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);
}
