Matchmaking Guide

{
  "Competitive5v5": {
    "teams": 2,
    "playersPerTeam": 5,
    "timeout": 120,
    "backfill": { "enabled": false },
    "rules": [
      {
        "type": "difference",
        "field": "mmr",
        "maxDifference": 200
      },
      {
        "type": "region"
      }
    ]
  }
}

{
  "RankedRoleQueue": {
    "teams": 2,
    "playersPerTeam": 5,
    "minPlayersPerTeam": 5,
    "maxPartySize": 2,
    "excludedFromQueue": ["Spectator", "Coach"],
    "teamComposition": {
      "team1": {
        "top": 1,
        "jungle": 1,
        "mid": 1,
        "adc": 1,
        "support": 1
      },
      "team2": {
        "top": 1,
        "jungle": 1,
        "mid": 1,
        "adc": 1,
        "support": 1
      }
    },
    "timeout": 90,
    "rules": [
      {
        "type": "difference",
        "field": "mmr",
        "maxDifference": 150
      }
    ]
  }
}

using System.Collections.Generic;
using PlayFlow;
using UnityEngine;

public class TraditionalMatchmaking : MonoBehaviour
{
    public void SetTraditionalMatchmakingData(int playerMMR)
    {
        var matchmakingData = new Dictionary<string, object>
        {
            { "mmr", playerMMR },
            { "regions", new List<string> { "us-west", "us-east", "eu-west" } }
        };

        PlayFlowLobbyManagerV2.Instance.UpdatePlayerState(matchmakingData,
            onSuccess: (lobby) => {
                Debug.Log("Player matchmaking data has been set.");
            },
            onError: (error) => {
                Debug.LogError($"Could not set matchmaking data: {error}");
            }
        );
    }
}

public class RoleBasedMatchmaking : MonoBehaviour
{
    // Single specific role (MOBA player who only plays one lane)
    public void SetSpecificRole(string role, int playerMMR)
    {
        var matchmakingData = new Dictionary<string, object>
        {
            { "role", role }, // e.g., "jungle", "mid", "support"
            { "mmr", playerMMR },
            { "regions", new List<string> { "us-east", "us-west" } }
        };

        PlayFlowLobbyManagerV2.Instance.UpdatePlayerState(matchmakingData);
    }

    // Priority array of roles (flexible fill player)
    public void SetFlexibleRoles(int playerMMR)
    {
        var matchmakingData = new Dictionary<string, object>
        {
            { "role", new List<string> { "support", "adc", "mid" } }, // Preference order
            { "mmr", playerMMR },
            { "regions", new List<string> { "us-east", "eu-west" } }
        };

        PlayFlowLobbyManagerV2.Instance.UpdatePlayerState(matchmakingData);
    }

    // Spectator role (excluded from matchmaking)
    public void SetSpectatorRole()
    {
        var matchmakingData = new Dictionary<string, object>
        {
            { "role", "Spectator" }, // Will be excluded from team requirements
            { "regions", new List<string> { "us-east" } }
        };

        PlayFlowLobbyManagerV2.Instance.UpdatePlayerState(matchmakingData);
    }
}

public class MatchmakingStarter : MonoBehaviour
{
    // Traditional matchmaking (Competitive5v5, Duels, BattleRoyale, etc.)
    public void StartTraditionalSearch(string mode = "Competitive5v5")
    {
        var manager = PlayFlowLobbyManagerV2.Instance;

        if (!manager.IsInLobby || !manager.IsHost)
        {
            Debug.LogWarning("Must be the host of a lobby to start matchmaking.");
            return;
        }

        manager.FindMatch(mode,
            onSuccess: (lobby) => {
                Debug.Log($"Successfully entered the '{lobby.matchmaking.mode}' queue.");
                // Update your UI to show a "searching..." state
            },
            onError: (error) => {
                Debug.LogError($"Failed to start matchmaking: {error}");
            }
        );
    }

