public void Receive(NetIncomingMessage msg)
{
for (var i = 0; i < net_states.Count; ++i)
{
net_states[i].Receive(msg);
}
}
public void ReceiveMessage(object sender, NetIncomingMessage msg)
{
#if !EXTERNAL
UnityEngine.Debug.Log("Got message [" + msg.LengthBytes + "B]");
#else
Console.WriteLine("Got message [" + msg.LengthBytes + "B]");
#endif
MsgType type = (MsgType)msg.ReadByte();
switch (type)
{
case MsgType.RecommendationRequest:
if (this.RecommendationRequested != null)
this.RecommendationRequested(msg);
break;
case MsgType.RecommendationContent:
if (this.RecommendationReceived != null)
this.RecommendationReceived(msg);
break;
case MsgType.RecommendationSelected:
if (this.RecommendationSelected != null)
this.RecommendationSelected(msg);
break;
case MsgType.ObjectsFreed:
if (this.ObjectsFreed != null)
this.ObjectsFreed(msg);
break;
case MsgType.Sentiments:
if (this.Sentiments != null)
this.Sentiments(msg);
break;
default: break;
}
}
static object ReadArgument(NetIncomingMessage msg, Type type)
{
if (type == typeof(int))
{
return msg.ReadInt32();
}
else if (type == typeof(byte))
{
return msg.ReadByte();
}
else if (type == typeof(float))
{
return msg.ReadFloat();
}
else if (type == typeof(Vector3))
{
return NetworkUtils.ReadVector3(msg);
}
else if (type == typeof(Quaternion))
{
return NetworkUtils.ReadQuaternion(msg);
}
else if (type == typeof(string))
{
return msg.ReadString();
}
else
{
throw new Exception("Unsupported argument type " + type);
}
}
private void OnDeserializeStream(NetIncomingMessage netIncomingMessage)
{
//deserialize position from the stream
//TODO: implement smoothing/lag compensation
_serializer.OnDeserialize(netIncomingMessage);
transform.position = _serializer.vector3;
}
public static void ReceiveRemoteCall(NetIncomingMessage msg)
{
var instance = GetCallTargetInstance(msg.ReadInt32());
if (instance == null)
{
return;
}
var instanceType = instance.GetType();
var methodName = msg.ReadString();
var method = instanceType.GetMethod(methodName);
Debug.Log("RPC: " + instanceType.Name + "." + methodName);
if (method == null)
{
throw new Exception("Found no method named '" + methodName + "' on type '" + instance.GetType() + "'");
}
var parms = method.GetParameters();
var args = new object[parms.Length];
args[0] = msg;
for (var i = 1; i < args.Length; ++i)
{
args[i] = ReadArgument(msg, parms[i].ParameterType);
}
method.Invoke(instance, args);
}
internal override void ReceiveMessage(NetIncomingMessage message)
{
int relate = NetUtility.RelativeSequenceNumber(message.m_sequenceNumber, m_windowStart);
// ack no matter what
m_connection.QueueAck(message.m_receivedMessageType, message.m_sequenceNumber);
if (relate == 0)
{
// Log("Received message #" + message.SequenceNumber + " right on time");
//
// excellent, right on time
//
//m_peer.LogVerbose("Received RIGHT-ON-TIME " + message);
AdvanceWindow();
m_peer.ReleaseMessage(message);
// release withheld messages
int nextSeqNr = (message.m_sequenceNumber + 1) % NetConstants.NumSequenceNumbers;
while (m_earlyReceived[nextSeqNr % m_windowSize])
{
message = m_withheldMessages[nextSeqNr % m_windowSize];
NetException.Assert(message != null);
// remove it from withheld messages
m_withheldMessages[nextSeqNr % m_windowSize] = null;
m_peer.LogVerbose("Releasing withheld message #" + message);
m_peer.ReleaseMessage(message);
AdvanceWindow();
nextSeqNr++;
}
return;
}
if (relate < 0)
{
m_peer.LogVerbose("Received message #" + message.m_sequenceNumber + " DROPPING DUPLICATE");
// duplicate
return;
}
// relate > 0 = early message
if (relate > m_windowSize)
{
// too early message!
m_peer.LogDebug("Received " + message + " TOO EARLY! Expected " + m_windowStart);
return;
}
m_earlyReceived.Set(message.m_sequenceNumber % m_windowSize, true);
m_peer.LogVerbose("Received " + message + " WITHHOLDING, waiting for " + m_windowStart);
m_withheldMessages[message.m_sequenceNumber % m_windowSize] = message;
}
internal override void ReceiveMessage(NetIncomingMessage msg)
{
// ack no matter what
m_connection.QueueAck(msg.m_receivedMessageType, msg.m_sequenceNumber);
m_peer.ReleaseMessage(msg);
}
/// <summary>
/// Processes a handshake response (initiated locally)
/// </summary>
/// <param name="msg">Incoming message with resonse data</param>
internal static NetSRP.Verification HandshakeFromPassive(NetIncomingMessage msg)
{
// Get response
NetSRP.Response response = new NetSRP.Response();
response.ExtractPacketData(msg);
// Create Verification data
return (msg.SenderConnection.Tag as Handshake).KeyFromResponse(response);
}
//This is run whenever a room or server RPC is received
private void ProcessRpc(byte b, NetIncomingMessage msg)
{
Debug.Log("Room rpc " + b + " received");
//TODO: deserialize data from the msg object
//this can be done via if/else, switches, or Dictionary<byte, Action<NetIncomingMessage>>.
//The dictionary is recommended for its cleanness
//the if/else is fastest if you only have a few Room/Server RPCs
}
/// <summary>
/// Finishes the handshake by processing the verification data received
/// </summary>
/// <param name="msg">Incomming message with verification data</param>
internal static Boolean FinishHandshakeFromPassive(NetIncomingMessage msg)
{
// Get Verification
NetSRP.Verification verification = new NetSRP.Verification();
verification.ExtractPacketData(msg);
// Try to verify data
return (msg.SenderConnection.Tag as Handshake).VerificationOfPassiveParty(verification);
}
/// <summary>
/// Processes a handshake that was not initated locally
/// </summary>
/// <param name="msg">Incomming msg with handshake</param>
internal static NetSRP.Response HandshakeFromActive(NetIncomingMessage msg)
{
// Read request
NetSRP.Request request = new NetSRP.Request();
request.ExtractPacketData(msg);
// Create response
return (msg.SenderConnection.Tag as Handshake).ResponseFromRequest(request);
}
public static Vector3 ReadVector3(NetIncomingMessage msg)
{
Vector3 data;
data.x = msg.ReadFloat();
data.y = msg.ReadFloat();
data.z = msg.ReadFloat();
return data;
}
/// <summary>
/// Decrypt an incoming message
/// </summary>
public bool Decrypt(NetIncomingMessage msg)
{
int numBytes = msg.LengthBytes;
for (int i = 0; i < numBytes; i++)
{
int offset = i % m_key.Length;
msg.m_data[i] = (byte)(msg.m_data[i] ^ m_key[offset]);
}
return true;
}
public override void OnDataReceived(NetIncomingMessage incMsg)
{
NetDataType type = (NetDataType)incMsg.ReadByte();
if (type == NetDataType.eDATA_REQUEST_LOGIN)
{
string accountName = incMsg.ReadString();
string password = incMsg.ReadString();
Login(accountName, password, incMsg.SenderConnection);
}
}
public NetworkClientInfo GetClientInfo(NetIncomingMessage msg)
{
var connection = msg.SenderConnection;
if (connection.Tag == null)
{
connection.Tag = new NetworkClientInfo(++host_id_counter, connection);
}
return ((NetworkClientInfo)connection.Tag);
}
public static Quaternion ReadQuaternion(NetIncomingMessage msg)
{
Quaternion data;
data.x = msg.ReadFloat();
data.y = msg.ReadFloat();
data.z = msg.ReadFloat();
data.w = msg.ReadFloat();
return data;
}
void onMovement(NetIncomingMessage msg)
{
Debug.Log("onMovement");
int id = msg.ReadInt32();
LidgrenGameObject lgo = null;
if (lgos.TryGetValue(id, out lgo))
{
lgo.GetComponent<PlayerAnimator>().OnPlayerMovement(msg.ReadByte());
}
}
void onRequestSpawn(NetIncomingMessage msg)
{
LidgrenPlayer player = (LidgrenPlayer)msg.SenderConnection.Tag;
if (player.GameObject == null)
{
player.GameObject = LidgrenGameObject.Spawn(-1, player.Id, msg.SenderConnection);
foreach (NetConnection c in server.Connections)
{
spawnOn(player.GameObject, c);
}
}
}
public override void OnConnectionApproval(NetIncomingMessage incMsg)
{
string encryptedToken = incMsg.ReadString();
F3_NetConnectionToken loginToken = GetConnectionToken();
if (loginToken.ValidateToken(encryptedToken))
{
incMsg.SenderConnection.Approve();
}
else
{
incMsg.SenderConnection.Deny();
}
}
public override void OnStatusChanged(NetIncomingMessage incMsg)
{
NetConnectionStatus status = (NetConnectionStatus)incMsg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
ConnectPlayer(incMsg.SenderConnection.RemoteUniqueIdentifier, null);
}
if (status == NetConnectionStatus.Disconnected)
{
DisconnectPlayer(incMsg.SenderConnection.RemoteUniqueIdentifier);
}
}
internal override void ReceiveMessage(NetIncomingMessage msg)
{
int nr = msg.m_sequenceNumber;
// ack no matter what
m_connection.QueueAck(msg.m_receivedMessageType, nr);
int relate = NetUtility.RelativeSequenceNumber(nr, m_lastReceivedSequenceNumber);
if (relate < 0)
return; // drop if late
m_lastReceivedSequenceNumber = nr;
m_peer.ReleaseMessage(msg);
}
public override NetIncomingMessage ReadMessage()
{
if (!connected)
{
return null;
}
if (messages.Count() > 0)
{
return messages.Dequeue();
}
if (connected2)
{
while (tosend.Count() > 0)
{
INetOutgoingMessage msg = tosend.Dequeue();
DoSendPacket(msg);
}
}
EnetEventRef event_ = new EnetEventRef();
if (platform.EnetHostService(host, 0, event_))
{
do
{
switch (event_.e.Type())
{
case EnetEventType.Connect:
connected2 = true;
break;
case EnetEventType.Receive:
byte[] data = event_.e.Packet().GetBytes();
int dataLength = event_.e.Packet().GetBytesCount();
event_.e.Packet().Dispose();
NetIncomingMessage msg = new NetIncomingMessage();
msg.message = data;
msg.messageLength = dataLength;
messages.Enqueue(msg);
break;
}
}
while (platform.EnetHostCheckEvents(host, event_));
}
if (messages.Count() > 0)
{
return messages.Dequeue();
}
return null;
}
void onMovement(NetIncomingMessage msg)
{
LidgrenPlayer player = (LidgrenPlayer)msg.SenderConnection.Tag;
// Forward message to all other players
NetOutgoingMessage forward = msg.SenderConnection.Peer.CreateMessage();
forward.Write(msg);
server.SendToAll(forward, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered, 1);
// Throw away Id on server, we dont need it
msg.ReadInt32();
// Read movement animation on server also
player.GameObject.GetComponent<PlayerAnimator>().OnPlayerMovement(msg.ReadByte());
}
public static void RecommendationSelected(NetIncomingMessage inMsg)
{
int selected = inMsg.ReadInt32();
int count = inMsg.ReadInt32();
for (int i = 0; i < count; i++)
recommender.AddBusy(inMsg.ReadUInt32());
Console.WriteLine("Recommendation selected (" + selected + ")");
string busyOutput = "Currently Busy:";
foreach (uint id in recommender.GetBusy())
busyOutput += " " + id;
Console.WriteLine(busyOutput);
recommender.CandidateSelected(selected);
}
public override NetIncomingMessage ReadMessage()
{
int received = p.WebSocketReceive(incomingData, incomingDataMax);
if (received == -1)
{
return null;
}
else
{
NetIncomingMessage msg = new NetIncomingMessage();
msg.message = incomingData;
msg.messageLength = received;
msg.SenderConnection = c;
return msg;
}
}
public override NetIncomingMessage ReadMessage()
{
NetIncomingMessage msg = null;
platform.MonitorEnter(network.ClientReceiveBufferLock);
{
if (network.ClientReceiveBuffer.Count() > 0)
{
msg = new NetIncomingMessage();
ByteArray b = network.ClientReceiveBuffer.Dequeue();
msg.message = b.data;
msg.messageLength = b.length;
}
}
platform.MonitorExit(network.ClientReceiveBufferLock);
return msg;
}
public void RequestObjects(NetIncomingMessage msg)
{
var client = GetClientInfo(msg);
foreach (var obj in NetworkActorRegistry.Objects)
{
if (obj != null)
{
NetworkRemoteCall.CallOnClient(
client, "Spawn",
obj.host_id, obj.actor_id, obj.prefab_name,
obj.transform.position, obj.transform.rotation
);
}
}
}
public static void RecommendationRequested(NetIncomingMessage inMsg)
{
Console.WriteLine("Recommendation requested...");
if (recommender.GetBusy().Count() == 0)
{
List<Candidate> candidates =
new List<Candidate>(recommender.GetCandidates());
NetOutgoingMessage outMsg = network.CreateMessage();
EncodeRecommendations(candidates, outMsg);
network.Send(outMsg);
Console.WriteLine("Sent recommendations.");
}
else
{
Console.WriteLine("Holding recommendations until all objects are free...");
}
}
void onPosition(NetIncomingMessage msg)
{
Debug.Log("onPosition");
int id = msg.ReadInt32();
LidgrenGameObject lgo = null;
if (lgos.TryGetValue(id, out lgo))
{
// Update position
Vector3 pos = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
lgo.transform.position = pos;
// Update rotation
Quaternion rot = new Quaternion(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
lgo.transform.GetChild(0).rotation = rot;
}
}
public void RecommendationReceived(NetIncomingMessage inMsg)
{
Debug.Log("RecommendationReceived");
int count = inMsg.ReadInt32();
string[] names = new string[count];
uint[][] participants = new uint[count][];
for (int i = 0; i < count; i++)
{
names[i] = inMsg.ReadString();
int numParticipants = inMsg.ReadInt32();
participants[i] = new uint[numParticipants];
for (int j = 0; j < numParticipants; j++)
participants[i][j] = inMsg.ReadUInt32();
}
this.Runner.ReceivedCandidates(names, participants);
}
/// <summary>
/// Shortcut constructor, immediately decodes an incoming message
/// </summary>
/// <param name="msg">Incoming message to immediately decode.</param>
public NetworkMessage(NetIncomingMessage msg)
{
this.Decode(msg);
}
private void ClientInitRequest(NetIncomingMessage inc)
{
if (ConnectedClients.Find(c => c.Connection == inc.SenderConnection) != null)
{
//this client was already authenticated
//another init request means they didn't get any update packets yet
return;
}
UnauthenticatedClient unauthClient = unauthenticatedClients.Find(uc => uc.Connection == inc.SenderConnection);
if (unauthClient == null)
{
//client did not ask for nonce first, can't authorize
inc.SenderConnection.Disconnect("Client did not properly request authentication.");
return;
}
if (!string.IsNullOrEmpty(password))
{
//decrypt message and compare password
string saltedPw = password;
saltedPw = saltedPw + Convert.ToString(unauthClient.Nonce);
saltedPw = Encoding.UTF8.GetString(NetUtility.ComputeSHAHash(Encoding.UTF8.GetBytes(saltedPw)));
string clPw = inc.ReadString();
if (clPw != saltedPw)
{
unauthClient.failedAttempts++;
if (unauthClient.failedAttempts > 3)
{
//disconnect and ban after too many failed attempts
banList.BanPlayer("Unnamed", unauthClient.Connection.RemoteEndPoint.Address.ToString(), "Too many failed login attempts.", null);
DisconnectUnauthClient(inc, unauthClient, "Too many failed login attempts. You have been automatically banned from the server.");
Log(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " has been banned from the server (too many wrong passwords)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " has been banned from the server (too many wrong passwords)", Color.Red);
return;
}
else
{
//not disconnecting the player here, because they'll still use the same connection and nonce if they try logging in again
NetOutgoingMessage reject = server.CreateMessage();
reject.Write((byte)ServerPacketHeader.AUTH_FAILURE);
reject.Write("Wrong password! You have " + Convert.ToString(4 - unauthClient.failedAttempts) + " more attempts before you're banned from the server.");
Log(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " failed to join the server (incorrect password)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " failed to join the server (incorrect password)", Color.Red);
server.SendMessage(reject, unauthClient.Connection, NetDeliveryMethod.Unreliable);
unauthClient.AuthTimer = 10.0f;
return;
}
}
}
string clVersion = inc.ReadString();
string clPackageName = inc.ReadString();
string clPackageHash = inc.ReadString();
string clName = Client.SanitizeName(inc.ReadString());
if (string.IsNullOrWhiteSpace(clName))
{
DisconnectUnauthClient(inc, unauthClient, "You need a name.");
Log(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " couldn't join the server (no name given)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(inc.SenderConnection.RemoteEndPoint.Address.ToString() + " couldn't join the server (no name given)", Color.Red);
return;
}
if (clVersion != GameMain.Version.ToString())
{
DisconnectUnauthClient(inc, unauthClient, "Version " + GameMain.Version + " required to connect to the server (Your version: " + clVersion + ")");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong game version)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong game version)", Color.Red);
return;
}
if (clPackageName != GameMain.SelectedPackage.Name)
{
DisconnectUnauthClient(inc, unauthClient, "Your content package (" + clPackageName + ") doesn't match the server's version (" + GameMain.SelectedPackage.Name + ")");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong content package name)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong content package name)", Color.Red);
return;
}
if (clPackageHash != GameMain.SelectedPackage.MD5hash.Hash)
{
DisconnectUnauthClient(inc, unauthClient, "Your content package (MD5: " + clPackageHash + ") doesn't match the server's version (MD5: " + GameMain.SelectedPackage.MD5hash.Hash + ")");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong content package hash)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (wrong content package hash)", Color.Red);
return;
}
if (!whitelist.IsWhiteListed(clName, inc.SenderConnection.RemoteEndPoint.Address.ToString()))
{
DisconnectUnauthClient(inc, unauthClient, "You're not in this server's whitelist.");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (not in whitelist)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (not in whitelist)", Color.Red);
return;
}
if (!Client.IsValidName(clName, this))
{
DisconnectUnauthClient(inc, unauthClient, "Your name contains illegal symbols.");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (invalid name)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (invalid name)", Color.Red);
return;
}
if (Homoglyphs.Compare(clName.ToLower(), Name.ToLower()))
{
DisconnectUnauthClient(inc, unauthClient, "That name is taken.");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (name taken by the server)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (name taken by the server)", Color.Red);
return;
}
Client nameTaken = ConnectedClients.Find(c => Homoglyphs.Compare(c.Name.ToLower(), clName.ToLower()));
if (nameTaken != null)
{
if (nameTaken.Connection.RemoteEndPoint.Address.ToString() == inc.SenderEndPoint.Address.ToString())
{
//both name and IP address match, replace this player's connection
nameTaken.Connection.Disconnect("Your session was taken by a new connection on the same IP address.");
nameTaken.Connection = unauthClient.Connection;
nameTaken.InitClientSync(); //reinitialize sync ids because this is a new connection
unauthenticatedClients.Remove(unauthClient);
unauthClient = null;
return;
}
else
{
//can't authorize this client
DisconnectUnauthClient(inc, unauthClient, "That name is taken.");
Log(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (name already taken)", ServerLog.MessageType.Error);
DebugConsole.NewMessage(clName + " (" + inc.SenderConnection.RemoteEndPoint.Address.ToString() + ") couldn't join the server (name already taken)", Color.Red);
return;
}
}
//new client
Client newClient = new Client(clName, GetNewClientID());
newClient.InitClientSync();
newClient.Connection = unauthClient.Connection;
unauthenticatedClients.Remove(unauthClient);
unauthClient = null;
ConnectedClients.Add(newClient);
#if CLIENT
GameMain.NetLobbyScreen.AddPlayer(newClient.Name);
#endif
GameMain.Server.SendChatMessage(clName + " has joined the server.", ChatMessageType.Server, null);
var savedPermissions = clientPermissions.Find(cp => cp.IP == newClient.Connection.RemoteEndPoint.Address.ToString());
if (savedPermissions != null)
{
newClient.SetPermissions(savedPermissions.Permissions, savedPermissions.PermittedCommands);
}
else
{
newClient.SetPermissions(ClientPermissions.None, new List <DebugConsole.Command>());
}
}
public static EntityUid ReadEntityUid(this NetIncomingMessage message)
{
return(new EntityUid(message.ReadInt32()));
}
///
/// <summary>
/// Reads any custom properties from a <see cref="NetIncomingMessage"/>.
/// </summary>
///
/// <param name="message">The <see cref="NetIncomingMessage"/> received from the server.</param>
///
public virtual void readCustomNetworkProperties(ref NetIncomingMessage message)
{
return;
}
internal override void InternalDeserialize(NetIncomingMessage lidgrenMsg)
{
base.InternalDeserialize(lidgrenMsg);
FolderName = lidgrenMsg.ReadString();
}
public override void HandleNetworkMessage(NetIncomingMessage message)
{
}
public override void ReadFromBuffer(NetIncomingMessage buffer)
{
Text = buffer.ReadString();
}
internal void OnWarning(NetIncomingMessage msg)
{
Debug.LogWarning(msg.ReadString());
}
public void HandlePacket(NetIncomingMessage inc)
{
handler.Handle(inc);
}
internal void OnError(NetIncomingMessage msg)
{
Debug.LogError(msg.ReadString());
}
public override void ReadFromBuffer(NetIncomingMessage buffer)
{
PlayerName = buffer.ReadString();
}
private static void Consume(NetIncomingMessage msg)
{
try
{
//faster than switch, as this is in most to least common order
if (msg.SequenceChannel == Channels.UNRELIABLE_STREAM)
{
if (msg.DeliveryMethod == NetDeliveryMethod.ReliableUnordered)
{
HandleStaticRpc(msg);
}
else
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
else
{
if (GetPlayer(msg.SenderConnection).CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted to send unreliable stream data for view {1}, but it does not exist",
msg.SenderConnection.Tag, actorId);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
}
}
else if (msg.SequenceChannel == Channels.RELIABLE_STREAM)
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
else
{
if (GetPlayer(msg.SenderConnection).CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted to send reliable stream data for view {1}, but it does not exist",
msg.SenderConnection.Tag, actorId);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
}
else if (msg.SequenceChannel >= Channels.BEGIN_RPCMODES && msg.SequenceChannel <= Channels.OWNER_RPC)
{
//rpc...
var viewId = msg.ReadUInt16();
var rpcId = msg.ReadByte();
Player player = GetPlayer(msg.SenderConnection);
NetworkView find;
var info = new NetMessageInfo((RPCMode)(msg.SequenceChannel - Channels.BEGIN_RPCMODES), player);
if (NetworkView.Find(viewId, out find))
{
find.CallRPC(rpcId, msg, info);
//Do we need to forward this still?
if (info.mode != RPCMode.Server && info.continueForwarding)
{
//need to forward...
if (info.mode == RPCMode.Others || info.mode == RPCMode.All)
{
}
else
{
find.Buffer(msg);
}
find.Send(msg, info.mode, msg.SenderConnection);
}
}
else
{
if (player.CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted RPC {1} on view {2}, but the view does not exist",
player, rpcId, viewId);
player.InternalErrorCount++;
}
}
}
else if (msg.SequenceChannel == Channels.SYNCHED_FIELD)
{
var viewId = msg.ReadUInt16();
var fieldId = msg.ReadByte();
NetworkView find;
if (NetworkView.Find(viewId, out find))
{
find.BufferField(msg, fieldId);
find.SendField(msg, msg.SenderConnection);
}
}
else if (msg.SequenceChannel == Channels.OBJECT_RPC)
{
Player player = GetPlayer(msg.SenderConnection);
if (player.CurrentRoom != null)
{
player.CurrentRoom.IncomingObjectRPC(msg);
}
}
else if (msg.SequenceChannel == Channels.STATIC_RPC)
{
HandleStaticRpc(msg);
}
else if (msg.SequenceChannel == Channels.STATIC_UTILS)
{
ProcessUtils(msg);
}
else
{
Debug.LogWarning("{2} bytes received over unhandled channel {0}, delivery {1}", msg.SequenceChannel, msg.DeliveryMethod, msg.LengthBytes);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
catch (Exception ex)
{
Debug.Log("[Consumption] {0} : {1}", ex.Message, ex.StackTrace);
}
}
protected abstract void Disconnected(NetIncomingMessage msg);
/// <summary>
/// Read a Point
/// </summary>
public static Point ReadPoint(this NetIncomingMessage message)
{
return(new Point(message.ReadInt32(), message.ReadInt32()));
}
public void Deserialize(NetIncomingMessage lidgrenMsg)
{
PlayerName = lidgrenMsg.ReadString();
VesselId = GuidUtil.Deserialize(lidgrenMsg);
Type = (LockType)lidgrenMsg.ReadInt32();
}
internal abstract void InternalDeserialize(NetIncomingMessage lidgrenMsg);
public override void Read(NetIncomingMessage inInputStream)
{
bool stateBit = inInputStream.ReadBoolean();
uint32_t readState = 0;
if (stateBit)
{
uint32_t playerId = inInputStream.ReadUInt32();
SetPlayerId(playerId);
readState |= (uint32_t)EActorReplicationState.ECRS_PlayerId;
}
Vector3 oldRotation = GetRotation();
Vector3 oldLocation = GetLocation();
Vector3 oldVelocity = GetVelocity();
Vector3 replicatedLocation = default(Vector3);
Vector3 replicatedVelocity = default(Vector3);
stateBit = inInputStream.ReadBoolean();
if (stateBit)
{
inInputStream.Read(ref replicatedVelocity);
//replicatedVelocity.y = GetVelocity().y;
SetVelocity(replicatedVelocity);
//Debug.Log("replicatedVelocity : " + replicatedVelocity + ", player_id :" + GetPlayerId());
inInputStream.Read(ref replicatedLocation);
//replicatedLocation.y = GetLocation().y;
SetLocation(replicatedLocation);
//Debug.Log("replicatedLocation : " + replicatedLocation + ", player_id :" + GetPlayerId());
IsRight = inInputStream.ReadBoolean();
IsLeft = inInputStream.ReadBoolean();
IsForward = inInputStream.ReadBoolean();
IsBack = inInputStream.ReadBoolean();
mDirection.x = 0.0f;
mDirection.z = 0.0f;
mDirection.x += IsRight ? Vector3.right.x : 0.0f;
mDirection.x += IsLeft ? Vector3.left.x : 0.0f;
mDirection.z += IsForward ? Vector3.forward.z : 0.0f;
mDirection.z += IsBack ? Vector3.back.z : 0.0f;
mDirection.Normalize();
//Debug.Log("mDirection : " + mDirection + ", player_id :" + GetPlayerId());
mThrustDir = 1.0f;
readState |= (uint32_t)EActorReplicationState.ECRS_Pose;
}
stateBit = inInputStream.ReadBoolean();
if (stateBit)
{
Vector3 color = default(Vector3);
inInputStream.Read(ref color);
SetColor(color);
readState |= (uint32_t)EActorReplicationState.ECRS_Color;
}
stateBit = inInputStream.ReadBoolean();
if (stateBit)
{
mHealth = 0;
mHealth = inInputStream.ReadInt32(4);
readState |= (uint32_t)EActorReplicationState.ECRS_Health;
}
if (GetPlayerId() == NetworkManagerClient.sInstance.GetPlayerId())
{
//did we get health? if so, tell the hud!
if ((readState & (uint32_t)EActorReplicationState.ECRS_Health) != 0)
{
//HUD::sInstance->SetPlayerHealth(mHealth);
}
DoClientSidePredictionAfterReplicationForLocalActor(readState);
//if this is a create packet, don't interpolate
if ((readState & (uint32_t)EActorReplicationState.ECRS_PlayerId) == 0)
{
InterpolateClientSidePrediction(oldRotation, oldLocation, oldVelocity, false);
}
}
else
{
DoClientSidePredictionAfterReplicationForRemoteActor(readState);
//will this smooth us out too? it'll interpolate us just 10% of the way there...
if ((readState & (uint32_t)EActorReplicationState.ECRS_PlayerId) == 0)
{
InterpolateClientSidePrediction(oldRotation, oldLocation, oldVelocity, true);
}
}
}
private void OnDataMessage(NetIncomingMessage buff)
{
PluginMgr.NotifyData(buff);
}
protected override void ProcessServerMessages()
{
while ((_msg = _network.ReadMessage()) != null)
{
switch (_msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
OnStatusChanged(_msg, (NetConnectionStatus)_msg.ReadByte());
break;
}
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
{
OnDebug(_msg);
break;
}
case NetIncomingMessageType.WarningMessage:
{
OnWarning(_msg);
break;
}
case NetIncomingMessageType.Error:
case NetIncomingMessageType.ErrorMessage:
{
OnError(_msg);
break;
}
case NetIncomingMessageType.Data:
{
var type = (MessageType)_msg.ReadByte();
if (type == MessageType.WorldState)
{
System.Array.Clear(_world_state, 0, Constants.MaxPlayers);
for (var i = 0; i < Constants.MaxPlayers; i++)
{
var exists = _msg.ReadBoolean();
if (exists)
{
_world_state[i] = EntityState.Read(_msg);
}
}
OnData(_world_state);
}
else if (type == MessageType.Connected)
{
var entity_id = _msg.ReadInt32();
Create(entity_id);
}
break;
}
default:
{
OnEvent(_msg);
break;
}
}
_network.Recycle(_msg);
}
}
private List <object> UnPackParams(NetIncomingMessage message)
{
var messageParams = new List <object>();
while (message.Position < message.LengthBits)
{
switch ((NetworkDataType)message.ReadByte())
{
case NetworkDataType.d_enum:
messageParams.Add(message.ReadInt32()); //Cast from int, because enums are ints.
break;
case NetworkDataType.d_bool:
messageParams.Add(message.ReadBoolean());
break;
case NetworkDataType.d_byte:
messageParams.Add(message.ReadByte());
break;
case NetworkDataType.d_sbyte:
messageParams.Add(message.ReadSByte());
break;
case NetworkDataType.d_ushort:
messageParams.Add(message.ReadUInt16());
break;
case NetworkDataType.d_short:
messageParams.Add(message.ReadInt16());
break;
case NetworkDataType.d_int:
messageParams.Add(message.ReadInt32());
break;
case NetworkDataType.d_uint:
messageParams.Add(message.ReadUInt32());
break;
case NetworkDataType.d_ulong:
messageParams.Add(message.ReadUInt64());
break;
case NetworkDataType.d_long:
messageParams.Add(message.ReadInt64());
break;
case NetworkDataType.d_float:
messageParams.Add(message.ReadFloat());
break;
case NetworkDataType.d_double:
messageParams.Add(message.ReadDouble());
break;
case NetworkDataType.d_string:
messageParams.Add(message.ReadString());
break;
case NetworkDataType.d_byteArray:
int length = message.ReadInt32();
messageParams.Add(message.ReadBytes(length));
break;
}
}
return(messageParams);
}
public static void OnClientSendIGameMessage(EIGameMessageType _EIGameMessageType, NetIncomingMessage _NetIncomingMessage)
{
var var_gameMessageType = _EIGameMessageType;
switch (var_gameMessageType)
{
case EIGameMessageType.RequestPlayerMessage:
handleRequestPlayerMessage(_NetIncomingMessage);
break;
case EIGameMessageType.RequestWorldMessage:
handleRequestWorldMessage(_NetIncomingMessage);
break;
case EIGameMessageType.RequestRegionMessage:
handleRequestRegionMessage(_NetIncomingMessage);
break;
case EIGameMessageType.RequestChunkMessage:
handleRequestChunkMessage(_NetIncomingMessage);
break;
case EIGameMessageType.PlayerCommandMessage:
handlePlayerCommandMessage(_NetIncomingMessage);
break;
case EIGameMessageType.RequestBlockMessage:
handleRequestBlockMessage(_NetIncomingMessage);
break;
case EIGameMessageType.RequestLivingObjectMessage:
handleRequestLivingObjectMessage(_NetIncomingMessage);
break;
case EIGameMessageType.CreatureInventoryItemPositionChangeMessage:
handleCreatureInventoryItemPositionChangeMessage(_NetIncomingMessage);
break;
case EIGameMessageType.CreatureEquipmentToInventoryMessage:
handleCreatureEquipmentToInventoryMessage(_NetIncomingMessage);
break;
case EIGameMessageType.CreatureInventoryToEquipmentMessage:
handleCreatureInventoryToEquipmentMessage(_NetIncomingMessage);
break;
case EIGameMessageType.UpdateObjectPositionMessage:
handleUpdateObjectPositionMessage(_NetIncomingMessage);
break;
}
}
public UpdatePlayerStateMessage(NetIncomingMessage im)
{
this.Decode(im);
}
public LobbyMessage(NetIncomingMessage im)
{
Rooms = new List <LobbySaveData>();
this.Decode(im);
}
internal void OnEvent(NetIncomingMessage msg)
{
Debug.Log("NetworkServer OnEvent, msg type == " + msg.MessageType);
}
public abstract void ReadInInitialData(NetIncomingMessage im);
public virtual void HandlePacket(NetIncomingMessage msg)
{
throw new NotImplementedException(); //must be overridden
}
/// <summary>
/// Decoding Constructor to be used by client.
/// </summary>
/// <param name="im"></param>
public vxNetmsgUpdatePlayerEntityState(NetIncomingMessage im)
{
PlayerInfo = new vxNetPlayerInfo(1, "any", vxEnumNetPlayerStatus.ReadyToPlay);
this.DecodeMsg(im);
}
private void OnDisconnected(NetIncomingMessage msg)
{
Debug.Log("Disconnection: " + msg.SenderConnection + " @ " + msg.SenderEndPoint);
}
/// <summary>
/// Handles creation of ui elements over network.
/// </summary>
public void HandleElementCreation(NetIncomingMessage msg) //I've opted for hardcoding these in for the moment.
{
// TODO: Either implement this or remove it
}
public void HandlePlacementRequest(NetIncomingMessage msg)
{
string alignRcv = msg.ReadString();
Boolean isTile = msg.ReadBoolean();
var mapMgr = (MapManager)IoCManager.Resolve <IMapManager>();
ushort tileType = 0;
string entityTemplateName = "";
if (isTile)
{
tileType = msg.ReadUInt16();
}
else
{
entityTemplateName = msg.ReadString();
}
float xRcv = msg.ReadFloat();
float yRcv = msg.ReadFloat();
var dirRcv = (Direction)msg.ReadByte();
IPlayerSession session = IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(msg.SenderConnection);
if (session.attachedEntity == null)
{
return; //Don't accept placement requests from nobodys
}
PlacementInformation permission = GetPermission(session.attachedEntity.Uid, alignRcv);
Boolean isAdmin =
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(msg.SenderConnection).adminPermissions.
isAdmin;
float a = (float)Math.Floor(xRcv);
float b = (float)Math.Floor(yRcv);
Vector2 tilePos = new Vector2(a, b);
if (permission != null || true)
//isAdmin) Temporarily disable actual permission check / admin check. REENABLE LATER
{
if (permission != null)
{
if (permission.Uses > 0)
{
permission.Uses--;
if (permission.Uses <= 0)
{
BuildPermissions.Remove(permission);
SendPlacementCancel(session.attachedEntity);
}
}
else
{
BuildPermissions.Remove(permission);
SendPlacementCancel(session.attachedEntity);
return;
}
}
if (!isTile)
{
Entity created = _server.EntityManager.SpawnEntityAt(entityTemplateName, new Vector2(xRcv, yRcv));
if (created != null)
{
created.GetComponent <ITransformComponent>(ComponentFamily.Transform).TranslateTo(
new Vector2(xRcv, yRcv));
if (created.HasComponent(ComponentFamily.Direction))
{
created.GetComponent <IDirectionComponent>(ComponentFamily.Direction).Direction = dirRcv;
}
if (created.HasComponent(ComponentFamily.WallMounted))
{
created.GetComponent <IWallMountedComponent>(ComponentFamily.WallMounted).AttachToTile(mapMgr.GetTileRef(tilePos));
}
}
}
else
{
mapMgr.Tiles[tilePos] = new Tile(tileType);
}
}
else //They are not allowed to request this. Send 'PlacementFailed'. TBA
{
LogManager.Log("Invalid placement request: "
+ IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(msg.SenderConnection).name +
" - " +
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(msg.SenderConnection).
attachedEntity.Uid.ToString() +
" - " + alignRcv.ToString());
SendPlacementCancel(
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(msg.SenderConnection).attachedEntity);
}
}
