This is a game to demonstrate the capabilities of the Dot collection built on-top of Godot 4 and TMC's gaming platform. In this 2D game, players start off as a small monster and grow by consuming food and other players. You may use space to split and throw yourself at others. This is heavily inspired by the cell-eating browser games!

Play on my test server here!

This project and the assets under it are COMPLETELY OPEN SOURCE. You are free to use, modify, and distribute them under the terms of the MIT license. The only thing not open source is the back-end web infrastructure. So if you opt into using your own authentication backend instead of integrating with TMC, you will need to build and integrate your own back-end infrastructure.

This project, along with every asset it is built on, was built initially with Claude Code and will continue to be maintained and extended using it. This is because I (gamemann) cannot build the entire TMC platform alone (I wish I could lol).

Please treat this as partially tested. It has its own headless test suite and that suite passes, but very little of this has been in front of real players yet. Expect rough edges, and please report anything you run into.

I intend on reviewing code, testing, and editing documentation regularly. If you're interested in helping out, please let me know!

Your mass is your size, your speed and your score. The bigger you are, the slower you move: twice the mass is about 26% slower. Your avatar rides on top of your monster.

• Eating. You can eat a monster that is at least a quarter smaller than you once you are properly on top of it. Every monster has a ring: green if you can eat it, red if it can eat you.
• Food comes in four sizes. The big pieces are rare, so the fastest way to grow is eating other players.
• Fruit gives you eight seconds of something: rush (faster), maw (eat players closer to your size) or rind (absorbs one burst).
• Throwables are picked up off the ground. A pepper bursts whoever it hits into five pieces, a frostberry slows them, and a lure drops a ring of food where it lands.
• Splitting throws half of you forward to catch someone. Your pieces can't merge for sixteen seconds, so each one is easier to eat.
• Ejecting spits out a little mass to make you smaller and faster.
• Loadout. Before you spawn, pick a starting throwable and a trait: nimble (faster, smaller start), sturdy (bigger start, slower) or greedy (more from food, smaller start).

Mass above 260 slowly decays, so you can't just park in a corner. When you are eaten, you watch whoever ate you until you respawn.

There are six modes:

On a phone, drag to steer, and there are buttons for split and throw.

You need Godot 4.7. The game is built from many Dot addons, each in its own repository, so the easiest way to get everything is dot-bootstrap. It clones every project and links the addons into each one:

git clone https://github.com/modcommunity/dot-bootstrap.git
cd dot-bootstrap
./bootstrap.sh
cd projects/game-hungario
./game.sh

On Windows, run bootstrap.ps1 instead and open the project in Godot.

game.sh does everything else:

online and server use dot-server-deploy, which bootstrap clones next to this one. Run its ./setup.sh once first.

Settings are cvars. Set them in the server's config, on the command line, or live from the console. cvarlist hungry_ lists them all.

bot_quota 6                   // players the arena is kept at with bots; each person who joins replaces one
bot_quota_mode fill           // fill (as above), fixed (that many bots), per_player (that many per person) or off
hungry_hunters_on 0           // release NPC hunters into the arena
hungry_hazards_count 0        // rocks scattered into the arena at load
hungry_outgrown ""            // a monster stuck in a refuge it outgrew: accept, cap or eject (empty: the mode's own)
hungry_avatar_pack ""         // manifest URL for this server's rider content

The bot cvars are the family's shared ones (dot-server's DotBotQuota). hungry_bots N still works and means what it did, N bots beside everybody: it sets bot_quota N and bot_quota_mode fixed. It is deprecated.

Console commands:

These come from dot-moderation, and modtools lists what this game supports. blind <player> [on|off|seconds] blacks out that player's screen, and beacon <player> [on|off] rings their monster on every screen and pings once a second. Both last through being eaten.

The vote for the next mode is dot-vote. The defaults are in game/hungry_maps.gd. To change them, put a file at user://cfg/hungry_vote.json (or use DOT_VOTE_* environment variables, or --vote-* arguments):

{ "end_vote": true, "vote_lead_sec": 120, "include_extend": true, "extend_seconds": 300, "max_extends": 2 }

end_vote: false turns the end-of-mode vote off, and include_extend: false takes "extend" off the ballot. dot-vote's README lists every setting.

Volume, camera smoothing, zoom, the minimap, names, the kill feed and the threat rings are in the pause menu. They are saved to user://cfg/hungry.json.

The rider on your monster is your avatar from the platform. Its parts come from a signed content pack when the server has one, from the game itself when it doesn't, and are drawn from their colours when there is neither. To build and publish an avatar pack:

godot --headless --path . res://tools/publish_avatars.tscn

web/README.md explains the browser build. In short, the server has to listen on WebSocket (browsers have no UDP), and an HTTPS page needs a wss:// address.

./game.sh test                    # every script parses, then every suite runs
./game.sh test headless_round     # one suite

CLAUDE.md has the rules, and docs/ the design decisions and the reasoning behind them.

There are no audio files: every sound is generated when the game starts.

MIT. See LICENSE.