    // Role-based matchmaking (RankedRoleQueue, AsymmetricHorror, etc.)
    public void StartRoleBasedSearch(string mode = "RankedRoleQueue")
    {
        var manager = PlayFlowLobbyManagerV2.Instance;

        if (!manager.IsInLobby || !manager.IsHost)
        {
            Debug.LogWarning("Must be the host of a lobby to start matchmaking.");
            return;
        }

        // Ensure all players have set their roles
        var currentLobby = manager.CurrentLobby;
        bool allPlayersHaveRoles = true;

        foreach (var playerId in currentLobby.players)
        {
            if (currentLobby.lobbyStateRealTime.TryGetValue(playerId, out var playerState))
            {
                if (!playerState.ContainsKey("role"))
                {
                    Debug.LogWarning($"Player {playerId} has not set their role!");
                    allPlayersHaveRoles = false;
                }
            }
        }

        if (!allPlayersHaveRoles)
        {
            Debug.LogError("All players must set their role before matchmaking!");
            return;
        }

        manager.FindMatch(mode,
            onSuccess: (lobby) => {
                Debug.Log($"Entered role-based queue: {lobby.matchmaking.mode}");
                // Show searching UI with role information
            },
            onError: (error) => {
                Debug.LogError($"Failed to start role-based matchmaking: {error}");
            }
        );
    }
}

void Start()
{
    var events = PlayFlowLobbyManagerV2.Instance.Events;

    events.OnMatchmakingStarted.AddListener(HandleMatchmakingStarted);
    events.OnQueueStats.AddListener(HandleQueueStats);
    events.OnMatchFound.AddListener(HandleMatchFound);
    events.OnMatchRunning.AddListener(HandleMatchRunning);
    events.OnMatchServerDetailsReady.AddListener(HandleServerDetailsReady);
    events.OnMatchmakingCancelled.AddListener(HandleMatchmakingCancelled);
    events.OnMatchmakingTimeout.AddListener(HandleMatchmakingTimeout);
}

private void HandleMatchmakingStarted(Lobby lobby)
{
    Debug.Log($"In queue for mode: {lobby.matchmaking.mode}");
    // Show "Searching for match…" UI
}

private void HandleQueueStats(QueueStats stats)
{
    // Update your UI: "42 players searching · ~12s avg wait"
    Debug.Log($"{stats.playersSearching} searching, {stats.avgWaitSeconds:F0}s avg wait");
}

private void HandleMatchFound(Lobby lobby)
{
    Debug.Log("Match committed! Server launching…");
    // Update UI to "Connecting…"
}

private void HandleMatchRunning(ConnectionInfo connectionInfo)
{
    // Quick-access for single-port games
    MyNetworkManager.Connect(connectionInfo.Ip, connectionInfo.Port);
}

private void HandleServerDetailsReady(List<PortMappingInfo> portMappings)
{
    // Preferred: look up by the port name you defined in the dashboard
    var lobby = PlayFlowLobbyManagerV2.Instance.CurrentLobby;
    if (lobby.TryGetPort("game_udp", out var port))
    {
        Debug.Log($"Connecting to {port.host}:{port.external_port}");
        MyNetworkManager.Connect(port.host, port.external_port);
    }
}

private void HandleMatchmakingCancelled(Lobby lobby) { /* back to lobby */ }
private void HandleMatchmakingTimeout(Lobby lobby)   { /* show "no match found" */ }

public void CancelSearch()
{
    var manager = PlayFlowLobbyManagerV2.Instance;

    if (!manager.IsHost || manager.CurrentLobby?.status != "in_queue")
    {
        return; // Can only cancel if you are the host and in the queue
    }

    manager.CancelMatchmaking(
        onSuccess: (lobby) => {
            Debug.Log("Successfully cancelled matchmaking.");
        },
        onError: (error) => {
            Debug.LogError($"Failed to cancel matchmaking: {error}");
        }
    );
}