// 匹配同玩接口：
访问接口入口 MatchManager = ICloudSync.Instance.MatchManager;
请求匹配 RequestMatch
结束同玩 EndMatchGame

// 监听事件：玩家加入/离开
ICloudSync.Instance.OnSeatPlayerJoined
ICloudSync.Instance.OnSeatPlayerLeaving

// 监听事件：匹配到了其他用户
MatchManager.OnMatchUsers
// 监听事件：结束同玩了（返回单播）
MatchManager.OnEndMatchGame

private async Task<bool> InitCloudGame(string appId)
{
    // 云同步初始化 Init
    var initResult = await ICloudSync.Instance.Init(appId, new UDeviceFactory(viewProvider));
    if (!initResult.IsSuccess)
    {
        Debug.LogError($"Init 初始化失败，无法启动云游戏 {initResult.Message}");
        return false;
    }
    return true;
}

// 添加事件监听
private void InitEvents()
{
    // 监听事件：玩家加入/离开
    ICloudSync.Instance.OnSeatPlayerJoined += OnPlayerJoined;
    ICloudSync.Instance.OnSeatPlayerLeaving += OnPlayerLeaving;
    
    MatchManager = ICloudSync.Instance.MatchManager;
    // 可选：监听事件：匹配到了其他用户
    MatchManager.OnMatchUsers += OnMatchUsers;
    // 监听事件：结束同玩了（返回单播）
    MatchManager.OnEndMatchGame += OnEndMatchGame;
}

/// 开始匹配
private async void StartMatch()
{
    MatchManager = ICloudSync.Instance.MatchManager;
    // 匹配配置，选择一个系统自带提供的匹配池
    var matchConfig = new SimpleMatchConfig()
    {
        PoolType = SimpleMatchPoolType.P1v1, // 2人 1v1
        MatchTag = "Demo-test-1.0" // 匹配标签，区分开用户
    };
    
    // 开始匹配，传入匹配配置。 成功后进入系统自动进入多人同玩状态。
    var task = MatchManager.RequestMatch(matchConfig); 
    var result = await task; // 等待结果    
    // todo: 处理结果：OnMatchResult(result);
}

public class SimpleMatchConfig
{
    /// 选择匹配池，对应一套匹配规则
    public SimpleMatchPoolType PoolType;

    /// 匹配标签，区分开用户。 建议用不同值区分开测试环境"test"、线上环境"online"，也可以用于分开不同版本"1.0","2.0"。 Example: 例如："test-1.0", "online-2.0"
    public string MatchTag;
}

public enum SimpleMatchPoolType
{
    /// 2人 1v1
    P1v1,
    /// 4人 2v2
    P2v2,
    /// 4人各自1队
    P1x4,
    /// 3人各自1队
    P1x3,
}

private CancellationTokenSource _matchCancel;
/// 开始匹配
private async void StartMatch()
{
    // 设置本地游戏状态，可自定义表现，例如：显示“匹配中”文字、Loading转圈、按钮置灰等等...
    SetState(State.Matching);

    // 创建取消用的 CancellationTokenSource，using使其自动Dispose
    using CancellationTokenSource cancel = _matchCancel = new CancellationTokenSource();
    
    // 匹配配置，选择一个系统自带提供的匹配池
    var matchConfig = ...;
    
    // 开始匹配，传入匹配配置，传入可取消用的cancel.Token。 成功后进入系统自动进入多人同玩状态。
    var task = MatchManager.RequestMatch(matchConfig, cancel.Token); 
    var result = await task; // 等待结果    
    _matchCancel = null; // 已出结果，不再需要取消，应把 TokenSource 引用置null    
    // todo: 处理结果：OnMatchResult(result);
}

/// 主动取消匹配
private void CancelMatch()
{
    if (_matchCancel != null)
    {
        // 主动取消。 若成功取消，`RequestMatch`返回结果的`IMatchResult.Code`会是`Cancelled`
        _matchCancel.Cancel();        
        // 取消后，应把 TokenSource 引用置null
        _matchCancel = null;
    }
}

// 监听事件
MatchManager.OnMatchUsers += OnMatchUsers;

private void OnMatchUsers(IMatchResult matchResult)
{
    var isHost = matchResult.IsHost;
    var myIndex = matchResult.MyIndex;
    var users = matchResult.AllUsers;
    var opponents = users.Where(s => s.RoomIndex != myIndex).ToList();
    var oppoNames = string.Join(", ", opponents.Select(s => s.Nickname).ToList());
    ShowHostNote($"匹配到了用户: {oppoNames}");
}

/// 处理匹配结果
private void OnMatchResult(IMatchResult result)
{
    _matchResult = result;
    // 处理失败情况
    if (!result.IsSuccess)
    {
        var debugMsg = $"code: {result.Code} ({(int)result.Code}), msg: {result.Message}";
        // 根据返回码：`result.Code`枚举判断
        switch (result.Code)
        {
            case MatchResultCode.Success:
                break;
            case MatchResultCode.Cancelled:
                Debug.Log($"StartMatch 取消 {debugMsg}");
                break;
            case MatchResultCode.Timeout:
                Debug.LogWarning($"StartMatch 匹配超时 {debugMsg}");
                break;
            case MatchResultCode.Error:
            default:
                Debug.LogError($"StartMatch 匹配失败 {debugMsg}");
                break;
        }

        // 重置本地游戏状态、界面，并返回，允许后续操作。
        SetState(State.Ready);
        return;
    }

    var isHost = result.IsHost;
    Debug.Log($"StartMatch 匹配成功 isHost: {isHost}");
    // 处理成功情况
    OnMatchSuccess(isHost);
}

