Fruit Dash: A Solstice Platformer with Binary Code Gates

This is a submission for the June Solstice Game Jam

What I Built

I built Fruit Dash, a lightweight 2D browser platformer inspired by the bright, playful energy of June and the June Solstice.

Fruit Dash is a colorful pixel-art platformer where the player chooses a character, enters a 50-level world, collects fruit, avoids traps, fights enemies, activates checkpoints, and clears each stage by reaching the end flag.

The game includes:

• 50 generated platforming levels
• Character selection
• Level selector
• Fruit collection
• Jumping and double jumping
• Fireball/powerball attacks
• Enemies that scale by level
• Checkpoints and end flags
• Saws, spikes, fire traps, arrows, fans, trampolines, moving platforms, boxes, and surfaces
• Background music with mute/unmute control
• Mobile and tablet touch controls
• Turing Gate binary puzzles on milestone levels

For the June Solstice theme, I wanted the game to feel like a bright seasonal arcade adventure: colorful, energetic, full of motion, and centered around progression. The solstice is a turning point in the year, and Fruit Dash mirrors that through the way each level moves the player forward into new hazards, enemies, and mechanics.

I also added a specific Alan Turing-inspired mechanic: Turing Gates. On milestone levels, the exit is locked behind a small binary code puzzle. The player must shoot three binary switches until the bits match the target code. This connects the platforming gameplay to computation, binary logic, code-breaking, and Turing’s legacy in computer science.

Video Demo

Code

GitHub repository:

kris70lesgo / fruitdash

Fruit Dash

Fruit Dash is a lightweight 2D browser platformer built for the June Solstice Game Jam. It is a colorful fruit-collecting platformer about movement, progression, and small moments of code-breaking.

The game runs directly in the browser with plain HTML, CSS, and JavaScript. No heavy game engine is required.

Play

Live demo:

https://game-jade-one-25.vercel.app

Local run:

python3 -m http.server 4173

Then open:

http://127.0.0.1:4173/game-src/index.html

Features

• 50 generated platforming levels
• Home screen, level selector, and character selection
• Fruit collection with multiple fruit types
• Jumping, double jumping, checkpoints, and end flags
• Tiered enemies: mushrooms, Vomfy, slimes, and mixed late-game waves
• Fireball/powerball attack with character-specific colors
• Traps and movement tools: saws, spikes, fire, arrows, fans, trampolines, moving platforms, boxes, and surfaces
• Turing Gates on milestone levels with binary switch puzzles
• Looping background music with mute/unmute control
• Touch controls for mobile and tablet, including a fire button
• Vercel-friendly root entry page

Controls

• Move: A/D or…

View on GitHub

Live demo:

https://game-jade-one-25.vercel.app

How I Built It

Fruit Dash is built with plain HTML, CSS, and JavaScript. I intentionally avoided a heavy game engine so the game would stay lightweight, easy to deploy, and fully controllable in the browser.

The game runs on an HTML canvas. The player, enemies, fruits, traps, projectiles, platforms, checkpoints, Turing Gates, and HUD are all drawn and updated manually in JavaScript.

The visual style comes from pixel-art PNG assets and sprite sheets. The game uses sprites for characters, fruits, terrain, traps, enemies, fireballs, checkpoints, and UI elements.

The level system is generated in code. Each level creates a different combination of:

• Ground platforms
• Floating platforms
• Fruits
• Boxes
• Checkpoints
• End flags
• Moving platforms
• Hazards
• Trampolines
• Fans
• Enemies
• Turing Gates on milestone levels

Difficulty increases as the level number rises. Early levels focus on movement and collection. Later levels introduce more enemies, hazards, and tighter platforming situations.

Enemies are introduced by level tier:

• Early levels use mushroom enemies
• After level 10, Vomfy enemies appear
• After level 30, slimes appear
• After level 40, enemy types are mixed together

