Solving Cross-Scene UDP Communication

The Problem: Broken Connection

After successfully implementing both Learning Mode and Duel Mode, I discovered that the UDP connection between my game and the Python backend (which handles sign language detection) would break whenever players switched between modes.

My game flow requires players to move between scenes frequently:

  1. Mode Selection → Learning Mode → Mode Selection → Duel Mode

Each time a scene changed, the UDP socket connection would drop, forcing players to restart the application or manually reconnect the Python backend. This created a jarring experience that interrupted the learning flow and frustrated testers during my playtesting sessions.


The Solution

After exploring several options, I implemented a classic yet effective solution: a persistent singleton for UDP communication. Here's how I architected it:

1.  Single-Instance Architecture

I implemented a classic singleton pattern for my UDPReceiver class. The key components included:

  • A private static instance variable and public static accessor property
  • Proper initialization in the Awake() method with duplicate instance checking
  • Implementation of Unity's DontDestroyOnLoad() to maintain the GameObject across scenes
  • Error handling for cases where the instance might be missing

This pattern ensures:

  • Only one UDPReceiver exists across all scenes
  • The connection persists during scene changes
  • All game modes can access the same connection instance

2. Refactoring Mode-Specific Scripts

Each game mode needed to access my singleton UDPReceiver rather than creating its own connection. For both my LearningMode and DuelGame classes, I:

  • Retrieved the singleton instance through the static accessor
  • Registered for UDP message events using an event-based system
  • Added proper null checks and error handling for robustness
  • Implemented event cleanup during scene unloading to prevent memory leaks
  • Sent mode-specific notifications to help the Python backend adjust accordingly

I applied similar refactoring consistently across all game mode scripts, ensuring a standard approach to UDP connection handling.

3. Connection Management

Maintaining a healthy connection required additional steps:

  • Scene transition detection using Unity's SceneManager.sceneLoaded event
  • Socket reconnection protocol for cases where the connection might be broken
  • Explicit mode change notifications sent to the Python backend via UDP
  • Status monitoring to detect and recover from connection issues

I implemented a robust messaging system that notifies the Python backend whenever the game transitions between modes, allowing the sign detection system to adjust its parameters accordingly.

Results

After implementing this architecture, I achieved:

  • Consistent UDP Connection: The connection now persists seamlessly across all scene transitions
  • Improved Player Experience: No more connection interruptions or manual reconnections
  • Proper Mode Detection: The Python backend now receives accurate game mode information

Moving Forward

With my UDP communication working reliably across scenes, I've finally reached an exciting milestone: the game is technically stable enough for proper user testing! Now that players can seamlessly transition between Learning Mode and Duel Mode without connection interruptions, I can focus on gathering meaningful feedback about the actual gameplay experience.

References

Technologies, U. (n.d.). Unity - Scripting API: Object.DontDestroyOnLoad. https://docs.unity3d.com/ScriptReference/Object.DontDestroyOnLoad.html

Comments

Post a Comment

Popular posts from this blog

UDP vs TCP

After successfully implementing hand sign detection and classification in Python, my next challenge was connecting this system to Unity for a more interactive learning experience. At first, I saw a video from the same YouTube channel that showed how to connect Python to Unity using UDP. This inspired me to explore network protocols more deeply to understand what would work best for my project. Initial Discovery: UDP from the YouTube Tutorial When I first started researching how to connect my Python classifier to Unity, I came across a tutorial video from the same YouTube channel ( Murtaza’s Workshop - Robotics and AI)  that taught me about hand detection. The video suggested using UDP (User Datagram Protocol) for this connection. This piqued my interest, but before implementing it, I wanted to understand why UDP was recommended over TCP (Transmission Control Protocol). My Understanding of the Two Protocols Through my research, I found that TCP and UDP represent two different philos...
Read more

Initial Research

Image
Bridging Family Gaps for Deaf Teenagers Communication is one of the most important aspects of building strong family relationships. However, for many deaf teenagers raised in hearing families, communication is often one of the biggest barriers. Everyday conversations, emotional expressions, and even simple family interactions can become sources of frustration or isolation when a shared language is missing. These experiences may go unnoticed by hearing family members, but for deaf teens, they can have long-term effects on emotional well-being, self-identity, and social development. Inspiration This project was inspired by the Korean drama Twinkling Watermelon . In the story, a young deaf girl is discouraged by her mother from learning sign language. Despite this, her boyfriend takes the initiative to learn sign language so that he can communicate with her and eventually teaches her as well. How Sweet! Later in the story, he becomes deaf due to an accident. The two eventually marry and r...
Read more

Final Approach: Python OpenCV

Image
After experimenting with 3 different approaches, I realized that fully implementing them would be too risky. Each required a deep technical understanding and advanced knowledge of complex systems that I don’t yet possess. While the concepts were promising, I ultimately decided to take a more practical route that aligned with my current skills and ensured the project would be functional and deliverable within my timeline. Luckily, when I decided to broaden my research and look into more practical solutions, I came across a fascinating YouTube tutorial on building a hand sign detection system specifically for American Sign Language (ASL) alphabets that offered a more systematic approach. Learning From Mr. Murtaza The tutorial I discovered from the YouTube channel called "Murtaza's Workshop - Robotics and AI" presented a comprehensive step-by-step guide for building a robust hand sign detection system using ASL alphabets A, B, and C. What caught my attention was its two-step...
Read more