Fingerball devlog #1

Here's a devlog we wanted to do for sometime. We want to share our story and plans for the game as well as some fun stuff we encounter during development phases.

The Idea Behind Fingerball

In our creative brainstorming sessions, we found ourselves gravitating towards an exciting feature of modern VR devices—finger tracking. The Quest 3, being one of the market leaders, offers such refined hand and finger-tracking capabilities that it felt like a whole new realm of possibilities opened up before us. Naturally, the conversation shifted to games that could fully leverage the elegance and precision of these controls—specifically, games played using just hands and fingers.

This nostalgic journey took us back to the games we played as kids, especially the simple but thrilling goal-based games. That's when the light bulb moment happened: Fingerball. The idea was simple, but the potential for immersive fun was undeniable. Imagine a table, two long sticks acting as goalkeepers, and a penny or something similar that you flick with your fingers, aiming to score a goal. It’s tactile, it’s strategic, and it’s a perfect fit for a hand-tracking experience.

"A game that taps into the simple joys of our past, enhanced by the futuristic possibilities of virtual reality."

We were inspired to bring this childhood classic to life—but with a modern twist, in XR. The mechanics of flicking, blocking, and scoring, combined with immersive environments, make Fingerball more than just a digitalized version of a childhood game. It becomes an exciting and competitive experience for VR enthusiasts, transforming simple finger flicks into moments of glory.

And so, Fingerball was born. A game that transforms the simple act of flicking into a strategic challenge, where precision and skill define your victory. It’s time to embrace the next era of gaming, where your hands are your only controller.

Development

So we started to first gather some basic ideas and possible solutions to the main concept. Some ideas we had (and some still relevant) are:

  • Shoes on all fingers
  • Maybe we can have more like a stadium? Optimization?
  • Balls with different weights? Might be too hard to balance
  • Maybe a much bigger table? 

In the picture, you see an early prototype concept of how we've came to the final idea. We thought of "throwing stuff in cans or baskets" might be a good and fun way to incorporate into soccer-like ball shooting so the setup you see in game now has emerged.

After some iteration processes and decision-making, ideaballing in between how to add challenges, how to make it a bit engaging, how to provide a proper scoreboard race etc. we've come to the latest design.

There's still a way to go for the game and us but we do believe it's coming together fine in the end.

The game uses Unity 6 as it's development engine and relies on the official packages provided by both Unity and Meta to handle proper hand tracking & device tracking. The language is C#.

One good thing about how we've developed the base game is that we're actually already preparing for vs. AI and multiplayer development as well. See a tiny example of our TurnRunner from the code to see we actually have already defined Opponent Turn in there :)

public int PassedPlayerTurns => _turnList.turns.FindAll(t => t.isPlayerTurn && t.isTurnOver).Count;
public int PassedOpponentTurns => _turnList.turns.FindAll(t => t.isOpponentTurn && t.isTurnOver).Count;
public int PassedNeutralTurns => _turnList.turns.FindAll(t => t.isNeutralTurn && t.isTurnOver).Count;
 public TurnRunner(TurnConfig turnConfig, bool hasOpponentTurn = false){ _turnConfig = turnConfig; _hasOpponentTurn = hasOpponentTurn;}

This would be just a glimpse into the whole hit calculation mechanic but we have come up with our own hit detection system based on delta distance and we're not relying on Unity's own physics system as it's not deterministic and can be much more unpredictable. See the base algorithm for our calculation below:

Vector3 force = _velocity * _playerConfig.SpeedMultiplier + Vector3.Cross(_velocity, direction) * _playerConfig.AngularMultiplier;

Basically we calculate the distance of the finger from a past couple of frames, get the velocity according to the distance difference, multiply it by a custom value we have it for speed, add a cross point of the velocity vs. the direction we calculate again from the movement of the finger and then finally multiply it by angular multiplier value from the player config to be able to incorporate torque into our physics calculation as well.

We've found out this to be a bit better than what Unity offers as default.