Built From Scratch

Challenge

One of the core challenges was to design and implement all swipe and touch interactions manually, as no external libraries were allowed. Additionally, the game needed to be scalable—what began with a simple cube would eventually expand to support multiple 3D figures, each with different interaction behaviors and decision logic.

Key technical challenges included:

Creating a robust swipe detection system that felt responsive and natural on touch devices.
Rotating 3D figures (starting with a cube) in response to swipe inputs, while maintaining orientation and state.
Building a system that could support dynamic figure expansion, allowing more complex shapes or structures to be introduced later in development.
Designing a modular logic system so that each face of a cube (or figure) could present unique decision prompts and track different game outcomes.

Solution

To meet these goals, I focused on building a lightweight, fully custom system that prioritized responsiveness and extensibility:

Swipe & Touch Input System

Developed a custom swipe detection logic using low-level touch input events, avoiding any Unity-provided gesture libraries.
Implemented swipe direction recognition with dynamic thresholds to differentiate between left, right, and accidental gestures.
Linked swipe input to smooth 3D cube rotations, giving users a tactile and visually responsive interaction experience.

Modular Cube Architecture

Designed the cube as a modular figure, with each face linked to text prompts, decision outcomes, and logic paths.
Built the system with scalability in mind—allowing for future figures beyond the cube, such as prisms, pyramids, or more abstract geometries.
Created a data-driven system for face content, enabling easy updates or additions to the game's logic and narrative elements.

UI/UX Enhancements

Focused on clean, intuitive UI design, making interactions feel immediate and satisfying.
Built a system for feedback animations (e.g., subtle bounce, glow on selection) to reinforce user actions.
Implemented difficulty scaling mechanics, such as time pressure, trick prompts, and increasingly complex figure rotation patterns.

Result

The final product was a highly responsive, minimalistic swipe-based game that delivered a polished user experience without relying on external tools or assets. The gameplay was designed to scale in difficulty, starting from simple decisions on a cube and evolving into a more challenging, layered experience with additional figures and logic systems.

This project showcased a strong focus on custom interaction systems, modular design, and UX-first development, delivering a foundation that could continue evolving long after launch.

Built From Scratch

Challenge

The complexity came from matching user gestures to the correct prompts, especially in a system where levels were randomly generated and cube rotations affected the orientation of each face. The game needed to:

Ensure the displayed text matched the required gesture.
Detect the correct swipe direction, and distinguish between valid inputs and incorrect or partial gestures.
Prevent inconsistencies caused by cube rotation—i.e., a face labeled “Swipe Up” should always expect an actual upward swipe on the screen, regardless of how the cube was rotated in 3D space.
Seamlessly integrate the gesture logic into a randomized level generation system, which varied commands and increased difficulty over time.

Solution

To ensure accurate and intuitive gameplay, I implemented a gesture interpretation and validation system tied directly to the cube's current face and the prompt logic.

Gesture-to-Command Matching System

Created a mapping between gesture directions and command keywords (“up”, “down”, “left”, “right”, “tap”, etc.).
The system compared the player’s swipe direction against the current active command, validating whether the response was correct.
Allowed for tolerance thresholds and input smoothing to eliminate accidental failures from imperfect gestures.

Cube-Face Command Logic

Each cube face held a text prompt and a target gesture tag.
When a face was rotated into the active view, the system loaded the expected input for that face, awaiting the corresponding user action.
Built-in a layer of abstraction to ensure the gesture mapping stayed consistent regardless of the cube’s rotation in 3D space, aligning game logic with screen-space gestures instead of object-space orientation.

Randomized Level Generation

Developed a simple random level generation system that pulled commands from a pool and assigned them to cube faces dynamically.
Logic ensured a balance between difficulty and fairness—for example, avoiding repeated commands or too many similar directions in sequence.
Allowed future extensibility for fake prompts, timed responses, or inverted logic (e.g., “don’t swipe down”).

Feedback & Game Loop Integration

Integrated real-time feedback for correct and incorrect inputs with animations and sound cues.
Built the full game loop, tracking score, streaks, and fail conditions based on gesture accuracy.

Result

This system formed the core gameplay mechanic, transforming simple swipe interactions into an engaging and reactive decision-making challenge. The combination of gesture interpretation, command mapping, and randomized level design created a game that felt responsive, intuitive, and scalable in difficulty—laying the foundation for more advanced mechanics and game modes in future iterations.

Adaptive Timing System for Smooth Gameplay

Challenge

One of the most critical aspects of difficulty scaling was the speed mechanic—levels required players to react within a set time window, represented visually by a countdown line animation. However, implementing this system came with several technical challenges:

The countdown animation needed to be tightly synced with the actual game timer to reflect how much time the player truly had to respond.
Unity’s animation and update timing can vary slightly depending on the device's performance, which meant that the animation might finish too early or too late on different devices, leading to a disconnect between what the player sees and what the game logic enforces.
Additionally, the animation duration had to account for ease-in/out or smoothing curves for visual polish, which could introduce subtle delays if not handled correctly.

Solution

To ensure consistency across devices and provide a fair, visually coherent experience, I implemented a synchronized timing system that kept the animation and gameplay timer tightly linked.

Difficulty Profile System

Each level used a difficulty profile defining:
- Required number of gestures
- Allowed response time
- Whether prompts were straightforward or deceptive
This made difficulty modular and easy to adjust or expand. 2.** Timer & Animation Synchronization**
Created a shared timer controller that both the countdown animation and game logic referenced.
The animation was no longer hardcoded but dynamically scaled to match the timer value, ensuring they always finished together, regardless of animation speed or easing.

Device-Dependent Timing Adjustments

Accounted for potential frame rate or performance differences across devices by:
- Using unscaled delta time for consistent timer progression
- Adding a** buffer margin** to animation start/finish times to absorb minor performance variations
- Performing runtime speed calibration on startup (or periodically) to ensure UI animations stayed in sync with logical timeouts

Smooth Transitions Without Gameplay Lag

Ensured animations felt smooth with proper easing curves, without affecting the underlying logic.
Any delay introduced by visual polish was pre-compensated in the timer logic so that gameplay fairness was never compromised.

Result

The end result was a tight, responsive speed system where the visual countdown matched exactly with the time the player had to act. This created a high-trust experience, where players could rely on visual cues and engage with the game more confidently, even as the difficulty increased.

By accounting for both animation behavior and device performance variability, the system remained consistent, polished, and fair across a wide range of mobile devices.

Case study

Cube Not Not

Not Clone not not is game duplicate the client asked to create similar game with slight changes, and the original features were:

Unity
C#

Cube Not Not

Start of development:: 2016
I am in the project:: 2016

Contribution to project

Randomly generated levels with increasing level of difficulty
Different surfaces like cube, pyramid, sphere etc
Ability to save you score, share you score and other social features
The directions need to be written like “up”, “down” etc. And also identifying color like “green”, “red”

Case impression

The goal was to create a game where the playing surface and rules change each time, so players have to adapt on the fly instead of memorizing levels.

Create something similiar but unique

The idea of project was to create a similiar game to already existing one, but enchance it in sense of UX and difficulty

Custom Mobile Game – Built From ScratchDue to creating everything from scratch without using anything Read more

No swipeDue to creating a swipping mechanicRead more

Scaling difficultyDue to creating convoluted goalsRead more

before

after

Стара версія

Нова версія

The first iteration of project ended

All projectsLet’s talk