Jordy Priessen Portfolio - Outloop Ping Pong

Outloop: Ping Pong is a modular, arcade-style table tennis prototype built in Unity using modern software design principles. This minigame represents one playable activity inside a larger open-world game concept I’m developing titled Outloop.

The game supports local multiplayer, charged hits, directional control via analog stick input, and modular gameplay logic using design patterns. The entire gameplay is scalable and cleanly structured for future enhancements like AI opponents or online multiplayer.

Core Gameplay Features

🎮 Full controller support for 2 players (Xbox tested)
⚡ Charged hits with variable power and visual feedback
↩️ Directional influence based on analog stick input
🧠 Modular architecture using Strategy and Command patterns

📣 MVP Update – August 4th, 2025

Since the initial prototype launched on July 30th, I’ve taken Outloop: Ping Pong all the way to MVP status, completing the full game loop. This update represents the first playable vertical slice of the game and reflects an enormous boost in technical depth, polish, and responsiveness.

Major Improvements:

✅ Full match logic including serve transitions, scoring, deuce, and win condition
✅ Modular event-driven architecture using Observer and State Patterns
✅ Controller-based gameplay with clear separation of game logic
✅ Technical polish on positioning, serving, ball tracking, and game resets

The result is a rock-solid MVP that’s fun, reactive, and built with scalability in mind. The gameplay loop is now fully playable with clear rules and round transitions — all crafted through modular, testable code. 🎯

📄 Download the Game Design Document

You can read the full design outline and long-term vision for this game in the GDD: Outloop – Ping Pong (PDF).

🎥 Updated Gameplay Preview

🕹️ Pre-MVP Footage – July 30th, 2025

This was the initial playable slice where I established player movement, hit detection, and ball interaction — the foundation for the full game loop. Below is the gameplay footage and core code used to build the prototype.

Gameplay Preview

How I Built It

BallController.cs – Controls the behavior of the ping pong ball, including force application, max speed clamping, and resets.


public void Serve(Vector3 direction, float speed)
{
    if (isServed) return;
    rb.useGravity = true;
    rb.AddForce(direction * speed);
    isServed = true;
}

IBallHitStrategy & SimpleHitStrategy.cs – Allows different hit types (e.g., lob, curve, smash) to be defined and swapped modularly.


public interface IBallHitStrategy
{
    void ApplyHit(Rigidbody ballRb, Transform paddle, float charge, float inputDir);
}

HitDetector.cs – Detects input, charge state, and triggers hit logic if the ball is within range.


if (isCharging && inRange && InputReleased)
{
    float charge = Mathf.Clamp01(chargeTime / maxCharge);
    hitStrategy.ApplyHit(ballRb, paddleTransform, charge, inputDirection);
}

Command Pattern: InputHandler delegates player input using ICommand implementations like MoveCommand, enabling decoupled, testable player movement logic.


public class MoveCommand : ICommand
{
    public void Execute(Vector2 input) => paddle.SetDirection(input);
}

What’s Next?

This project is being expanded into a modular collection of minigames within the larger Outloop universe. The goal is to demonstrate flexible, maintainable systems design within Unity — with gameplay always feeling responsive and fun.