Grow plants. Make friends.

Engine: Unity

Platform: PC

Extent: 5 Months

Year of launch: 2025

Average session: ~ 25 mins

Genre: Cozy, Casual, Nature, City-Builder

Language: C#

Animation

For the villagers I built a custom animation system that sits on top of Unitys Animator instead of relying on the usual Animator Controller setup. I wanted full control over when animations start how long they run and how they blend. Doing it in code gave me that freedom and it made the whole system feel very predictable and easy to extend.

Each animation is defined through a small data object that holds everything it needs like optional entry and exit animations and optional random play times. The controller reads these data objects and handles all transitions. Idle animations run in a smart loop that avoids repeating the same clip twice in a row. Entry and exit clips are played when needed. Swim and fidget states take over seamlessly based on player interaction or the villager height in the world.

Everything is handled through coroutines that wait for real animation lengths inside the Animator. This makes the timing feel natural and keeps the code in sync with the actual clips. The system turned out very stable and it was fun to work on. It gave me a lightweight alternative to a full state machine while still keeping the flexibility of Unitys Animator under the hood.

If needed I could add new animations or whole new states within minutes which was one of the most satisfying parts of the project.

Commands

After getting the request in almost every playtest we built a full command based undo and redo system that works across placement, placeable deletion, terraforming, terrain-painting and villager movement. It became one of the most important quality of life features in the project because it let players experiment freely without fear of messing anything up.

The system is built around simple command objects that store everything needed to undo or redo a change. Every action the player performs creates a command and pushes it into the undo stack while clearing the redo stack. Each command knows how to restore the state it changed which keeps the logic easy to follow and very flexible. The manager responds to gameplay events and wraps them into commands so the whole system stays automatic.

The manager also handles stack trimming, input handling and UI updates which made it feel lightweight during play. Undo and redo works for single objects and batches of objects and even complex actions like terraforming store full before and after states so the world can be restored exactly.

This system was surprisingly easy to build. It gave the game a sense of safety and freedom that players reacted well to. Looking back it is one of the parts of the project I am most proud of because of how cleanly it integrated with everything else.

Decorative Animals

For the decorative animals I built a lightweight behaviour system that makes the pond feel alive without affecting gameplay. Each creature type has its own simple movement rules and shader driven animations. The base class handles wandering speed changes visibility and bounds so new species were easy to add. Dragonflies hover and dart with wobble noise, butterflies tilt and roll as they move and fish gently drift with shader based swimming. Birds fly in flocks that spawn offscreen and travel across the world in different formations.

New Animals are spawned randomly, but with every placed object theres a chance of a related animal spawning attached to it. So when placing a flower theres a chance for any animal to spawn but an increased chance for a butterfly or with water plants there's a high chance for fishes to spawn under it. If the placeable that spawned this animal is deleted the animal is removed aswell. This relation is actually even saved in the save games.

Each animal has it's own spawning and movement behaviour, but all have a defined box in which they randomly move around in. If modes like terraforming or placement are exited, each animal raycasts if they are still in a valid spot and if not they reposition and create a new box in valid bounds.

The whole system uses object pooling and randomized behaviour so the creatures feel organic and are inexpensive to run. The animals were received very well, they added a lot of charm to the world and more visual movement in the world making it more alive especially in the beginning.

Save-System

Everything that needs to remember its state implements a small memento class so each system stays self contained. The central SaveGame object collects all these snapshots and writes them out in a single pass while a separate meta file keeps track of playtime, game mode and a thumbnail for the save slot.

Autosaving is async and runs on a settable timer not even creating a stutter when saving mid-gameplay. Creating and deleting save slots fires events that keep the UI in sync. Screenshots for save previews are generated on demand and stored as lightweight JPG bytes in the meta file.

Modes

The game uses a set of basic modes that decide what the player can do at any moment. Each mode has a small state class that only handles its own behaviour. The GameModeManager just switches between them and raises OnChanged events, making it a classic state machine.

E.g. Placement, deletion, terraforming and painting mode each activate their own menu on enter and close them again when the player leaves the mode. Deletion mode is a good example. It only listens for input while it is active and collects all objects the player marked for removal. If the player cancels, everything is shown again. If they confirm, the objects are removed.

The system stayed very clean. Each mode minds its own business and the manager handles the rest. It made it easy to add new features without running into technical chaos.