LogoLogo
HomeOnline DashboardAPIDiscordForums
SDK 1.7 Preview
SDK 1.7 Preview
  • Welcome
  • Overview
    • Features
    • Roadmap
  • Getting started
    • Get the Unity SDK
    • Setup a project
      • 1. Scene setup
      • 2. Prefab setup
      • 3. Test your game locally
        • Local testing using builds
        • Local testing via Unity's Multiplayer Play Mode
        • Local testing via ParrelSync
      • 4. Test in the cloud
        • Deploy a Replication Server
        • Share builds
    • How to... ?
    • Single-player to multiplayer
    • Video tutorials
    • Samples and tutorials
      • Package samples
      • Sample Connection UIs
      • First Steps tutorial
        • 1. Basic syncing
          • 1.1 Animation parameters
          • 1.2 Sending commands
        • 2. Physics / Authority transfer
        • 3. Areas of interest
        • 4. Parenting entities
        • 5. Complex hierarchies
        • 6. Persistence
      • Campfire project
        • Game mechanics
        • Leveraging object pooling
        • Remote interactions: Chairs
        • Remote interactions: Trees
        • A unique object with complex state
        • Custom instantiation and destruction
        • Running a server-side NPC
        • Playing audio and particles
        • A simple text chat
      • Beginner's guide to networking
    • Troubleshooting
  • Manual
    • Unity Components
      • CoherenceSync
      • CoherenceBridge
      • CoherenceLiveQuery
      • CoherenceTagQuery
      • CoherenceGlobalQuery
      • CoherenceInput
      • CoherenceNode
      • PrefabSyncGroup
      • Order of execution
    • Networking state changes
      • Instantiate and Destroy Objects
      • Supported types
      • Messaging with Commands
      • Syncing child GameObjects
      • Animation
      • CoherenceSync references
      • [Sync] and [Command] Attributes
      • [OnValueSynced] Attribute
      • Creating your own syncable member
      • Custom Component Actions
      • Rigid Bodies
      • Interpolation
    • Authority
      • Authority transfer
      • Server-authoritative setup
    • Lifetime
      • Persistence
      • Uniqueness
      • Example: A global counter
    • Parenting network entities
      • Direct children CoherenceSyncs
      • Deeply-nested CoherenceSyncs
      • Nesting Prefabs at Edit time
    • Asset management
      • Instantiating from CoherenceSyncConfig
      • Instantiate via
      • Load via
    • Scene management
    • Multiple Connections within a Game Instance
    • Baking (code generation)
      • Conditional compilation
    • Replication Server
      • Rooms and Worlds
      • Replication Server API
    • Simulators (Servers)
      • Scripting: Client vs Simulator
      • Run local Simulators
      • World Simulators
      • Room Simulators
      • Advanced Simulator Authority
      • Simulator slugs
      • Build and Deploy
      • Command-line arguments
    • Client Connections
    • Optimization
      • Areas of Interest
      • Level of Detail (LOD)
      • Profiling
      • Simulation Frequency
    • Project Settings
    • Advanced topics
      • Big worlds
        • World Origin Shifting
        • Load balancing
      • Competitive games
        • Simulation Frame
        • Determinism, Prediction and Rollback
      • Team workflows
        • Version Control integration
        • Continuous Integration
      • Schema explained
        • Specification
        • Field settings
        • Archetypes
      • Code stripping
      • Replication Server CLI
      • Single-player gameplay
    • Scripting API
  • Hosting
    • Choosing where to host
    • coherence Cloud
      • Online Dashboard
      • Manage Worlds
      • Configure Rooms
      • Player Accounts
      • Game Services
        • Lobbies
        • Cloud Storage
        • Key-Value Store (Legacy)
      • APIs
        • Worlds
        • Rooms
        • Lobbies
        • Cloud Storage
        • Key-Value Store (Legacy)
    • Peer-to-peer
      • Implementing Client hosting
        • Steam Relay
        • Epic Online Services (EOS) Relay
        • Azure PlayFab Relay
  • Support
    • Release notes
    • Glossary
    • Unreal Engine support
    • WebGL support
    • ECS / DOTS support
    • Known issues
    • Upgrade guide
      • Upgrade 1.6 -> 1.7
      • Upgrade 1.5 -> 1.6
      • Upgrade 1.4 -> 1.5
      • Upgrade 1.3 -> 1.4
      • Upgrade 1.2 -> 1.3
      • Upgrade 1.1 -> 1.2
      • Upgrade 1.0 -> 1.1
      • Upgrade 0.10 -> 1.0
      • Upgrade 0.9 -> 0.10
    • Credit cost & pricing
    • Report a bug
Powered by GitBook
On this page

Was this helpful?

Export as PDF
  1. Hosting
  2. Peer-to-peer
  3. Implementing Client hosting

Azure PlayFab Relay

Last updated 14 days ago

Was this helpful?

is a backend platform for building and operating live games. It provides a suite of managed game services, real-time analytics, and LiveOps tools within a single platform. It provides a free service as well as pay-per-month plans. In order to use PlayFab you'll need to set up a game with a valid PlayFab Title ID. Once you have a PlayFab Title ID, you'll be able to pass messages between clients via PlayFab's servers.

To make things easy, coherence provides a complete PlayFab relay implementation that provides out-of-the-box networking over PlayFab. The PlayFab relay utilizes the to access the PlayFab Party API.

The PlayFab Integration is using a combination of the PlayFab relay servers and an implementation of ICoherenceRelay to enable PlayFab users to connect and play with each other while avoiding NAT issues. The ICoherenceRelay implementation allows for users to connect to the hosting client through PlayFab, and have the client forward their data packets to the user-hosted Replication Server.

The sample code in the repository demonstrates how to join and host a game with the PlayFab Party API.

The Azure PlayFab relay is available here:

Connecting over PlayFab, step-by-step

  1. The host (Client A) initializes the PlayFabClientAPI that handles PlayFab connections and then starts a Replication Server on its local machine.

  2. The host connects to the local Replication Server and joins the PlayFab network. The host receives the remote server's network ID and host id. These are used by clients to connect to PlayFab's services.

  3. Another player (Client B) connects to the host via PlayFab using the PlayFabTransport.

  4. The PlayFabRelay accepts the incoming connection, creating a PlayFabRelayConnection.

  5. The PlayFabRelayConnection immediately starts passing data between the PlayFab servers and the Replication Server.

  6. The relayed connection is now fully established. All data between Client B and the Replication Server is relayed through PlayFab.

  7. For each new Client that connects, steps 3-6 are repeated.

Although the diagram above shows that traffic is routed via PlayFab servers, it is often the case that traffic can flow directly between player and host machines without actually making the extra hop via the PlayFab servers. This technique is commonly referred to as "hole punching" or "NAT Punch-through" and greatly reduces latency, however, it is not supported on all networks due to firewall restrictions.

PlayFab Party will first attempt a NAT punch-through and then automatically fall back to relayed communication if the punch-through failed.

PlayFab
PlayFabPartyUnity package
https://github.com/coherence/playfab-integration-sample
PlayFab relay overview