Split Game

A fast-paced neon arcade game built in Unity.

Overview

A simple fast-paced hyper casual game developed in C#/Unity, built around a modular, data driven architecture that allows levels, gameplay elements, and behaviors to be configured and extended without tightly coupling them to the core game systems.

Concept

Split draws its core concept from the behavior of quantum particles entanglement; particularly the idea of particles existing as separate states that can interact, converge, or transition into a unified state. The game translates this abstract concept into an arcade experience where the player can separate or unite the particles to avoid obstacles and progress through.

Gameplay

One gameplay sequence focuses directly on the concept of particle seperation and unification. Two particles naturally move toward one another, and the player's task is to keep them separated by maintaining a finger on the screen.

As long as the player maintains the input, the particles remain split. Releasing the input removes the separation force, causing the particles to converge and eventually unify.

This creates a simple but high-pressure interaction: hold to maintain separation, release and the particles collapse into one.

The player has to avoid all the obstacles and pick the powerups using the single control

private void UpdateQuarkMovement()
{
    float speed = GetSpeed();
    float delta = speed * Time.deltaTime;
    float y = Mathf.Lerp(
    rightPaddle.transform.localPosition.y,
    separatePosition.y,
    Time.deltaTime * speed
);

  bool shouldSeparate = Input.GetKey(KeyCode.Space) || bReverseControls;
  
  if (shouldSeparate)
  {
      bHitPaddle = false;
  
      if (Mathf.Abs(y - separatePosition.y) < 0.25f)
          xPosition += delta;
  }
  else if (!bHitPaddle)
  {
      xPosition -= delta;
  }
  else
  {
      return;
  }

  xPosition = Mathf.Clamp(xPosition, 0.0f, xClearance);

  rightPaddle.transform.localPosition = new Vector3(xPosition, y, 0.0f);
  leftPaddle.transform.localPosition = new Vector3(-xPosition, y, 0.0f);
}

private void UpdateQuarkMovement()
{
    float speed = GetSpeed();
    float delta = speed * Time.deltaTime;
    float y = Mathf.Lerp(
    rightPaddle.transform.localPosition.y,
    separatePosition.y,
    Time.deltaTime * speed
);

  bool shouldSeparate = Input.GetKey(KeyCode.Space) || bReverseControls;
  
  if (shouldSeparate)
  {
      bHitPaddle = false;
  
      if (Mathf.Abs(y - separatePosition.y) < 0.25f)
          xPosition += delta;
  }
  else if (!bHitPaddle)
  {
      xPosition -= delta;
  }
  else
  {
      return;
  }

  xPosition = Mathf.Clamp(xPosition, 0.0f, xClearance);

  rightPaddle.transform.localPosition = new Vector3(xPosition, y, 0.0f);
  leftPaddle.transform.localPosition = new Vector3(-xPosition, y, 0.0f);
}

private void UpdateQuarkMovement()
{
    float speed = GetSpeed();
    float delta = speed * Time.deltaTime;
    float y = Mathf.Lerp(
    rightPaddle.transform.localPosition.y,
    separatePosition.y,
    Time.deltaTime * speed
);

  bool shouldSeparate = Input.GetKey(KeyCode.Space) || bReverseControls;
  
  if (shouldSeparate)
  {
      bHitPaddle = false;
  
      if (Mathf.Abs(y - separatePosition.y) < 0.25f)
          xPosition += delta;
  }
  else if (!bHitPaddle)
  {
      xPosition -= delta;
  }
  else
  {
      return;
  }

  xPosition = Mathf.Clamp(xPosition, 0.0f, xClearance);

  rightPaddle.transform.localPosition = new Vector3(xPosition, y, 0.0f);
  leftPaddle.transform.localPosition = new Vector3(-xPosition, y, 0.0f);
}

Key Technical Architecture

Data Objects: Gameplay configuration is separated from runtime logic using data-driven objects, allowing properties such as level parameters, pickup behavior, obstacle configuration, and gameplay values to be modified independently of their implementation.
Configurable Levels: Levels are designed as modular, self-contained configurations that can be added, modified, and loaded independently. This allows new gameplay scenarios to be introduced without changing the core game architecture.
Extensible Pickups & Obstacles: Pickups and obstacles use a configurable behavior architecture, allowing new types and variations to be introduced by composing or extending existing behaviors rather than rewriting the core gameplay systems.
GPU-Driven Transformations: Large numbers of gameplay objects and visual elements are transformed using GPU based shader operations, reducing CPU-side transform work and allowing the game to efficiently render and manipulate large numbers of objects.

Example: Edge Shader (Moving edges on a mesh - translated in Unity)

Example: Horizon Shader for background
Separation of Data & Behavior: Configuration, gameplay logic, and presentation are kept separate, making the system easier to iterate on and allowing designers to tune gameplay without modifying core code.

The overall architecture was designed to make the game highly configurable and extensible, while maintaining the performance required for a fast-paced experience with large numbers of dynamically moving objects.