The player can shoot fireballs using Enter, mouse click, tap, or the mobile fire button. Fireballs use sprite-sheet animation and have character-specific colors. They disappear when they hit enemies, platforms, traps, switches, or other solid objects.

For the Turing-inspired mechanic, levels 10, 20, 30, 40, and 50 include Turing Gates. Each gate displays a 3-bit binary target. The player shoots three bit switches to toggle them between 0 and 1. When the current bit pattern matches the target, the exit unlocks.

I also added background music. The original audio file was an OGG file around 11 MB, which felt too large for a small browser game. I used FFmpeg to convert it into a smaller MP3 file, reducing it to around 4.1 MB and improving browser compatibility. The music loops after the first player interaction because browsers usually block autoplay audio until the user clicks, taps, or presses a key.

For mobile support, I added touch controls that appear automatically on touch screens. Mobile and tablet players can move, jump, and fire without a keyboard.

The game is deployed as a static site on Vercel. I also added a root index.html so the deployed URL opens correctly instead of returning a 404.

Challenges I Faced

One of the biggest challenges was making sure the collision system matched the visuals. At one point, some platforms had collision but were not visibly drawn because the wrong part of the terrain sprite sheet was being used. This made the character look like they were standing on invisible platforms. I fixed this by correcting the terrain tile coordinates and adding safer fallback drawing for platform types.

Generated level quality was another major challenge. Since levels are built in code, some objects were originally placed in awkward spots. Fruits could appear in cramped areas that were hard or impossible to reach. Fans could appear under platforms, pushing the player directly into a ceiling. I added a cleanup pass to the level generator that checks fruit placement, reduces overlapping fruit clusters, and only places fans where the upward air path is actually useful.

The arrow trap also needed redesign. Initially, touching an arrow restarted the player, which felt unfair and not very meaningful. I changed arrows into directional boosters so they become a movement mechanic instead of just another punishment.

Enemy sprite alignment was tricky too. Some enemy sprite sheets had transparent padding, so enemies looked like they were floating even when their collision boxes were touching the ground. I adjusted enemy drawing offsets so their feet visually line up with the platform.

Adding Turing Gates required balancing the puzzle with the platforming. I did not want to turn the whole game into a slow puzzle game, so I placed the binary gates only on milestone levels. That way the Alan Turing tribute appears clearly, but the main game still feels like an arcade platformer.

Audio also had browser-specific challenges. Modern browsers block autoplay audio, so the music starts after the first player interaction. I also added a mute/unmute button so the player has control.

Deployment had one final issue: Vercel initially showed a 404 because the actual game was inside game-src/index.html, not the project root. I fixed this by adding a root index.html that forwards to the game.

Prize Category

I am submitting for two prize categories:

Best Ode to Alan Turing

Fruit Dash includes a Turing-inspired mechanic called Turing Gates.

On milestone levels, the exit is locked behind a binary code puzzle. The game displays a 3-bit target code, and the player must shoot three binary switches until the switch values match the target.

This is an arcade-style tribute to Alan Turing’s legacy in computation, logic, code-breaking, and the foundations of modern computer science. I wanted the tribute to exist inside the gameplay itself, not only in the submission description.

The player solves a small binary logic problem, unlocks the gate, and continues the level.

Best Google AI Usage

Google AI helped throughout the development process. I used Antigravity IDE for development ,also while building and iterating on the game. It helped with code generation, debugging, gameplay iteration, layout fixes, and improving the structure of the app.

AI assistance was especially useful for:

• Debugging invisible platform issues
• Fixing sprite alignment problems
• Improving generated level placement
• Adding enemies and attacks
• Adding mobile controls
• Adding audio controls
• Optimizing the background music file
• Preparing the project for Vercel deployment
• Shaping the Turing Gate binary puzzle mechanic

I also used Gemini models / Gemini API workflows during the creative process for asset and image-related experimentation. The final game is still a browser-based JavaScript game using local assets, but Google AI helped speed up the design, development, debugging, and iteration process.