A physics puzzle game in the slingshot genre, written in Godot 4 with GDScript. You pull a bird back, read the predicted arc, release, and try to bring a wooden or stone structure down on the pigs inside it. Three birds per level, three levels, and every hit resolved by the engine's rigid body simulation rather than by a scripted outcome.

The interesting part is not the genre. It is that the game ships no images at all.

Built entirely with AI. Every line of code, every document and every physics constant in this repository was produced with OpenCode driving the DeepSeek v4 Flash (FREE) model. This is stated plainly because you deserve to know what you are reading before you review it or build on it.

There is no .png in this repository, no sprite sheet, no audio file and no font asset. Every texture you see is built at runtime: pixel_art.gd takes a text map and a palette and returns an ImageTexture.

# a sprite is literally written as text, one character per pixel
"...RRRR..."
"..RRRRRR.."
"..RWWRRR.."

The map goes in, Image.create plus set_pixel runs over it, and an ImageTexture comes out. The Art autoload builds every sprite in the game this way when the project starts, which is why the repository is a few dozen kilobytes of source and nothing else.

Rendering uses the NEAREST filter at a logical resolution of 1280×720, with the camera at zoom 3.5 — so a 16×12 pixel block becomes a chunky, readable object on screen.

The white dots are not decoration. They are the actual predicted trajectory, computed from the same equation the engine will integrate:

launch velocity = pull × 7.2         (pull is capped at 66 px)
y(t) = y₀ + vy·t + ½·g·t²            (g = 400 px/s², set in project.godot)

The dots are sampled from that curve and fade out where they meet the ground, and the red target marker sits at the computed landing point. It grows and becomes more solid as the tension increases, so the strength of the shot is readable without a numeric gauge.

If the prediction and the flight ever disagree, that is a bug worth reporting — they are supposed to be the same maths.

Nothing here is scripted. Every hit is a real collision, detected with body_entered and continuous collision detection on the fast bodies. The bird travels at roughly 500 px/s, which is about 8 pixels per frame — without CCD it would pass straight through a pig between frames.

The consequence is that a collapsing tower is a legitimate way to win a level, and often the efficient one.

1. On the title screen click INICIAR. SCORES opens your history.
2. Click the bird on the slingshot and drag backwards. The band stretches, the dots show the arc and the red marker shows where it lands.
3. Release to launch. The further you pull, the faster and further it flies.
4. Clear every pig to finish the level.

Scoring: 100 per block destroyed, 500 per pig, 5000 bonus per level cleared.

Scores are written to user://save.json by the Save autoload when you lose, quit with Esc or finish the game. The SCORES panel lists your last 10 runs with points, level and timestamp, plus your record and the furthest level you have reached.

Requires Godot 4.7+ on your PATH (winget install Godot.Godot).

git clone https://github.com/claudneysessa/one-shot-bird.git
cd one-shot-bird

.\run.ps1            # play
.\run.ps1 -Editor    # open in the Godot editor

Or directly:

godot --path ./src

one-shot-bird/
├── run.ps1              launcher (-Editor)
├── CHANGELOG.md         delivery history, with date and time
├── CONTRIBUTING.md
├── SECURITY.md
└── src/                 the whole Godot project
    ├── project.godot    gravity 400, NEAREST filter, autoloads Art and Save
    ├── menu.tscn/.gd    title screen, animation, score panel
    ├── main.tscn/.gd    slingshot, aiming, levels, camera, HUD, scoring
    ├── art.gd           autoload Art: every sprite and palette
    ├── pixel_art.gd     text map + palette → ImageTexture (RGBA8)
    ├── saves.gd         autoload Save: user://save.json
    ├── bird.gd          flight, rotation, particle trail
    ├── pig.gd           1 HP, dies to any real impact
    ├── block.gd         wood / plank / stone, HP and break tween
    └── band.gd          the slingshot band (draw_line)

Levels are defined in code, in _level1, _level2 and _level3 in main.gd, and settle into place by physics rather than by hand-placed coordinates in the editor.

Honest list, each one an open door rather than an excuse:

• Three levels. The level format is a handful of function calls, so adding a fourth is a small pull request — and a welcome one.
• No automated tests. The failure modes here are physical, and a token test suite would be worse than admitting the gap. pixel_art.gd and the ballistic prediction are the deterministic parts and the sensible place to start.
• Mouse only. No touch or keyboard aiming, so it is desktop-only in practice.
• No web build published. Godot can export to HTML5, but that export is not set up here, so there is no online demo to link to yet.
• The in-game text is Portuguese only. The HUD reads PONTOS, NIVEL and PASSAROS, as the screenshots show. Localizing the interface is an open task and a good first contribution.
• The physics is tuned, not balanced. Difficulty across the three levels was set by feel.

Contributions are welcome — levels, physics, balance, documentation and code. Read CONTRIBUTING.md first: it covers the no-external-assets rule, where the tuning constants live, and the play-test checklist that stands in for a test suite. Participation is covered by the Code of Conduct, and security reports have their own policy.

Built by Claudney Sarti Sessa using OpenCode and the DeepSeek v4 Flash (FREE) model, which generated the code, the documentation and the physics balancing.

One Shot Bird is an original game in a well-established genre. It contains no code, art, audio or other asset from any commercial title, and it is not affiliated with or endorsed by any other game or company — every pixel here is produced by the code in this repository.

Released under the MIT License.