Hey everyone. This past week was focused on getting our project into a playable demo state. Most of my time as lead QA and assistant gameplay programmer went toward making sure core systems behaved consistently and did not interrupt player flow. The priority was stability and clarity, especially in places where players would interact with the game most often.

The Problem

While implementing our item and inventory systems this week, I ran into a core issue with how our interaction interface was set up. At this point in development, true pickup items did not yet exist. Objects like the Campfire and Truck were already interactable, but they were world interactions rather than items that needed to be stored or owned by a player. As I started building pickups and inventory support, it became clear that the existing interaction flow was not designed with that use case in mind.

The main problem was that the Interact Interface did not pass in an actor reference. When I initially implemented pickup behavior inside MasterItem, I worked around this by grabbing the player pawn directly. That logic simply returned the first BasePlayer found in the scene. While this allowed early testing to move forward, it was not technically correct and introduced assumptions that would not hold up as the project grew.

This limitation became a real blocker once items needed to know exactly who interacted with them so they could be added to the correct inventory. Without a reliable actor reference flowing through the interface, pickups could not be implemented cleanly. Addressing this problem was important not just for the demo, but for the long-term structure of our interaction and inventory systems.

The Solution

I started by updating the Interact Interface so that OnInteract takes in an Actor reference. This allowed interaction events to correctly identify which actor initiated them. With that change in place, I restructured how item interaction logic was handled.

Instead of relying on item-specific activation logic inside Event Graphs, I refactored MasterItem to contain a virtual OnInteract function. Child items now override this function to handle their own behavior. This shifted interaction handling into a single, consistent path and reduced unnecessary duplication across items.

To fully resolve the issue, I also updated MasterItem overlap events to store a reference to the overlapping actor. That stored reference is passed directly into the Interact Interface call when interaction occurs. With this change, items such as Coffee are now reliably added to the inventory of the player who interacted with them.

Fixing this issue addressed a major blocker for the demo and improved the structure of our interaction system as a whole. Item pickups now behave consistently, and the code supporting them is easier to understand and extend.

Alongside other demo-focused fixes I worked on this week, this change helped move the game into a more stable and presentable state. From a player perspective, interactions feel dependable. From a development perspective, the system is better prepared for future content and iteration. Inventory is still being developed, but this was a notable obstacle that took some time to figure out. With this fix in place, inventory can be properly implemented moving forward.