Snake Rogue is a traditional roguelike that I am making with C++ and SDL3 to improve my programming and game design skills.
It is still a work-in progress, so this document gives an overview over the game's design and other aspects.
The project's code can be found at https://github.com/ButterJ/Snake-Rogue

In Snake Rogue, a snake is cursed to satiate its never-ending hunger, having to thrive inside a jungle filled with ancient ruins and monsters, adapting to the dangers by growing and mutating its body.

In Snake Rogue, a snake hatches on a stone pedestal surrounded by ancient ruins in the middle of a jungle. The snake has an insatiable hunger and explores the jungle to eat more and more food.

In the jungle, the snake will encounter food which can be eaten, monsters which must be fought, and ruins which hold secrets. The jungle consists out of multiple separate areas. To reach the next area, a connecting tunnel must be found. Each area will be more difficult than the last with more frequent and dangerous monsters.

The snake consists out of multiple body parts and has a maximum amount of body parts. In combat, a body part can be destroyed, slicing off all the body parts following it. When eating something, the snake is able to regrow previously lost body parts. If the maximum body size is reached, the snake levels up, choosing one of three mutations (e.g. + 1 maximum body size).

Additionally, pieces of equipment can be found and equipped to separate body parts of the snake, enhancing its stats and giving it bonus effect or abilities.

If all the body parts of the snake have been destroyed, the snake dies and the run is over. When starting a new run, the snake hatches from a different stone egg in a new randomly generated environment without keeping any of the equipment or mutations that were previously acquired.

I chose to design a traditional roguelike as it allows me to put less work into the visual design of, and instead focus on the roguelike design, user experience, and programming side of the project. This game is made with C++ and SDL3 instead of using a game engine, allowing me to learn about aspects of programming and game development that I do not have to think about otherwise.

The game itself is a unique twist on the traditional roguelike genre. It keeps the elements that players consider vital for a traditional roguelike, such as turn-based combat, but adds a single base thought that makes the game unique and allows design decisions to be structured around. The question that this game is based around is "What if the player character was a snake that can grow in size, similar to Blockade or the Snake games?".

Design pillars are used to focus the design of the project throughout its development. For this project, the design pillars focus on the player experience that engages players.

Novelty is the most central design pillar to Snake Rogue. This is because novelty is arguably the aspect that engages players to play roguelikes and to continue playing them.

Playing Snake Rogue, each run should feel different each time. This will be achieved through absolute novelty from encountering game elements with new aspects and relative novelty from experiencing game elements in different organisations. Additionally, novelty will be achieved through players improving and learning about the game, allowing them to encounter novel game elements and changing their perception of already encountered game elements.

Players should be engaged by starting out weak and growing in strength throughout the run, creating a power fantasy. However, through permadeath, players can loose their run and their character progression along it.
This engages players through improving their player character during a run, achieving growth in a run which they can remember and strive for.

Players should be engaged through being able to pursue different strategies. Players will have competing objectives for which players need to act differently, making players think about what they value and make strategic decisions. Through the random nature of the game, players will have different objectives and are not always be able to go for the same strategy, making them to adapt and use different strategies each run. Replaying the game allows players to try out different strategies, or be able to optimize a certain strategy.

Players will be able to improve through failure, motivating them to play again with their newly gained skills. While playing, new mechanics are encountered and players are able to collect additional information about already encountered game elements.
To achieve this, the game should have elements that motivate the player to play again, even after failure. Players should be encouraged to view a failed run as a positive experience. This could be achieved by players taking their improvement or learning as a positive outcome or by having reached a personal goal.

This game is made for people who like traditional roguelikes for their turn-based combat and strategic decision making. However, it is not made for roguelike purists who may discount this game as being a true roguelike for not complying to a specific opinion on how the genre should be.

Instead, the game aims to be intriguing with its inviting visuals and gameplay premise to allow it to be played by players that are not familiar with traditional roguelikes. In particular, players of modern roguelikes are targeted to play this game.

In Snake Rouge, the player controls a snake that consists out of multiple body parts. As a creature, the snake can have a maximum amount of body parts. When moving in a direction, the head moves and the other body parts follow it. Each body part has its own health. When a body part reaches 0 health it dies and disappears. All body parts that are after the dead body part will dislocate from the snake, turning into food. When the head dies, instead the head disappears and the next body part will become the new head.

When the player snake loses all its body parts, the run is lost and a new run must be started. Each run happens from the beginning without keeping any in-game progress of the last run. To make each run feel different, the jungle that the game plays in is procedurally generated every run.

To generate the jungle, a mixture of different procedural generation techniques are used.

First, binary space partition will be used to create simple room shapes that will be used as a base for the next steps.

Then, the diffusion-limited aggregation algorithm with center attraction will be used and ran on each room in isolation. This adds a more random looking shape to the rooms, adding to the feeling of a natural jungle, not a humanly built one.

To clean up the generated map, tiles that have 3 or more empty neighbours will be removed again. This way, the map will be traversable by the player character without being stuck in a 1-wide tunnel.

