public bool Equals(IUserPresence _userPresence, string _matchID) { return((MatchID == _matchID) && (UserPresence.SessionId == _userPresence.SessionId) && (UserPresence.Username == _userPresence.Username) && (UserPresence.UserId == _userPresence.UserId)); }
private void OnNewMatchPrecense(bool action, IUserPresence user) { if (action) { if (_usersOnMap.Count > 0) { var disPlayer = _usersOnMap.SingleOrDefault( x => x.UserPresence.UserId == user.UserId ); if (disPlayer != null) { Debug.LogWarning("Player Ya instanciado"); return; } } Debug.LogWarning("NetworkPlayerConnected"); var newPlayer = Instantiate(OnlinePlayerPref); newPlayer.UserPresence = user; newPlayer.SetName(user.Username); _usersOnMap.Add(newPlayer); } else { Debug.LogWarning("Deleting Player"); var disPlayer = _usersOnMap.SingleOrDefault(x => x.UserPresence.UserId == user.UserId); _usersOnMap.Remove(disPlayer); Destroy(disPlayer.GameObject); } }
// +++ functions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ private void AddActivePlayer(IUserPresence p) { if (_presences.Count(x => x.UserId == p.UserId) == 0) { _presences.Add(p); } }
private async void Start() { var deviceId = SystemInfo.deviceUniqueIdentifier; var session = await _client.AuthenticateDeviceAsync(deviceId); Debug.Log(session); _socket = _client.NewSocket(); _socket.Connected += () => Debug.Log("Socket connected."); _socket.Closed += () => Debug.Log("Socket closed."); _socket.ReceivedError += Debug.LogError; IUserPresence self = null; var connectedOpponents = new List <IUserPresence>(2); _socket.ReceivedMatchmakerMatched += async matched => { Debug.LogFormat("Matched result: {0}", matched); var match = await _socket.JoinMatchAsync(matched); self = match.Self; Debug.LogFormat("Self: {0}", self); connectedOpponents.AddRange(match.Presences); }; _socket.ReceivedMatchPresence += presenceEvent => { foreach (var presence in presenceEvent.Leaves) { connectedOpponents.Remove(presence); } connectedOpponents.AddRange(presenceEvent.Joins); // Remove yourself from connected opponents. connectedOpponents.Remove(self); Debug.LogFormat("Connected opponents: [{0}]", string.Join(",\n ", connectedOpponents)); }; await _socket.ConnectAsync(session); Debug.Log("After socket connected."); await _socket.AddMatchmakerAsync("*", 2, 2); // NOTE As an example create a second user and socket to matchmake against. var deviceId2 = Guid.NewGuid().ToString(); var session2 = await _client.AuthenticateDeviceAsync(deviceId2); var socket2 = _client.NewSocket(); socket2.ReceivedMatchmakerMatched += async matched => await socket2.JoinMatchAsync(matched); await socket2.ConnectAsync(session2); await socket2.AddMatchmakerAsync("*", 2, 2); await Task.Delay(TimeSpan.FromSeconds(10)); // disconnect after 10 seconds. Debug.Log("After delay socket2 closed."); await socket2.CloseAsync(); }
async void Start() { var deviceid = SystemInfo.deviceUniqueIdentifier; // NOTE should cache a user session. var session = await _client.AuthenticateDeviceAsync(deviceid); Debug.LogFormat("Session '{0}'", session); _socket = _client.CreateWebSocket(); IUserPresence self = null; var connectedOpponents = new List <IUserPresence>(0); _socket.OnMatchmakerMatched += async(sender, matched) => { Debug.LogFormat("Matched '{0}'", matched); var match = await _socket.JoinMatchAsync(matched); self = match.Self; Debug.LogFormat("Self '{0}'", self); connectedOpponents.AddRange(match.Presences); // NOTE shows how to send match state messages. var newState = new Dictionary <string, string> { { "hello", "world" } }.ToJson(); _socket.SendMatchState(match.Id, 0, newState); // Send to all connected users. }; _socket.OnMatchPresence += (sender, presenceChange) => { connectedOpponents.AddRange(presenceChange.Joins); foreach (var leave in presenceChange.Leaves) { connectedOpponents.RemoveAll(item => item.SessionId.Equals(leave.SessionId)); } ; // Remove yourself from connected opponents. connectedOpponents.RemoveAll(item => { return(self != null && item.SessionId.Equals(self.SessionId)); }); }; _socket.OnMatchState += (sender, message) => { var enc = System.Text.Encoding.UTF8; Debug.LogFormat("Match state '{0}'", enc.GetString(message.State)); }; _socket.OnConnect += (sender, evt) => Debug.Log("Socket connected."); _socket.OnDisconnect += (sender, evt) => Debug.Log("Socket disconnected."); await _socket.ConnectAsync(session); int minCount = 2; int maxCount = 8; var matchmakerTicket = await _socket.AddMatchmakerAsync("*", minCount, maxCount); Debug.LogFormat("Matchmaker ticket '{0}'", matchmakerTicket); }
private void OnMatchJoined(IMatch match) { _self = match.Self; var participants = match.Presences.ToArray(); foreach (var player in participants) { // MainThreadDispatcher.Instance().Enqueue(_gameManager.CreateShip(player)); } }
// ------------------------------------------- /* * QuitMatch */ public async Task QuitMatch() { if (m_currentMatch != null) { await NakamaConnection.Disconnect(m_currentMatch); m_currentMatch = null; m_localUser = null; m_players.Clear(); } }
private void NewPlayerJoined(IUserPresence player) { _readyPlayers.Add(player); UnityMainThreadDispatcher.Instance().Enqueue(() => { OnPlayerJoined?.Invoke(_readyPlayers.Count, player); }); if (_readyPlayers.Count >= _pendingMatch.Users.Count()) { StartMatch(); } }
// +++ event handler ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ async void OnMatchmakerMatched(object sender, IMatchmakerMatched e) { Debug.Log("Match found"); _match = await _socket.JoinMatchAsync(e); Debug.Log("match joined"); // persisting own presence _self = _match.Self; _matchId = _match.Id; _connectedUsers.AddRange(_match.Presences); }
/// <inheritdoc cref="PromotePartyMember"/> public Task PromotePartyMember(string partyId, IUserPresence partyMember) { var envelope = new WebSocketMessageEnvelope { Cid = $"{_cid++}", PartyPromote = new PartyPromote { PartyId = partyId, Presence = partyMember as UserPresence // TODO serialize interface directly in protobuf } }; return(SendAsync(envelope)); }
/// <inheritdoc="RemovePartyMemberAsync"/> public Task RemovePartyMemberAsync(string partyId, IUserPresence presence) { var envelope = new WebSocketMessageEnvelope { Cid = $"{_cid++}", PartyMemberRemove = new PartyMemberRemove { PartyId = partyId, Presence = presence as UserPresence } }; return(SendAsync(envelope)); }
/// <inheritdoc cref="AcceptPartyMemberAsync"/> public Task AcceptPartyMemberAsync(string partyId, IUserPresence presence) { var envelope = new WebSocketMessageEnvelope { Cid = $"{_cid++}", PartyAccept = new PartyAccept { PartyId = partyId, Presence = presence as UserPresence // TODO serialize interface directly in protobuf } }; return(SendAsync(envelope)); }
private void SubscribeSocketsEvents() { connectedOpponents = new List <IUserPresence>(); _socket.ReceivedMatchmakerMatched += async matched => { Debug.LogFormat("Matched result: {0}", matched); _currMatch = await _socket.JoinMatchAsync(matched); _self = _currMatch.Self; Debug.LogFormat("Self: {0}", _self); connectedOpponents.AddRange(_currMatch.Presences); OnMatchJoins(_currMatch.Presences); }; // _socket.ReceivedMatchPresence += presenceEvent => { OnMatchLeaves(presenceEvent.Leaves); connectedOpponents.Remove(_self); OnMatchJoins(presenceEvent.Joins); UnityMainThread.wkr.AddJob(() => _player.SetName(_self.Username)); connectedOpponents.AddRange(presenceEvent.Joins); }; // var enc = System.Text.Encoding.UTF8; _socket.ReceivedMatchState += newState => { var content = enc.GetString(newState.State); var code = newState.OpCode.ToDataCode(); switch (newState.OpCode.ToDataCode()) { case DataCode.POSITION: Debug.Log("A custom opcode -- > NEW POSITION."); break; default: Debug.LogFormat("User '{0}'' sent '{1}'", newState.UserPresence.Username, content); break; } UnityMainThread.wkr.AddJob(() => { OnNewDataState(newState.UserPresence.UserId, code, content); }); BoxTextController.WriteText("Receive data--> " + content, Color.yellow); }; }
/// <inheritdoc cref="RemovePartyMemberAsync"/> public Task RemovePartyMemberAsync(string partyId, IUserPresence presence) { int cid = Interlocked.Increment(ref _cid); var envelope = new WebSocketMessageEnvelope { Cid = $"{cid}", PartyMemberRemove = new PartyMemberRemove { PartyId = partyId, Presence = presence as UserPresence } }; return(SendAsync(envelope)); }
public async Task JoinMatchAsync() { Debug.Log("awaiting match"); // await joining match _match = await _socket.JoinMatchAsync(_matchMakerMatch); Debug.Log("match joined"); // persisting own presence self = _match.Self; _matchId = _match.Id; Debug.LogFormat("MatchId: {0}", _matchId); _connectedUsers.AddRange(_match.Presences); }
/// <inheritdoc cref="PromotePartyMemberAsync"/> public Task PromotePartyMemberAsync(string partyId, IUserPresence partyMember) { int cid = Interlocked.Increment(ref _cid); var envelope = new WebSocketMessageEnvelope { Cid = $"{cid}", PartyPromote = new PartyPromote { PartyId = partyId, Presence = partyMember as UserPresence // TODO serialize interface directly in protobuf } }; return(SendAsync(envelope)); }
/// <summary> /// Selects a number of cards equal to <see cref="Hand._cardsInHand"/> from players deck /// and sends them to that player. /// </summary> private async Task SendStartingHandAsync(IUserPresence presence) { if (presence.UserId == MatchCommunicationManager.Instance.HostId) { List <Card> cards = await _localHand.InitAsync(presence.UserId); MatchMessageStartingHand message = new MatchMessageStartingHand(presence.UserId, cards); MatchCommunicationManager.Instance.SendMatchStateMessageSelf(MatchMessageType.StartingHand, message); } else { List <Card> cards = await _opponentHand.InitAsync(presence.UserId); MatchMessageStartingHand message = new MatchMessageStartingHand(presence.UserId, cards); MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.StartingHand, message); _opponentGold.Restart(); } }
// ------------------------------------------- /* * OnReceivedMatchmakerMatched */ private async void OnReceivedMatchmakerMatched(IMatchmakerMatched matched) { // Cache a reference to the local user. m_localUser = matched.Self.Presence; // Debug.LogError("MatchId=" + matched.MatchId); // Debug.LogError("Token=" + matched.Token); // Debug.LogError("Ticket=" + matched.Ticket); // Join the match. var match = await NakamaConnection.Socket.JoinMatchAsync(matched); // Spawn a player instance for each connected user. foreach (var user in match.Presences) { RegisterPlayer(match.Id, user); } m_currentMatch = match; await NakamaConnection.SendMainChatMessage(REMOVE_ROOMS_MESSAGE, m_roomName); }
// ------------------------------------------- /* * SpawnPlayer * <param name="matchId">The match the player is connected to.</param> * <param name="user">The player's network presence data.</param> */ private async void RegisterPlayer(string _matchId, IUserPresence _user) { if (DEBUG) { Debug.LogError("+++++++++++++++++++++++++++++++++++++++++++++REGISTERPLAYER::_user.UserId=" + _user.UserId); } NakamaPlayer newPlayer = new NakamaPlayer(_user.UserId, _matchId, _user); bool found = false; foreach (NakamaPlayer player in m_players) { if (player.Equals(newPlayer)) { found = true; } } if (!found) { m_players.Add(newPlayer); } if (m_isGameCreator) { if (m_players.Count == m_totalPlayers) { if (DEBUG) { Debug.LogError("RegisterPlayer::SENDING UIDS"); } await SendUIDsPlayers(); } } }
private void OnPlayerLeft(IUserPresence player) { //TODO Destroy player's ship object Debug.Log("Player Left: " + player.Username); }
private void OnPlayerJoined(IUserPresence player) { // MainThreadDispatcher.Instance().Enqueue(_gameManager.CreateShip(player)); }
void DeleteRemotePlayer(IUserPresence presence) { remotePlayersToDestroy.Add(presence.UserId); }
private bool Equals(IUserPresence other) => string.Equals(SessionId, other.SessionId) && string.Equals(UserId, other.UserId);
void OnPlayerJoinedMatch(int totalReadyPlayers, IUserPresence newPlayer) { ReadyPlayersCount.UpdateCurrentPlayers(totalReadyPlayers); }
public bool Equals(IUserPresence _userPresence) { return((UserPresence.SessionId == _userPresence.SessionId) && (UserPresence.Username == _userPresence.Username) && (UserPresence.UserId == _userPresence.UserId)); }
private bool HasPlayerAlreadyJoined(IUserPresence player) { return(_readyPlayers.Contains(player)); }
public NakamaPlayer(string _ID, string _MatchID, IUserPresence _UserPresence) { ID = _ID; MatchID = _MatchID; UserPresence = _UserPresence; }
void SpawnRemotePlayer(IUserPresence presence) { remotePlayersToSpawn.Add(presence.UserId); }