Arizona Bones

Role: UI Systems Programmer

Contributions:

• Developed modular UI gameplay systems including inventory management, crafting interfaces, and progression-based journal navigation using Unity UI, C#, ScriptableObjects, and event-driven architecture

• Built dynamic runtime UI pipelines by generating inventory slots, crafting ingredient displays, and unlockable journal content through prefab instantiation, serialized data structures, and state-driven UI management

• Implemented player progression systems by connecting exploration triggers, unlock states, and persistent save/load functionality using collision events, PlayerPrefs serialization, and runtime state tracking

• Designed cross-platform menu navigation supporting mouse, keyboard, and controller input using Unity Input System, EventSystem navigation, and accessible UI selection flows

• Integrated gameplay systems with UI feedback by linking item collection, crafting validation, and journal unlock events to popup notifications, icon indicators, and contextual interface updates

Project Information:

Released: December 2024

Duration: 4 Months

Engine: Unity

Platforms: Windows, Mac, Xbox, Playstation

Language: C#

Tools: Burndown chart, Trello, Discord, Github

Team Size:  10

Inventory

Built a modular inventory framework in Unity that manages item collection, stackable item logic, hotbar assignment, and dynamic UI updates through an event-driven architecture. Designed the system around reusable item data, centralized inventory state management, and runtime UI generation to support scalable item interactions without tightly coupling gameplay logic to interface behavior. 

Core Functionality

• Stores and manages collected items through a centralized inventory system

• Supports stackable and non-stackable item behavior, including stack limits and quantity tracking

• Handles item addition, removal, and inventory validation checks for gameplay systems such as crafting, usage requirements, or progression gating

• Uses event-driven updates to automatically refresh connected systems whenever inventory state changes

• Dynamically generates inventory slots at runtime based on current inventory contents

• Separates key items into dedicated hotbar / core item slots for quick player access

• Integrates item collection feedback through pickup popups and UI notifications

• Supports both mouse and controller navigation for inventory interaction through Unity’s UI EventSystem

Breakdown

• Built a centralized inventory management system by implementing item storage, stack handling, and quantity validation using C# Lists, singleton architecture, and reusable ScriptableObject item data

• Implemented stackable item logic by creating dynamic stack merging, max stack enforcement, and multi-item removal systems using conditional item checks, list searching, and runtime item instantiation

• Developed an event-driven UI pipeline by broadcasting inventory state changes and automatically rebuilding inventory slots when items were modified using delegates, callback events, prefab instantiation, and Unity UI systems

• Created dynamic inventory and hotbar interfaces by generating item slots at runtime and routing core items into dedicated quick-access slots using Transform hierarchies, prefab-based slot creation, and runtime UI population logic

• Integrated gameplay-facing inventory feedback by connecting collected items to popup notifications, hotbar assignment, and player interaction systems using manager communication patterns and event-based hooks

Crafting

Developed a reusable crafting system that integrates inventory management, recipe validation, and UI feedback into a cohesive player progression pipeline. Built with ScriptableObject recipe assets and dynamic runtime UI generation, the system enables scalable content authoring while clearly communicating crafting requirements and availability to players. 

Core Functionality

• Defines crafting recipes as reusable ScriptableObject assets containing output items and required ingredient lists

• Validates crafting requirements by checking player inventory quantities against recipe ingredient costs

• Automatically removes required ingredients and adds crafted results when crafting succeeds

• Generates recipe descriptions dynamically based on ingredient data for clear player-facing requirements

• Activates crafting interfaces contextually when players are within range of crafting stations

• Dynamically builds ingredient UI slots at runtime based on the selected recipe

• Provides visual feedback by graying out missing ingredients and highlighting available materials

• Reuses shared inventory systems for item validation, removal, and crafted item insertion, creating a connected gameplay pipeline

Breakdown

• Built a reusable crafting recipe system by defining craftable items, outputs, and ingredient requirements through ScriptableObject inheritance, serialized ingredient data, and object-oriented item behavior

