Bearly Baking

Itch.io: https://alexisbliesener.itch.io/bearly-baking

Project Info

Roles: Gameplay Programmer, Producer

Team Size: 7

Engine/Language: Unity , C#

Description

Bearly Baking is a cooking and relationship-building game where you play as a bear running an inn to feed animals for hibernation. You cook bread and muffins in small mini-games, and based on the quality, you build better relationships with your patrons and learn more about their stories.

Introduction

Bearly Baking is a cozy cooking and relationship-building game originally developed as a six-week class project by my team and me. It was recognized within our cohort, winning Best Aesthetics, Most Fun, and Most Innovative. I served as both the Gameplay Programmer and Producer on the project.

As the Gameplay Programmer, I was responsible for designing and implementing the core cooking mini-game. I created an intuitive drag-and-drop system that allowed players to interact with ingredients and baking tools fluidly. To ensure scalability, I built a modular, class-based system that could support multiple items and cooking mechanics, making it easy to add new content and iterate quickly. I also collaborated closely with the UI artist and SFX designer to align game mechanics with visual and audio feedback, ensuring that gameplay felt both responsive and satisfying.

As the Producer, I was responsible for managing our timeline, assigning tasks, and keeping the team aligned across all stages of development. I organized regular meetings, set up our workflow in tools like Asana and Google Sheets, and made sure milestones were hit on time. When we faced challenges, such as scope creep, unexpected bugs, or conflicting schedules, I worked with the team to reprioritize tasks and find efficient solutions without compromising quality. My focus was on creating a supportive environment where each team member could thrive and contribute meaningfully.

Our team was so passionate about the project that we chose to continue development beyond the class. We've since evaluated areas for improvement and are now focused on adding quality-of-life features and new content and release on Steam in August 2025.

Cooking Mini Game

Stations - Prototype

As the developer on the team, I implemented a fast, lightweight prototype of the game’s station system using simple colored rectangles. This allowed us to rapidly test gameplay interactions and iterate on core mechanics without waiting on final art assets. By prioritizing functionality over visuals in the early stages, I enabled the team to quickly evaluate the fun factor of the game and make informed decisions about system design and player flow. This prototyping approach significantly accelerated development and helped us identify what was working, and what needed improvement, early on.

Stations - Final

All three stations, Prep, Cook, and Toppings, are implemented entirely using Unity UI (uGUI) components to facilitate seamless mouse interactions via Unity’s IPointerDownHandler, IPointerUpHandler, and IPointerClickHandler interfaces. To ensure that core processes (e.g., oven timers) continue running even when a station is not visible, UI layers are toggled using hierarchy sorting instead of disabling GameObjects. This approach preserves background behavior across overlapping UI states. The interface is resolution-independent and optimized for all 16:9 aspect ratios. Dynamic UI interactions, such as determining when a spoon reaches a threshold to reverse stirring direction, are calculated using normalized screen-space coordinates to ensure consistent behavior across varying screen resolutions.

Item Class

ItemCodeSample.pdf

To build a scalable and modular item system, I created a base Item class, which serves as the parent for various specific item types such as Tin, Product, Dough, and others. This inheritance-based architecture allows for centralized logic and shared behavior across all item types, making it easy to apply global changes with minimal effort. The system is also highly extensible, new item types (e.g., toppings or dough variants) can be introduced simply by configuring new data entries (e.g., names and finished product references), with no code changes required. This data-driven approach ensures rapid iteration and supports future content expansion without refactoring core systems.

Item Spawner Class

ItemSpawnerCodeSample.pdf

Another key scalable system I developed is the ItemSpawner class, a reusable component used across all item spawners, including those for dough, tins, and toppings. By abstracting spawning logic into a single, modular script, I enabled designers to easily instantiate new spawners without writing code. The class is fully editor-friendly, allowing items to be swapped dynamically by simply dragging the desired Item prefab into the Inspector. This design promotes rapid prototyping, maintainability, and scalability, ensuring consistent behavior and reducing the need for redundant logic across the project.

Other Features

Screenshot Feature

The screenshot feature was designed to give players a visual glimpse of the food they prepared when delivering it to a patron. I use Unity's screen capture system to take a screenshot of the game view, saving it to a fixed file location. Before saving a new screenshot, the system checks for and deletes any existing image with the same name to ensure only one file is stored at a time.

The screenshot is saved using the user's application data path, combined with a consistent file name, making it easy to retrieve later when the player delivers the food. This approach minimizes storage usage, as only a single image file is ever stored at any given time.

In Cafe Movement

I implemented the in-cafe movement system for the player character, along with interactive mechanics such as picking up and discarding food items. When the player holds food, the character's animation changes dynamically using the Unity Animator. A boolean parameter in the Animator controls whether the character plays the "holding food" animation or the default idle/walking animations. This same boolean also governs item logic, preventing the player from picking up additional baked items while already holding one. This design choice was informed by user feedback, which indicated that holding multiple items was confusing. By integrating animation state control with gameplay restrictions, I ensured a more intuitive and responsive player experience.

Production

I served as the Producer for our project, overseeing the entire development process for our small team of seven members. In this role, I was responsible for a wide range of leadership and coordination duties that were critical to keeping the project on track and ensuring team cohesion.

My primary responsibilities included assigning tasks, defining and managing scope, resolving interpersonal challenges, and planning and facilitating regular team meetings. To ensure clear task ownership and progress tracking, I used a combination of Google Sheets and Asana to better manage tasks, deadlines, and team accountability. These tools helped maintain visibility across the team's work and allowed for agile adjustments to the project timeline and scope as needed.

For communication, I established a reliable system using Discord, which served as our central hub for both synchronous and asynchronous collaboration. I organized structured weekly meetings and spontaneous check-ins when needed to keep everyone aligned. I also created dedicated channels for task updates, bug tracking, and feature discussions to reduce miscommunication and keep discussions organized.

In addition to project logistics, I worked to foster a positive team environment, addressing any interpersonal conflicts promptly and fairly to maintain morale and collaboration. My leadership approach emphasized transparency, mutual respect, and flexibility, which helped the team stay productive and focused throughout the development cycle.

What I Learned

Refactoring for Scalability: Lessons from Early Prototyping

One challenge I faced was the need to refactor the item system into a more robust inheritance-based architecture. Initially, I implemented a single monolithic item class to rapidly prototype the game's core features. While this approach was effective for quick iteration, I postponed the refactor for too long. Transitioning to a proper object-oriented structure later in development required significant rework. Refactoring earlier would have streamlined the process, reduced technical debt, and accelerated scalability during the critical post-preproduction phase. This experience highlighted the importance of balancing rapid prototyping with forward-thinking system design.

The Value of Documentation in Long-Term Development

As the project evolved into a long-term endeavor with plans for a Steam release, I’ve come to truly appreciate the emphasis I placed on code documentation from the start. By consistently commenting my code and maintaining a clean, modular script structure, I made it easy to step away and return to the project without losing momentum. This approach has also proven essential in a team environment, where clear documentation and organization have enabled teammates to quickly understand and integrate with my systems. Moving forward, I plan to continue prioritizing well-documented, maintainable code in every project I take on.

Page updated

Google Sites

Report abuse