After, the rooms will be connected with 2-wide tunnels, as described in the binary space partition algorithm.

Then a starting tile for the player is selected. This point is used to decide where the exit tunnel, monsters, items, and other elements spawn, by measuring the distance to the starting tile using a Dijkstra Map. For example, monsters should not spawn too close to the starting position, and the exit tunnel should be at the furthest away position.

Snake Rogue has a turn-based system, giving the player as much time as they want to strategically think about their next actions.

Each tick, the turns of all turn-based entities are processed until player input is needed.
A turn-based entity has an amount of current energy, an energy cost for taking an action, and an energy regeneration rate. When it is processed, the current energy is increased by the energy regeneration rate. If enough energy is available for taking an action, that energy is removed and the action is taken.

This allows different entities to have different energy regeneration rates and action costs, meaning that one entity may do two actions before another entity can do one action.

In the jungle there will be different kinds of monsters to fight. These monsters will mostly only have one body part to make the multiple body parts of the player feel special. However, some monsters should have multiple body parts as well.

To fight a monster normally, the players snake's head will deal damage when bumping into (walking into) a monster. Monsters will also attack the player, deciding which body part of the player to target based on their behaviour.

When a monster has been defeated, it will drop its body as food that can be eaten as well as a chance of dropping other loot.

Snake Rogue does not have a hunger system where satiation is lost every turn. This has been decided against as it punishes players for suboptimal uses of their movement and actions in a way that does not feel good for many players.

Instead, each creature controlled by the player (usually just the main player snake) will have its own satiation bar. When eating food, the foods satiation value gets added to the creature who ate the food. If the satiation bar is full, one of the following things happen:

The player has a player level. Points are added to the player level through different factors. When enough points are acquired, the player levels up and chooses a mutation. The player will have a randomized choice of 3 mutations to choose from. Each mutation will change how the game is played, opening up choices for different builds and making players take decisions.

For example, one of the mutation choices may be to increase the maximum amount of body parts that the player snake can have. This would allow the player to wear more equipment, extend their chances of survival, and interact with other game elements (see Snake specific jungle elements). Another choice may be to reduce the maximum amount of body parts, but increase another stat of the player (e.g. damage or armor). This would make the survival of the player depend on less body parts and make it easier to die, but have a synergy with other game elements (also see Snake specific jungle elements).

Each creature will have different stats. These stats need to be defined in further detail in another document. Here are some example stats:

Here are two examples for equipment:

The following shows an example of a UI screen for equipping items to different body parts in Caves of Qud:

The jungle should be designed to utilize unique aspect of a snake with multiple body parts as the player character.

For example, a ruin could be in the jungle with multiple pressure plates on the floor. If all pressure plates are pressed down at the same time, a door or a chest opens. A snake with enough body parts can cover all buttons at once, rewarding them for having that many body parts.

Furthermore, a tunnel with spikes in a distance of 3 tiles could exist. These spikes will deal damage to anything that is on them every 2 turns. A snake that is longer than 3 tiles would be forced to take damage if choosing to slither that way. However, a snake with 3 or less body parts could wait in-between these spikes to take less damage or non at all.

The game will be top-down with 16x16 pixel-art tiles.
A resolution of 16x16 pixels has been decided on for the tiles as they are big enough to allow for detail, while not being so big that they are too difficult to work with.

Two different options for the artstyle of the tiles will be offered:

The traditional ASCII tiles will be inspired by the ASCII tiles of the game Brogue.
In the game Brogue, ASCII tiles have different background colours, which makes them look visually pleasing and enables to convey additional information.
However, unlike the Brogue tiles, the tiles for Snake Rogue will be square.

The modern graphical tiles will be square pixel art tiles, visually resembling the environment of a jungle with ancient ruins.

The visual design of the snake will be inspired by the updated design of the snake games on Nokia phones.

As the game environment is a jungle with ancient ruins, the colours used for the environment should be the following:

The following two pictures depict grass tiles. In the first image, I like the vibrant colours and want to highlight the detail that is possible with using 8x8 tiles. The second picture shows 16x16 grass tiles which can be used as inspiration for the shape of the grass.

The next picture is not at all to be taken as a reference for the level of detail of the environment, as the resolution is too high. However, it can be used as a visual reference for overgrown jungle ruins, particularly the colour combination of it.

In a jungle, a snake hatches from an egg on top of a stone pedestal. The snake is born with an insatiable feeling of hunger, which does not disappear, no matter how much it eats.

The snake eats itself through the fruits, berries, and creatures of the jungle, hoping to find a meal that will finally satiate it.

Inevitably, the snake gets defeated by the dangers of the jungle. However, instead of dying and being released from its eternal hunger, it hatches with a new body from an egg on a different stone pedestal.

Thus, the snake is damned to try to explore the jungle to finally find something that will satiate its hunger.

Visuals of an egg from "The Legend of Zelda: Link's Awakening", as a visual representation for the egg(s) that the snake hatches out of.