/// 处理匹配结果成功情况
private void OnMatchSuccess(bool isHost)
{
    var result = _matchResult;
    if (isHost)
    {
        // 匹配成功后，若我方是房主，应负责加载启动本局游戏（包括例如加载游戏资源、切换场景、显示界面UI等）。
        // 房主A 
        SetState(State.InGameHost);
        // 从result中，可以获取到匹配结果信息内容，例如：标识一场匹配的id`MatchId`，我的座位号`MyIndex`，房主用户`HostUser`；各个玩家用户的列表`AllUsers`，Team列表`Teams`
        var playersCount = result.AllUsers.Count;
        game.LoadGame(new GameInfo
        {
            isPk = true,
            playersCount = playersCount,
        });
    }
    else
    {
        // 若我方是要加入同玩的玩家，系统会切流加入到房主A的实例去同玩。 本地无需特殊处理，可以自定义显示，例如：显示“与...同玩中”、显示Loading。
        // 玩家B 
        SetState(State.InConnectOther);
    }
}

// 监听事件：玩家加入/离开
ICloudSync.Instance.OnSeatPlayerJoined += OnPlayerJoined;
ICloudSync.Instance.OnSeatPlayerLeaving += OnPlayerLeaving;

// 匹配成功
private void OnMatchSuccess(bool isHost)
{
    if (isHost)
    {
        // 匹配成功后，若我方是房主，应负责加载启动本局游戏（包括例如加载游戏资源、切换场景、显示界面UI等）
        LoadGame(...);
    }
}

// 等待和检查玩家B的加入事件
private void OnPlayerJoined(ICloudSeat seat)
{
    Debug.Log($"Game OnPlayerJoin seat index: {seat.Index}");
    if (State == GameState.Loaded)
        CheckStartGame();
}

// 加载游戏
public void LoadGame(...)
{
    State = GameState.Loaded;
    // todo: 自定义实现：加载游戏资源、切换场景、显示界面UI等...
    // 检查确认
    CheckStartGame();
}

// 检查确认
private void CheckStartGame()
{
    if (State != GameState.Loaded)
        return;
    // 检查玩家加入到齐、确认OK后，开始正式一局游戏玩法。
    if (ArePlayersJoined(seats))
    {
        InitPlayerInfos(seats);
        // 开始正式一局游戏玩法
        StartGame();
    }
}

private ICloudSeat _seat;

/// 显示结算
public void ShowGameResult(GameResult result, ICloudSeat seat)
{
    _seat = view.Seat;
}

// 当点击【退出】
private async void OnClickExit()
{
    await EndMatchGame(_seat.IsHost(), _seat.Index);
    // todo: 结束同玩了，后续流程
    OnConfirmEnd();
}

// 区分是否房主，结束同玩
private async Task EndMatchGame(bool isHost, SeatIndex roomIndex)
{
    var resultJson = JsonUtility.ToJson(_result);
    Debug.Log($"GameResult EndMatchGame isHost: {isHost}, roomIndex: {roomIndex}");
    if (isHost)
    {
        // 若是房主A点击【退出】，调用EndMatchGame 且不指定座位号，并传入结束信息
        // 逻辑其实是踢所有人，这时我们需要把结算结果透传给另一个主播
        // 让另一个主播在回到原实例后仍可继续看结算结果（收到OnEndMatchGame事件）
        await ICloudSync.Instance.MatchManager.EndMatchGame(resultJson);
    }
    else
    {
        // 若是玩家B点击【退出】，调用EndMatchGame 且指定座位号 index1，并传入结束信息
        // [可选] 自定义结束信息，因为他是自己主动退了， 他已经看到了结算信息，所以可按需要自定义透传什么结束信息。
        await ICloudSync.Instance.MatchManager.EndMatchGame(roomIndex, resultJson);
    }
}

// 监听事件
MatchManager.OnEndMatchGame += OnEndMatchGame;

// 收到事件：结束同玩了（返回单播）
private void OnEndMatchGame(string info)
{
    var hasEndInfo = !string.IsNullOrEmpty(info);
    if (hasEndInfo)
    {
        // 玩家回流到自己实例
        ShowHostNote("回流了");
        try
        {
            // 回流的玩家，收到结算信息
            var gameResult = JsonUtility.FromJson<GameResult>(info);
            if (gameResult != null)
                ViewA.ShowGameResult(gameResult, false);
        }
        catch (Exception)
        {
            ShowHostAlert("endInfo", info);
        }
    }
    else
    {
        // 房主自己结束同玩了（或者调用结束同玩时，没有传入结束信息、为空）
        ShowHostNote("结束同玩了");
    }
    
    SetState(State.Ready);
}

private void OnPlayerLeaving(ICloudSeat seat)
{
    var playerText = seat.IsHost() ? "主播" : $"玩家{seat.IntIndex + 1}";
    ViewA.ShowNote($"{playerText}： {seat.PlayerInfo?.NickName} 离开了游戏");
    
    if (State != GameState.Started)
        return;
        
    CheckGameEnd();
}

private void CheckGameEnd()
{
    if (State != GameState.Started)
        return;

    if (AreOtherSeatsDisconnected())
    {
        // 其他玩家都已退出同玩。房主侧不强制退出，开发者可以在做好合适的展示后，自己调用`结束同玩`接口
        Debug.Log("其他玩家都已退出同玩");
        EndGame();
        return;
    }

    if (_liveBlockCount == 0)
    {
        Debug.Log("游戏关卡完成");
        EndGame();
    }
}