• Implemented inventory-driven crafting validation by checking recipe requirements against player inventory quantities and consuming materials on success using inventory query functions, item removal pipelines, and runtime item insertion logic

• Developed contextual crafting interactions by enabling crafting interfaces only when players were within usable station ranges using proximity checks, world interaction triggers, and state-based UI activation

• Created dynamic crafting UI generation by instantiating ingredient slots at runtime and visually communicating recipe availability using Unity UI prefabs, sprite swapping, and state-based visual feedback systems

• Integrated crafting into the broader item pipeline by connecting recipes directly into inventory storage, consumption, and item acquisition systems using shared manager architecture and reusable gameplay data structures

Journal

Developed a progression-driven journal system in Unity that allows players to unlock, navigate, and revisit pages as they progress through the game world. Built the system around modular page data, checkpoint-based content unlocking, persistent save state tracking, and dynamic tabbed navigation to create an interactive in-game knowledge system that integrates exploration, UI, and player progression. 

Core Functionality

• Stores journal content as modular page objects that support both single-page entries and two-page spreads

• Unlocks new journal pages dynamically through world-based checkpoint triggers tied to player progression

• Supports persistent save/load functionality so unlocked journal content carries across play sessions

• Organizes journal entries through tabbed category navigation for structured content browsing

• Tracks viewed vs. newly unlocked pages and displays notification icons for unread content

• Handles page flipping between unlocked entries while automatically skipping locked pages

• Dynamically opens / closes alongside other UI systems while managing cursor state and gameplay pause behavior

• Supports controller / keyboard navigation using Unity’s EventSystem for accessible menu interaction

• Displays unlock notifications in-world when new journal content becomes available

Breakdown

• Built a progression-based journal framework by designing unlockable page structures, spread layouts, and categorized navigation using serialized page data, enum-driven page types, and modular UI prefabs

• Implemented world-driven content unlocking by connecting player trigger checkpoints to specific journal pages and spreads using collision triggers, event-driven unlock logic, and runtime UI notifications

• Developed persistent journal progression systems by saving and restoring unlocked page states across sessions using PlayerPrefs serialization, runtime state reconstruction, and unlock tracking lists

• Created dynamic journal navigation systems by supporting tab selection, page flipping, locked page skipping, and spread presentation using Unity UI Buttons, EventSystem navigation, and runtime page state management

• Integrated player-facing feedback systems by tracking newly unlocked but unread entries and surfacing notification indicators using state lists, UI icon toggling, and viewed-content tracking logic

Post-Mordem

Developing the inventory, crafting, and journal systems significantly changed how I think about gameplay programming. Early in the project, I approached each feature as a standalone mechanic that needed to function on its own. As development continued, I began to understand that stronger engineering comes from creating modular systems that can interact with one another, scale with project needs, and be reused across multiple gameplay experiences. That shift in perspective pushed me to focus less on isolated implementation and more on building flexible frameworks that could support future development.

One of the biggest technical lessons came from working with data-driven architecture. Using ScriptableObjects for item definitions, crafting recipes, and configurable game data taught me the importance of separating content from logic. This made the systems easier to expand, easier to maintain, and much more adaptable when new features or design changes were introduced. It also helped me better understand how strong engineering supports iteration by making systems easier for both programmers and designers to work with.

Building UI-heavy systems like the inventory and journal deepened my understanding of state management and player interaction. Managing menu transitions, controller navigation, dynamic UI generation, and persistent progression systems taught me that UI programming is much more than creating screens. It is about designing interactions that feel intuitive, responsive, and accessible across different devices and control schemes. This experience strengthened the way I think about usability, feedback, and how players engage with systems over time.

Perhaps the most valuable lesson I took from this project was learning how important scope and iteration are during development. Large features become much more manageable when they are broken into smaller, achievable goals with clear milestones. Setting realistic sprint objectives helped me stay focused on meaningful progress while remaining flexible enough to adapt when project needs changed. That balance between planning, iteration, and adaptability became one of the most important skills I developed through this work.

Overall, this project taught me to think beyond simply making systems functional. It taught me to build systems that are scalable, maintainable, and designed with change in mind.