internal override void HandleActorCreation(INetworkMessageIn msg)
{
var quantity = msg.ReadInt();
for (int i = 0; i < quantity; i++)
{
var id = msg.ReadInt();
var x = msg.ReadInt();
var y = msg.ReadInt();
var hashedClassName = msg.ReadInt();
if (Actors.Exists(a => a.Id == id))
{
return;
}
var newActor = CreateRemoteActorByName(hashedClassName, id, x, y);
if (newActor == null)
{
return;
}
Actors.Add(newActor);
if (newActor.ReplicateProperties)
{
newActor.Deserialize(msg);
}
}
}
internal override void HandleServerTravel(INetworkMessageIn msg)
{
// do exactly as if the client just connected
_readyConnections[msg.UniqueId] = new ReadyConnection();
HandleActorRequestPlayerActor(msg);
}
internal override void HandleClientDisconnected(INetworkMessageIn msg)
{
int id = msg.ReadInt();
Actors.RemoveAll(a => a.Id == id);
HandlePlayerDisconnected(id);
}
internal override void HandleChatMessage(INetworkMessageIn msg)
{
var message = msg.ReadString();
ReceivedChatMessage(message);
NetworkImplementation?.SendChatMessage(message);
}
internal override void HandleActorRequestPlayerActor(INetworkMessageIn msg)
{
var id = msg.ReadInt();
var x = msg.ReadInt();
var y = msg.ReadInt();
var player = CreateLocalPlayer(id, x, y);
Actors.Add(player);
}
/// <summary>
/// Runs on client.
/// </summary>
public override void Deserialize(INetworkMessageIn message)
{
// remember to read on the same sequence that we write
_pointsLeft = message.ReadInt();
_pointsRight = message.ReadInt();
ReconstructScore();
// always call the base Deserialize to ensure all properties are replicated
base.Deserialize(message);
}
internal override void HandleActorPropertiesReplication(INetworkMessageIn msg)
{
int actorQuantity = msg.ReadInt();
for (int i = 0; i < actorQuantity; i++)
{
int id = msg.ReadInt();
var actor = Actors.FirstOrDefault(a => a.Id == id);
actor?.Deserialize(msg);
}
}
internal virtual void HandleConnectionApproval(INetworkMessageIn msg)
{
var approvalMessage = msg.ReadString();
if (ApproveConnection(approvalMessage))
{
NetworkImplementation?.ApproveMessage(msg);
}
else
{
NetworkImplementation?.DisapproveMessage(msg);
}
}
internal override void HandleServerTravel(INetworkMessageIn msg)
{
var newGameState = msg.ReadByte();
var worldBuilderClass = msg.ReadString();
var levelName = msg.ReadString();
Actors.Clear();
ChangeGameState(newGameState, levelName);
var outMessage = CreateMessage(NetworkMessageType.ServerTravel);
SendMessageToAll(outMessage, MessageDeliveryMethod.ReliableOrdered, 2);
}
internal override void HandleActorDestruction(INetworkMessageIn msg)
{
int id = msg.ReadInt();
var actor = Actors.FirstOrDefault(a => a.Id == id);
if (actor == null)
{
return;
}
actor.IsMarkedToDestroy = true;
actor.RemoteDestroyed();
}
public void SendMessageToSender(INetworkMessageIn to, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
if (_netPeer == null)
{
throw new NullReferenceException("NetPeer was not initialized.");
}
message.Encrypt();
var outMessage = ((NetworkMessageOutLidgren)message).GetInternalMessage();
var inMessage = ((NetworkMessageInLidgren)to).GetInternalMessage();
_netPeer.SendMessage(outMessage, inMessage.SenderConnection, deliveryMethod.ToDeliveryMethod(), channel);
}
internal override void HandleStatusChangedConnected(INetworkMessageIn msg)
{
if (!_readyConnections.ContainsKey(msg.UniqueId))
{
_readyConnections.Add(msg.UniqueId, new ReadyConnection());
NetworkImplementation?.ClientJoinedSession(msg);
if (_lastLevelChange != null)
{
var message = CreateLevelChangeMessage(_lastLevelChange);
SendMessageToId(msg.UniqueId, message, MessageDeliveryMethod.ReliableOrdered, 2);
}
}
}
internal override void HandleActorReplication(INetworkMessageIn msg)
{
int actorQuantity = msg.ReadInt();
for (int i = 0; i < actorQuantity; i++)
{
int id = msg.ReadInt();
int x = msg.ReadInt();
int y = msg.ReadInt();
var actor = Actors.FirstOrDefault(a => a.Id == id);
actor?.SetLocation(x, y);
}
}
internal virtual void HandleActorRemoteMethodCall(INetworkMessageIn msg)
{
int id = msg.ReadInt();
int methodKey = msg.ReadInt();
byte parameterCount = msg.ReadByte();
var parameters = new object[parameterCount];
for (byte i = 0; i < parameterCount; i++)
{
var type = (NetworkRemoteCallParameterType)msg.ReadByte();
switch (type)
{
case NetworkRemoteCallParameterType.Int:
parameters[i] = msg.ReadInt();
break;
case NetworkRemoteCallParameterType.Float:
parameters[i] = msg.ReadFloat();
break;
case NetworkRemoteCallParameterType.String:
parameters[i] = msg.ReadString();
break;
case NetworkRemoteCallParameterType.Boolean:
parameters[i] = msg.ReadBool();
break;
}
}
try
{
if (_remoteMethods.ContainsKey(methodKey))
{
var actor = Actors.FirstOrDefault(a => a.Id == id);
actor?.GetType().InvokeMember(_remoteMethods[methodKey], BindingFlags.InvokeMethod, null, actor, parameters);
}
}
catch
{
// todo: throw?
}
}
internal override void HandleDisconnected(INetworkMessageIn msg)
{
var player = _readyConnections[msg.UniqueId].PlayerActor;
if (player == null)
{
return;
}
RemoveRemotePlayer(player);
_readyConnections.Remove(msg.UniqueId);
var message = CreateMessage(NetworkMessageType.ClientDisconnected);
message.Write(player.Id);
SendMessageToIds(GetReadyConnectionIds(), message, MessageDeliveryMethod.ReliableUnordered, 0);
}
internal override void HandleActorRequestPlayerActor(INetworkMessageIn msg)
{
if (_readyConnections.ContainsKey(msg.UniqueId) && _readyConnections[msg.UniqueId].PlayerActor != null)
{
return;
}
var playerName = "default"; //todo: get remote player name
var newPlayer = CreateRemotePlayer(playerName);
Actors.Add(newPlayer);
var outMessage = CreateMessage(NetworkMessageType.ActorRequestPlayerActor);
AppendActorCreationMessage(outMessage, newPlayer);
SendMessageToSender(msg, outMessage, MessageDeliveryMethod.ReliableUnordered, 0);
_readyConnections[msg.UniqueId].PlayerActor = newPlayer;
SendSyncronizeActors(msg);
}
public void DisapproveMessage(INetworkMessageIn message)
{
var msg = ((NetworkMessageInLidgren)message).GetInternalMessage();
msg.SenderConnection.Deny();
}
public void ClientJoinedSession(INetworkMessageIn msg)
{
}
protected void SendMessageToSender(INetworkMessageIn to, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
NetworkImplementation?.SendMessageToSender(to, message, deliveryMethod, channel);
}
/// <summary>
/// This code gets the values in the same order sent by the server on all clients.
///
/// Remember to keep the exact same type serialized and in the same order.
/// </summary>
/// <param name="message"></param>
public virtual void Deserialize(INetworkMessageIn message)
{
}
internal virtual void HandleActorDestruction(INetworkMessageIn msg)
{
}
internal override void HandleDisconnected(INetworkMessageIn msg)
{
HandleDisconnected();
}
internal virtual void HandleServerTravel(INetworkMessageIn msg)
{
}
private void SendSyncronizeActors(INetworkMessageIn to)
{
var outMessage = GetActorsSendMessage(Actors);
SendMessageToSender(to, outMessage, MessageDeliveryMethod.ReliableUnordered, 0);
}
internal virtual void HandleActorCreation(INetworkMessageIn msg)
{
}
internal virtual void HandleActorPropertiesReplication(INetworkMessageIn msg)
{
}
internal virtual void HandleStatusChangedConnected(INetworkMessageIn msg)
{
}
internal virtual void HandleActorRequestPlayerActor(INetworkMessageIn msg)
{
}
internal override void HandleChatMessage(INetworkMessageIn msg)
{
var message = msg.ReadString();
ReceivedChatMessage(message);
}
internal virtual void HandleClientDisconnected(INetworkMessageIn msg)
{
}
