KMPingPong

• 

  The Team

Inspiration

Our inspiration comes from a desire to combine an active lifestyle with digital fun. We wanted to tap into the nostalgia of classic gaming while leveraging modern technology. The evolution of gaming went from traditional table tennis rackets to motion controllers, and we realized the next step was already in our pockets. We set out to bridge the physical and digital worlds by turning the smartphone into a game controller, making social gaming accessible globally without the need for expensive proprietary hardware.

What it does

KMPing Pong is a cross-reality multiplayer game where your smartphone acts as the racket.

• Motion First Control: There are no buttons; players use physical swings and the device's accelerometer to hit the digital ball.
• Cross-Reality Display: While the phone is the controller, the actual gameplay is visualized on a larger screen (Desktop or Web).
• Immersive Feedback: The phone provides audio cues for hits (custom swing/hit sounds) and haptic feedback (vibration) to simulate the feeling of impact.
• Zero Barriers: It supports a true multi-platform ecosystem, allowing Android and iOS users to play together seamlessly in the same match.

2 x 2 crossplattform support: Controller app and Table view app written using Kotling Multiplattform which works as Desktop, Web and Tablet Application.

How we built it

We utilized Kotlin Multiplatform (KMP) to create a unified experience across devices. The architecture is divided into three main areas:

1. Players Area: We built client applications for Android and iOS that capture raw accelerometer data (Swing Motion, Tilt, Speed). These clients act as WebSocket Clients. (https://github.com/christiansuslic/hackatum2025-mobileapp)
2. Server Area: A WebSocket Server (built with JavaScript) acts as the bridge, receiving sensor data from the phones and relaying it to the game engine. (https://github.com/raspitim/KMPingPongBackend)
3. Displays Area: The visual game component runs on Desktop or Web clients, which also connect via WebSockets to render the game state in real-time. (https://github.com/HappyKnuckles/PingPongWeb)

Challenges we ran into

One of the main challenges was managing the "Cross Reality" aspect—ensuring the latency between the physical swing of the phone and the action on the big screen was minimal. Debugging the sensor data (Direction X, Tilt, Intensity) to ensure accurate swing detection required significant calibration. Additionally, establishing a stable connection between the local host server and mobile clients required careful network handling to ensure the game starts automatically once players are connected.

Accomplishments that we're proud of

• True Multi-Platform Support: We successfully built a system where Android and iOS devices can interact in the same game session.
• Sensor Integration: We are proud of the "Motion First" implementation, utilizing raw accelerometer data to calculate swing speed and direction without relying on UI buttons.
• Dynamic Theming: We implemented a polished UI with automatic language detection and toggleable Dark/Light modes.

What we learned

We learned a great deal about Kotlin Multiplatform and its capabilities in sharing code between mobile and desktop environments.

What's next for KMPing Pong

Moving forward, we plan to focus on Adaptive Updates, ensuring our visual identity and gameplay remain relevant as trends change. We hope to expand the competitive analysis to further differentiate our motion control system from other market solutions.

Built With

• kotlin
• node.js
• websockets