public void Interpret(INetworkMediator netHost, EndPoint sender, IMessage message)
{
try
{
INetPlayer player = netHost.PlayerRepository.GetPlayer(sender);
if (!player.IsInEngine)
{
player.IsInEngine = true;
}
}
catch (PlayerNotFoundException) { }
}
public override void OnData(int connectionId, byte[] buffer, NetworkError error)
{
if (error != NetworkError.Ok)
{
Debug.LogWarning(this.ToString() + " OnData from connection ID == " + connectionId.ToString() + ", buffer size == " + buffer.Length.ToString() + ", encountered NetworkError == " + error.ToString());
return;
}
var messageType = buffer.PeekType();
if (printEveryMessageReceived)
{
Debug.Log(this.ToString() + " OnData. Connection Id == " + connectionId.ToString()
+ ", error == " + error.ToString() + ", message type == " + messageType.ToString() + ", buffer size == " + buffer.Length.ToString() /*+ ", contents:\n" + buffer.DebugLogContents()*/);
}
bool handled = false;
switch (messageType)
{
case NetMessageType.LocalConnect:
{
HandlePlayerLocalConnect(connectionId, buffer);
handled = true;
break;
}
default:
{
break;
}
}
INetPlayer player = GetPlayer(connectionId);
// handle messages outside of this class, for modularity
for (int i = 0; i < messageHandlers.Count; i++)
{
var h = messageHandlers[i];
if (h.handleTypes.Count == 0 || h.handleTypes.Contains(messageType))
{
h.ServerHandleMessageFromClient(messageType, buffer, player != null ? player.netId : (short)-1);
handled = true;
}
}
if (!handled)
{
Debug.LogError(this.ToString() + " OnData unhandled MessageType == " + messageType.ToString());
}
}
/// <summary>
/// Removes the given player from the players' dictionary.
/// See also <seealso cref="M:VRNetwork.NetworkBase`1.AddPlayer(VRNetwork.INetPlayer)" /> and <seealso cref="M:VRNetwork.NetworkBase`1.GetPlayer(System.Int32)" />
/// </summary>
/// <param name="player">The player.</param>
/// <returns></returns>
protected override bool RemovePlayer(INetPlayer player)
{
var connectionId = GetConnectionId(player.netId);
if (connectionId == int.MinValue)
{
Debug.LogError(this.ToString() + " could not remove player (" + player.ToString() + " : " + player.netId.ToString() + "), since no connection ID exists in lookup");
return(false);
}
var netId = player.netId;
return(base.RemovePlayer(netId) && _connectionIdLookup.Remove(netId) && _netIdLookup.Remove(connectionId));
}
public void Interpret(INetworkMediator netMediator, EndPoint sender, IMessage message)
{
try
{
INetPlayer player = netMediator.PlayerRepository.GetPlayer(sender);
if (!player.IsInEngine)
{
player.IsInEngine = true;
}
}
catch (PlayerNotFoundException ex)
{
netMediator.EngineProxy.Logger.LogException(ex);
}
}
public void AddPlayer_ShouldGetSamePlayer()
{
var id = AbstractFactory.Get <INetworkTypeFactory>().GetNew <IPlayerSignature>();
var player = A.Fake <INetPlayer>();
A.CallTo(() => player.Id).Returns(id);
var repo = AbstractFactory.Get <INetworkTypeFactory>().GetNew <IPlayerRepository>();
Assert.AreEqual(0, repo.Count);
repo.AddPlayer(player);
Assert.AreEqual(1, repo.Count);
INetPlayer found = repo.GetPlayer(player.Id);
Assert.AreEqual(player, found);
Assert.AreEqual(player.Id, found.Id);
Assert.AreEqual(1, repo.Count);
}
protected override void ProcessMessageRead(BMSByte buffer, EndPoint sender)
{
if (_bannedEndpoints.Contains(sender))
{
return;
}
else if (!networkMediator.PlayerRepository.Exists(sender))
{
CleanupOldChallengedPlayers();
if (!_challengedPlayers.Exists(sender))
{
synchronizationContext.Post(CreatePlayer, sender);
}
else
{
ProcessPlayerMessageRead(_challengedPlayers.GetPlayer(sender), buffer);
}
}
else
{
INetPlayer player = networkMediator.PlayerRepository.GetPlayer(sender);
ProcessPlayerMessageRead(player, buffer);
}
}
public void Interpret(INetworkMediator netMediator, EndPoint sender, IMessage message)
{
INetPlayer player = netMediator.PlayerRepository.GetPlayer(sender);
GameObject.FindObjectOfType <ComplexSampleNetwork>().PlayerJoined(player);
}
public void SendMessage(IMessage message, INetPlayer player)
{
MessageBus.SendMessage(message, SocketFacade.ManagedSocket, player.EndPoint);
}
public void ClearBufferFor(INetPlayer player)
{
_messageConstructors.Remove(player.EndPoint);
}
private void PlayerRemovedFromRepository(INetPlayer player)
{
MessageBufferInterpreter.ClearBufferFor(player);
}
/// <summary>
/// Removes the given player from the players' dictionary.
/// </summary>
/// <param name="player">The player.</param>
/// <returns></returns>
/// <seealso cref="AddPlayer(INetPlayer)"/>
/// <seealso cref="GetPlayer(short)"/>
protected virtual bool RemovePlayer(INetPlayer player)
{
return(RemovePlayer(player.netId));
}
/// <summary>
/// Adds the given player to a dictionary using the player's netId as the key.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="netId">The net identifier to set on the player.</param>
/// <seealso cref="GetPlayer(short)"/>
/// <seealso cref="RemovePlayer(short)"/>
protected void AddPlayer(INetPlayer player, short netId)
{
player.SetNetId(netId);
_players.Add(netId, player);
}
/// <summary>
/// Adds a player to the server.
/// </summary>
/// <param name="connectionId">The connection identifier.</param>
/// <param name="player">The player.</param>
protected void AddPlayer(INetPlayer player, int connectionId, short netId)
{
_connectionIdLookup.Add(netId, connectionId);
_netIdLookup.Add(connectionId, netId);
base.AddPlayer(player, netId);
}
protected void ProcessPlayerMessageRead(INetPlayer player, BMSByte buffer)
{
player.LastCommunication = DateTime.Now;
networkMediator.MessageBus.ReceiveMessageBuffer(ManagedSocket, player.EndPoint, buffer);
}
