The Challenge

Create a cooperative puzzle experience that requires multiple players to help each other from their own individual game copies. The key challenge was designing mechanics that depend on shared knowledge and collaboration across separated gameplay sessions.

What I Built

• Programmed smooth first-person walking, looking, and jumping controls with simple, clean input handling

• Developed interaction systems allowing players to press buttons and type in UI input fields within the 3D environment

• Implemented puzzle logic that depends on asynchronous cooperation between multiple players in separate game instances

• Built minimalist UI elements consistent with the black-and-white style to provide clear feedback

• Optimized input handling and interaction code for seamless player experience despite minimalistic design constraints

My Technical Contributions

1. Scalable Puzzle Progression System

Problem: Design puzzles that require exponentially more players (1 → 4 → 50+ players) while maintaining fair progression tracking.

Solution: Created a dynamic system that tracks community contributions and scales puzzle requirements based on collective progress.

public class PuzzleProgressionManager : MonoBehaviour
{
    [SerializeField] private PuzzleRequirement[] puzzleRequirements = {1, 4, 50, 200};
    [SerializeField] private CommunityProgressTracker communityTracker;
    
    public bool CanProgressToNextPuzzle(int currentPuzzle)
    {
        int requiredPlayers = puzzleRequirements[currentPuzzle];
        return communityTracker.GetActiveContributors() >= requiredPlayers;
    }
    
    public void UpdatePuzzleAccess()
    {
        for(int i = 0; i < puzzleRequirements.Length; i++)
        {
            puzzles[i].SetAccessible(CanProgressToNextPuzzle(i

Result: Seamless progression system that enforces collaboration while providing clear feedback on community requirements.

2. Robust Button Interaction System

Problem: Implement precise button interactions that register properly and prevent accidental triggers with only walking and interaction as core mechanics.

Solution: Built a reliable interaction framework with proper collision detection and state management.

public class ButtonInteractionSystem : MonoBehaviour
{
    [SerializeField] private LayerMask interactableLayer;
    [SerializeField] private float interactionRange = 2f;
    private InteractableButton currentButton;
    
    void Update()
    {
        DetectNearbyButton();
        
        if(Input.GetKeyDown(KeyCode.E) && currentButton != null)
        {
            AttemptInteraction();
        }
    }
    
    private void DetectNearbyButton()
    {
        Collider[] nearbyObjects = Physics.OverlapSphere(transform.position, interactionRange, interactableLayer);
        currentButton = nearbyObjects.Length > 0 ? nearbyObjects[0].GetComponent<InteractableButton>() : null;
    }
    
    private void AttemptInteraction()
    {
        if(currentButton.CanInteract())
        {
            currentButton.OnInteract();
            LogInteractionForCommunity

Result: Responsive, bug-free interactions that work consistently across all puzzle scenarios.

3. Community Progress Tracking

Problem: Simulate community participation and track collective progress across multiple players using the game's itch.io forum.

Solution: Implemented a system that bridges in-game actions with external community coordination.

public class CommunityProgressTracker : MonoBehaviour
{
    [SerializeField] private PuzzleContribution[] playerContributions;
    private int activeContributors = 0;
    
    public void RegisterPlayerContribution(int playerId, int puzzleIndex)
    {
        if(!HasPlayerContributed(playerId, puzzleIndex))
        {
            playerContributions[puzzleIndex].AddContributor(playerId);
            activeContributors++;
            
            // Update UI to show progress toward puzzle requirements
            UpdateProgressUI(puzzleIndex);
            
            // Check if puzzle requirement is met
            CheckPuzzleCompletion(puzzleIndex);
        }
    }
    
    public int GetActiveContributors()
    {
        return activeContributors;
    }
    
    private void UpdateProgressUI(int puzzleIndex)
    {
        UIManager.Instance.UpdatePuzzleProgress(puzzleIndex, GetProgressPercentage(puzzleIndex

Result: Players could see their collective progress and understand exactly how many more contributors were needed.

4. Precise Collision & Movement System

Problem: Ensure smooth player movement and accurate collision detection for button interactions in a simple walking-based game.

Solution: Optimized collider setup and movement system for responsive gameplay.

public class PlayerMovementController : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private CharacterController controller;
    
    void Update()
    {
        Vector3 moveDirection = GetMovementInput();
        
        // Apply movement with proper collision detection
        controller.Move(moveDirection * moveSpeed * Time.deltaTime);
        
        // Handle ground detection and gravity
        if(!controller.isGrounded)
        {
            controller.Move(Vector3.down * 9.8f * Time.deltaTime);
        }
    }
    
    private Vector3 GetMovementInput()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        return new Vector3(horizontal, 0, vertical).normalized

Result: Smooth, responsive movement that never interfered with button interactions.

Results & Impact

• Delivered a polished first-person puzzle prototype in 48 hours with clean, responsive controls

• Created a distinctive minimalist black-and-white aesthetic supporting immersive puzzle exploration

• Designed cooperative puzzle mechanics emphasizing communication and collaboration outside the game

• Demonstrated ability to build intuitive interaction systems under tight deadlines

Lessons Learned

• Minimalism in gameplay and visuals can create a focused, immersive player experience

• First-person controls with limited input require precision and simplicity in programming

• Thinking outside the box was essential, as creating an offline multiplayer experience is an unusual concept that required creative problem-solving

• Rapid prototyping benefits from well-structured, modular interaction and input systems

Key Technologies & Patterns Demonstrated

• First-Person Systems: Smooth character controller, precise collision detection, responsive input handling

• Interaction Design: 3D UI integration, button state management, raycast-based interactions

• Game Architecture: Modular puzzle progression, scalable community tracking systems

• Rapid Development: Clean code structure under 48-hour constraints, efficient prototyping patterns

• Cross-Platform Logic: External community integration, asynchronous multiplayer coordination