Unique Artstyle

The art style of “Office Duck” stands out for its whimsical, hand-drawn aesthetic that marries flat, cartoon-like illustrations with a subtly eerie edge. Each character, from Elon Duck in a top hat to the office workers hustling between cubicles, is rendered in bold outlines and simple yet expressive shapes. The color palette leans toward softer hues for office scenes, giving them a playful, storybook feel that invites the player in. Yet, the same style takes on a haunting quality in darker, more foreboding environments, where stark contrasts of red and black highlight the unsettling underbelly of Nestla. This blend of playful and unsettling visuals underscores the game’s core theme: that there’s more lurking beneath the surface of a supposedly ideal workplace.

What truly separates “Office Duck” from other games is its balance of lighthearted cartoon flair and atmospheric tension. While many titles opt for hyper-realistic graphics or purely comical art, “Office Duck” fuses a deceptively cheerful, almost children’s book with suspense and horror elements. The consistently drawn, thick outlines and the minimal shading unify the world, but the shifts in color scheme—from pastel office cubicles to shadowy rooms lit with ominous red glows—keep the experience engaging and unpredictable. This art direction not only lends the game a distinctive visual identity but also enhances the storytelling, making each discovery feel both whimsically charming and deliciously unsettling.

Work Examples and Explanations

Robust Task Manager

The Task Manager is the largest and most pivotal tool I developed for “Office Duck”, providing a unifying structure that ensures every piece of the game fits together seamlessly. Although it’s not an especially long script, its influence on the project is monumental, as it ties together the numerous systems and scripts into a single, coherent framework. By orchestrating all in-game events in a chronological sequence, the Task Manager empowers both designers and artists to contribute to the narrative flow without delving into code. This careful ordering guarantees that each interaction, story beat, and gameplay mechanic follows the proper rules, creating a smooth progression from one event to the next. In short, it’s the backbone that keeps the entire game running in sync.

What truly sets this system apart is how it manages the activation and behavior of every “interactable” element in the game. Rather than requiring intricate programming knowledge, the Task Manager invites team members of all disciplines to simply place the interactables in the correct order and let the script handle the rest. This user-friendly approach streamlines the creative process, freeing designers and artists to focus on crafting compelling scenes and story moments without wrestling with technical hurdles. As a result, the Task Manager fosters a more collaborative workflow, allowing anyone on the team to shape the game’s world and progression with minimal friction.

The Interactables

public class Interactable : MonoBehaviour
{
    private void Start()
    {
        if (forcePlay)
        {
            this.Interact();
        }
    }
    public virtual void Interact()
    {
        PlayerMove.puzzleMode = true;
        UIManager.InteractionPopup.SetActive(false);
    }
    public virtual void Action() { }
    public virtual void Complete()
    {

		if (activatePostPuzzle)
        {
            foreach (GameObject thingToActivate in objectToActivate)
            {
                if(!counted)
                    if (thingToActivate != null)
                        if (thingToActivate.GetComponent<DoorInteract>() != null)  
                        {
                            thingToActivate.GetComponent<DoorInteract>().isLocked =
                            !thingToActivate.GetComponent<DoorInteract>().isLocked;
                        }
                        else
                        {
                            thingToActivate.gameObject.SetActive(!thingToActivate.gameObject.activeSelf);
                        }
            }
        }
        isCompleted = true;
		UIManager.InteractionPopup.SetActive(true);
		TaskManager.onTaskComplete(this);
    }
    public virtual void Failed()
    {
        TaskManager.onTaskFailed(this);
    }

The code above lays the foundation for every interactive element in Office Duck, serving as the parent class for all items the player engages with—be it talking to a quirky duck or diving into a challenging minigame. At its core, the Interactable class encapsulates essential variables and methods that define common behavior: flags like repeatable to determine if an interaction can occur multiple times, and booleans such as isCompleted or hasFailed to track progress. In the Start method, for instance, if forcePlay is set to true, the interaction is triggered automatically, ensuring that scripted events begin without delay. The primary Interact() method not only initiates the interaction by switching the game into puzzle mode but also manages the UI by deactivating any default interaction popups. With placeholder methods like Action(), developers have the flexibility to extend or override behavior for specific interactions while maintaining a consistent baseline across all interactable elements.

Crucially, this system is seamlessly integrated with the Task Manager, a central tool that orchestrates the game’s narrative flow. When an interaction reaches its conclusion via the Complete() method, the code not only updates the interaction’s status but also activates any related game objects—like toggling door locks or enabling hidden areas—and then communicates this change to the Task Manager through TaskManager.onTaskComplete(this). Similarly, if an interaction fails, the Failed() method notifies the Task Manager, ensuring that every narrative beat and event is accurately tracked and executed in the correct sequence.

What I Learned

Working on “Office Duck” has been an invaluable journey in bridging the gap between technical programming and creative design. Through this project, I learned how to architect systems—like the task manager and the foundational Interactable class—that empower both developers and creative team members to contribute seamlessly. By building flexible tools that abstract complex interactions into manageable components, I discovered the importance of designing code that is not only robust and scalable but also accessible to non-programmers. This approach has allowed us to maintain a cohesive game flow while accommodating rapid creative iterations, ultimately enhancing both the development process and the player experience.

In addition, the project deepened my appreciation for the symbiotic relationship between technical precision and artistic vision. I honed my skills in Unity and C#, learning to develop systems that support dynamic narrative progressions and interactive gameplay without sacrificing code maintainability or clarity. This experience underscored the value of cross-disciplinary collaboration—demonstrating how thoughtful tool design can empower artists and designers to innovate without getting mired in technical details. Overall, Office Duck has not only sharpened my technical expertise but also enriched my understanding of how well-integrated systems can elevate the storytelling and overall quality of a game.