The idea was to create a puzzle game that felt natural in VR, where players could interact with a miniature 3D world using their hands and guide a character through increasingly challenging levels.
Inspiration and Game Concept
I wanted to create something that combined puzzle-solving, spatial awareness, and hands-on VR interaction.
The result was Ogomoto, a 3D VR puzzle game in which players guide a little monster named Ogomoto to the destination block. Instead of directly controlling the character, players interact with the environment by tapping blocks to move Ogomoto and manipulating the level's blocks to create a path.
The journey isn't always straightforward. Some blocks need to be moved or rotated to create pathways, while different monster bots introduce additional challenges and interactions.
- Ogomoto: The main character that players guide through the puzzle.
- Friendly Bots: Other monsters that assist Ogomoto in reaching the destination.
- Wizard: A dangerous Wizard that kills Ogomoto if he gets too close.
The goal is to turn a simple-looking block puzzle into an interactive 3D world that players can manipulate directly with their hands.
How I Built the Project
One of the biggest parts of this project was developing the underlying systems from scratch rather than relying on ready-made puzzle mechanics.
1. Custom 3D Grid System
The foundation of Ogomoto is a custom 3D grid system that I developed specifically for this game.
Unlike a traditional 2D grid, the game world operates across three dimensions: X, Y, and Z. This allows me to create levels with different heights, platforms, stairs, gaps, and multiple layers.
I created custom data structures to manage the grid:
- GridCell: Stores the grid coordinates, world position, occupancy, walkability, and associated block reference.
- BlockInfo: Stores information about individual blocks, including their ID, block type, grid position, and direction.
- BlockData: Keeps the necessary block information together for maintaining the level's data.
I also implemented a dictionary-based grid lookup system using Vector3Int coordinates. This allows the game to quickly find blocks at specific grid positions without repeatedly searching through the entire level.
This system became the backbone of almost every gameplay mechanic, including character movement, pathfinding, block manipulation, and level validation.
2. Custom 3D Pathfinding System
One of the most challenging technical aspects was developing a pathfinding system that could understand the game's three-dimensional environment.
Instead of using Unity's built-in NavMesh system, I implemented a custom grid-based pathfinding algorithm from scratch.
The system uses:
- Grid-based neighbour detection.
- Walkability and occupancy checks.
- Visited-cell tracking.
- Path reconstruction.
- Dynamic path validation.
I implemented Breadth-First Search (BFS) using a queue, dictionary, and hash sets to calculate a valid route between two grid cells.
However, simple horizontal movement wasn't enough. The game also needed to support stairs, allowing Ogomoto to move between different vertical levels.
I extended the pathfinding system with custom stair connections that understand the stair's orientation and determine valid entry, exit, upward, and downward movement.
This allowed the character to navigate complex 3D structures rather than being restricted to a flat surface.
3. Procedural Level Generation and Level Design
I developed a grid-based level creation workflow to build and manage puzzle environments.
The level system uses the same underlying grid data to identify block positions, block types, and walkable spaces.
This makes it possible to construct levels using different types of blocks while keeping the gameplay systems connected to a consistent source of level data.
I also designed the system around reusable block information, making it easier to introduce new block types and create increasingly complex puzzle layouts.
4. Character Navigation and Movement
Ogomoto does not move like a traditional player-controlled character.
Players interact with the puzzle by tapping a destination block, and the character calculates a route to reach it.
I implemented a custom character movement system using Unity's Character Controller.
It handles:
- Movement between grid cells.
- Smooth character rotation towards the next destination.
- Gravity and ground detection.
- Following moving platforms.
- Detecting broken paths.
- Updating the character's grid position as it moves.
An important challenge was keeping the character synchronized with moving blocks. When a platform moves, the character must move along with it without losing its position or falling through the environment.
I handled this by tracking the platform's positional changes and applying the same movement to the character.
5. Interactive Blocks and Puzzle Mechanics
The blocks are not just static platforms. They are the main puzzle-solving tools.
Players can interact with the environment to move and rotate blocks, creating new pathways for Ogomoto.
This required keeping the physical environment and the logical grid data synchronized. Whenever blocks change position or orientation, the underlying level information must reflect those changes so that pathfinding continues to work correctly.
6. VR Interaction and Hand Tracking
One of the hackathon's main requirements was that controllers should not be mandatory.
I integrated Meta's All-in-One SDK to build a hands-based VR interaction experience.
The goal was to make interactions feel natural by allowing players to use their virtual hands to interact with blocks and manipulate the puzzle environment.
I also worked on rotating and repositioning the puzzle environment through hand interactions while keeping the underlying grid and gameplay systems intact.
This was particularly challenging because VR interactions had to work reliably without compromising the existing game logic.
Challenges and What I Learned
Building Ogomoto in a limited 30-day timeframe came with several challenges.
Designing a 3D grid: Moving from a conventional 2D grid to a fully three-dimensional system required rethinking how cells, neighbours, occupancy, and movement should work.
Pathfinding across different heights: Supporting stairs and vertical transitions was particularly challenging. I had to extend the basic pathfinding logic with additional connection rules to make navigation work correctly.
Keeping systems synchronized: Moving and rotating blocks introduced challenges between physics, transforms, grid coordinates, and pathfinding data. Maintaining consistency between these systems was essential.
VR interaction: Building a controller-independent experience required learning and integrating Meta's hand interaction tools while keeping the game comfortable and playable in a seated position.
Time management: Developing a complete VR puzzle experience within 30 days meant making technical and design decisions carefully, prioritizing core gameplay, and avoiding unnecessary complexity.
Through this project, I gained practical experience in custom spatial data structures, grid-based algorithms, pathfinding, procedural level workflows, Unity physics, and VR hand interactions.
Final Thoughts
Ogomoto was an opportunity to build more than just a puzzle game. It was an opportunity to design and implement the technical foundation of an interactive 3D puzzle environment from scratch.
As a solo developer, I worked across gameplay programming, system architecture, level creation, character mechanics, and VR integration.
The most valuable part of this project was learning how multiple independent systems can work together to create a cohesive gameplay experience.
Ogomoto represents my exploration of VR game development, custom gameplay systems, and hands-on puzzle design.