Matchmaking System

public class MatchmakingHub : Hub
{
    private readonly LobbiesManager _lobbiesManager;
    
    public async Task FindOrCreateLobby()
    {
        var connectionId = Context.ConnectionId;
        
        // 1. 입장 가능한 로비 찾기
        var lobby = _lobbiesManager.FindLobby();
        
        // 2. 없으면 새로 생성
        if (lobby == null)
        {
            lobby = _lobbiesManager.CreateLobby();
        }
        
        // 3. 로비에 멤버 추가
        if (lobby.AddMember(connectionId))
        {
            // 4. SignalR 그룹에 추가
            await Groups.AddToGroupAsync(connectionId, lobby.Id.ToString());
            
            // 5. 로비 상태를 그룹 전체에 브로드캐스트
            await NotifyLobbyUpdated(lobby);
            
            // 6. 로비가 꽉 찼으면 매칭 완료 알림
            if (lobby.IsFull)
            {
                await Clients.Group(lobby.Id.ToString())
                    .SendAsync("MatchFound");
            }
        }
    }
    
    private async Task NotifyLobbyUpdated(Lobby lobby)
    {
        await Clients.Group(lobby.Id.ToString())
            .SendAsync("LobbyUpdated", new LobbyStatus
            {
                LobbyId = lobby.Id,
                CurrentPlayers = lobby.MemberCount,
                MaxPlayers = lobby.MaxPlayers
            });
    }
}

public class MatchmakingClient : MonoBehaviour
{
    private HubConnection _connection;
    public event Action<LobbyStatus> OnLobbyUpdated;
    public event Action OnMatchFound;
    
    public async Task ConnectAsync()
    {
        _connection = new HubConnectionBuilder()
            .WithUrl("https://matchmaking-server.com/matchmaking")
            .WithAutomaticReconnect()
            .Build();
        
        // 로비 업데이트 이벤트 등록
        _connection.On<LobbyStatus>("LobbyUpdated", (status) =>
        {
            UnityMainThreadDispatcher.Enqueue(() =>
            {
                OnLobbyUpdated?.Invoke(status);
            });
        });
        
        // 매칭 완료 이벤트 등록
        _connection.On("MatchFound", () =>
        {
            UnityMainThreadDispatcher.Enqueue(() =>
            {
                OnMatchFound?.Invoke();
            });
        });
        
        await _connection.StartAsync();
    }
    
    public async Task StartMatchmakingAsync()
    {
        await _connection.InvokeAsync("FindOrCreateLobby");
    }
}

// Unity 클라이언트 연결 설정
var connection = new HubConnectionBuilder()
    .WithUrl("https://matchmaking-server.com/matchmaking")
    .WithAutomaticReconnect(new[] { 
        TimeSpan.Zero, 
        TimeSpan.FromSeconds(2),
        TimeSpan.FromSeconds(10),
        TimeSpan.FromSeconds(30)
    })
    .Build();

// 재연결 이벤트 처리
connection.Reconnecting += error =>
{
    Debug.Log("Connection lost. Reconnecting...");
    return Task.CompletedTask;
};

connection.Reconnected += connectionId =>
{
    Debug.Log("Reconnected successfully!");
    return Task.CompletedTask;
};

public class LobbiesManager
{
    private readonly ConcurrentDictionary<int, Lobby> _lobbies 
        = new ConcurrentDictionary<int, Lobby>();
    
    public Lobby CreateLobby()
    {
        var lobbyId = Interlocked.Increment(ref _nextLobbyId);
        var lobby = new Lobby(lobbyId);
        
        // Thread-safe하게 추가
        _lobbies.TryAdd(lobbyId, lobby);
        return lobby;
    }
    
    public void RemoveLobby(int lobbyId)
    {
        // Thread-safe하게 제거
        _lobbies.TryRemove(lobbyId, out _);
    }
}

public class Lobby
{
    private readonly object _gate = new object();
    private readonly HashSet<string> _members = new HashSet<string>();
    
    public bool AddMember(string connectionId)
    {
        lock (_gate)
        {
            if (_members.Count >= MaxPlayers)
                return false;
            
            return _members.Add(connectionId);
        }
    }
    
    public int MemberCount
    {
        get
        {
            lock (_gate)
            {
                return _members.Count;
            }
        }
    }
}

public class UnityMainThreadDispatcher : MonoBehaviour
{
    private static UnityMainThreadDispatcher _instance;
    private readonly Queue<Action> _executionQueue = new Queue<Action>();
    private readonly object _queueLock = new object();
    
    public void Awake()
    {
        if (_instance == null)
        {
            _instance = this;
            DontDestroyOnLoad(gameObject);
        }
    }
    
    public static void Enqueue(Action action)
    {
        lock (_instance._queueLock)
        {
            _instance._executionQueue.Enqueue(action);
        }
    }
    
    void Update()
    {
        // 메인 스레드에서 큐의 작업들을 순차적으로 실행
        lock (_queueLock)
        {
            while (_executionQueue.Count > 0)
            {
                _executionQueue.Dequeue().Invoke();
            }
        }
    }
}