public InstantiateData(NetDataReader reader)
{
uint len = reader.GetUInt();
NetStates = new List <byte[]>();
NetIDs = new uint[len];
for (int i = 0; i < len; i++)
{
NetStates.Add(reader.GetBytesWithLength());
NetIDs[i] = reader.GetUInt();
}
}
private void RecvData()
{
if (dataSocket == null)
{
return;
}
if (!dataSocket.Poll(0, SelectMode.SelectRead))
{
return;
}
EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
int recvLength;
try
{
recvLength = dataSocket.ReceiveFrom(recvBuffer, 0, recvBuffer.Length, SocketFlags.None, ref endPoint);
}
catch (SocketException ex)
{
HandleError(endPoint, ex.SocketErrorCode);
return;
}
recvReader.Clear();
recvReader.SetSource(recvBuffer, 0, recvLength);
uint connectionId = recvReader.GetUInt();
// Have to find which kcp send this data, then set its input
KCPHandle kcpHandle = null;
if (kcpHandles.TryGetValue(connectionId, out kcpHandle))
{
kcpHandle.remoteEndPoint = endPoint;
kcpHandle.kcp.Input(new Span <byte>(recvBuffer, 0, recvLength));
byte[] kcpData;
while ((recvLength = kcpHandle.kcp.PeekSize()) > 0)
{
kcpData = new byte[recvLength];
if (kcpHandle.kcp.Recv(kcpData) >= 0)
{
TransportEventData eventData = default(TransportEventData);
eventData.connectionId = connectionId;
eventData.endPoint = (IPEndPoint)endPoint;
HandleRecvData(kcpData, recvLength, eventData);
}
}
}
}
public void Deserialize(NetDataReader reader)
{
code = reader.GetUInt();
reader.TryGetString(out playerID);
appData = new AppData();
appData.Deserialize(reader);
}
public override void Deserialize(NetDataReader reader)
{
assetId = reader.GetString();
objectId = reader.GetUInt();
connectId = reader.GetLong();
position = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
}
public void Deserialize(NetDataReader reader)
{
pid = reader.GetUInt();
username = reader.GetString();
level = reader.GetString();
position = reader.GetVector2();
animationState = reader.GetInt();
}
public PlayerAuth(NetDataReader reader)
{
if (reader.GetUInt() != PROTOCOL_KEY)
{
throw new PlayerAuthException("Invalid protocol version, try updating your game");
}
Name = reader.GetString();
}
public override void ReadPayload(NetDataReader message)
{
base.ReadPayload(message);
Key = message.GetUInt();
Shift = message.GetBool();
Control = message.GetBool();
Alt = message.GetBool();
Mode = (KeyMode)message.GetInt();
}
public void Deserialize(NetDataReader reader)
{
SeqCount = reader.GetByte();
if (SeqCount > 0)
{
StartSeq = reader.GetByte();
Data = reader.GetUInt();
EndSeq = (byte)(StartSeq + SeqCount - 1);
}
}
public void Deserialize(NetDataReader reader)
{
Bounds = new Quad(reader.GetDouble(), reader.GetDouble(), reader.GetDouble());
Path = new PathString();
Path.Deserialize(reader);
byte[] ipBytes = reader.GetBytesWithLength();
BusAddress = new IPAddress(ipBytes);
BusPort = reader.GetUInt();
ApiUrl = reader.GetString();
}
public void ReadAll(NetPeer peer, NetDataReader reader) {
while (reader.AvailableBytes >= 4) {
var hash = reader.GetUInt();
Callback callback;
if (callbacks.TryGetValue(hash, out callback)) {
callback(peer, reader);
}
}
}
public void WriteReadUInt()
{
var ndw = new NetDataWriter();
ndw.Put(34U);
var ndr = new NetDataReader(ndw.Data);
var readUInt = ndr.GetUInt();
Assert.AreEqual(readUInt, 34U);
}
private Order ReadOrder(NetDataReader reader)
{
int playerIndex = reader.GetInt();
OrderType orderType = (OrderType)reader.GetInt();
var order = new Order(playerIndex, orderType);
byte argumentCount = reader.GetByte();
for (int i = 0; i < argumentCount; i++)
{
OrderArgumentType argumentType = (OrderArgumentType)reader.GetInt();
switch (argumentType)
{
case OrderArgumentType.Integer:
order.AddIntegerArgument(reader.GetInt());
break;
case OrderArgumentType.Float:
order.AddFloatArgument(reader.GetFloat());
break;
case OrderArgumentType.Boolean:
order.AddBooleanArgument(reader.GetBool());
break;
case OrderArgumentType.ObjectId:
order.AddObjectIdArgument(reader.GetUInt());
break;
case OrderArgumentType.Position:
order.AddPositionArgument(new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat()));
break;
case OrderArgumentType.ScreenPosition:
order.AddScreenPositionArgument(new Point2D(reader.GetInt(), reader.GetInt()));
break;
case OrderArgumentType.ScreenRectangle:
order.AddScreenRectangleArgument(new Rectangle(reader.GetInt(), reader.GetInt(),
reader.GetInt(), reader.GetInt()));
break;
default:
throw new NotImplementedException("We don't know the other argument types");
}
}
return(order);
}
public bool Read(NetPeer peer, NetDataReader reader) {
if (reader.AvailableBytes < 4) {
return false;
}
var hash = reader.GetUInt();
Callback callback;
if (callbacks.TryGetValue(hash, out callback)) {
callback(peer, reader);
}
return true;
}
protected override void OnDeserialize(NetDataReader reader)
{
var amount = reader.GetInt();
for (var i = 0; i < amount; i++)
{
var tick = reader.GetUInt();
var vector = reader.GetVector2();
_serverCachedPackets.PushBack(new PositionHistory {
Tick = tick, Position = vector
});
}
}
public void Deserialize(NetDataReader reader)
{
StartWorldTick = reader.GetUInt();
var length = reader.GetInt();
Inputs = new PlayerInputs[length];
ClientWorldTickDeltas = new short[length];
for (int i = 0; i < length; i++)
{
Inputs[i].ApplyKeyBitfield(reader.GetByte());
Inputs[i].ViewDirection = reader.GetQuaternion();
ClientWorldTickDeltas[i] = reader.GetShort();
}
}
protected override void OnDeserialize(NetDataReader reader)
{
if (IsHost)
{
return;
}
NetworkTick = reader.GetUInt();
var pos = reader.GetVector3();
var hist = new MovementHistory {
PeerId = PeerId, Tick = NetworkTick, Position = pos
};
_movementBuffer.PushFront(hist);
}
public virtual void Deserialize(NetDataReader reader)
{
ackId = reader.GetUInt();
responseCode = (AckResponseCode)reader.GetByte();
}
public override void Deserialize(NetDataReader reader)
{
objectId = reader.GetUInt();
}
public void Deserialize(NetDataReader reader)
{
damage = reader.GetInt();
selfDamage = reader.GetBool();
attackerId = reader.GetUInt();
}
public uint GetUInt()
{
return(_networkReaderImplementation.GetUInt());
}
public override void Deserialize(NetDataReader reader)
{
Value = reader.GetUInt();
}
public void Deserialize(NetDataReader reader)
{
id = reader.GetUInt();
}
public override void Deserialize(NetDataReader reader)
{
objectId = reader.GetUInt();
position = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
}
private static object GetObject(this NetDataReader reader, Type type)
{
if (type == null)
{
return(null);
}
if (type.GetInterface("INetSerializable") != null)
{
var result = (INetSerializable)Activator.CreateInstance(type);
result.Deserialize(reader);
return(result);
}
else if (type.GetInterface("ISyncObject") != null)
{
return(reader.GetByte());
}
else if (type.IsEnum)
{
return(Enum.Parse(type, type.GetEnumName(reader.GetObject(type.GetEnumUnderlyingType()))));
}
else if (type == typeof(bool))
{
return(reader.GetBool());
}
else if (type == typeof(byte))
{
return(reader.GetByte());
}
else if (type == typeof(sbyte))
{
return(reader.GetSByte());
}
else if (type == typeof(char))
{
return(reader.GetChar());
}
else if (type == typeof(short))
{
return(reader.GetShort());
}
else if (type == typeof(ushort))
{
return(reader.GetUShort());
}
else if (type == typeof(int))
{
return(reader.GetInt());
}
else if (type == typeof(uint))
{
return(reader.GetUInt());
}
else if (type == typeof(long))
{
return(reader.GetLong());
}
else if (type == typeof(ulong))
{
return(reader.GetULong());
}
else if (type == typeof(float))
{
return(reader.GetFloat());
}
else if (type == typeof(double))
{
return(reader.GetBool());
}
else if (type == typeof(string))
{
return(reader.GetDouble());
}
else if (type == typeof(IPEndPoint))
{
return(reader.GetNetEndPoint());
}
else
{
throw new Exception("Unable to deserialize object of type " + type);
}
}
/// <inheritdoc />
public virtual void TinyDeserialize(NetDataReader reader, bool firstStateUpdate)
{
if (firstStateUpdate)
{
NetworkID = reader.GetInt();
}
if (!firstStateUpdate)
{
int dFlag = reader.GetInt();
TinyNetStateSyncer.IntToDirtyFlag(dFlag, _dirtyFlag);
}
Type type;
int maxSyncVar = propertiesName.Length;
for (int i = 0; i < maxSyncVar; i++)
{
if (!firstStateUpdate && _dirtyFlag[i] == false)
{
continue;
}
type = propertiesTypes[i];
if (type == typeof(byte))
{
byteAccessor[propertiesName[i]].Set(this, reader.GetByte());
}
else if (type == typeof(sbyte))
{
sbyteAccessor[propertiesName[i]].Set(this, reader.GetSByte());
}
else if (type == typeof(short))
{
shortAccessor[propertiesName[i]].Set(this, reader.GetShort());
}
else if (type == typeof(ushort))
{
ushortAccessor[propertiesName[i]].Set(this, reader.GetUShort());
}
else if (type == typeof(int))
{
intAccessor[propertiesName[i]].Set(this, reader.GetInt());
}
else if (type == typeof(uint))
{
uintAccessor[propertiesName[i]].Set(this, reader.GetUInt());
}
else if (type == typeof(long))
{
longAccessor[propertiesName[i]].Set(this, reader.GetLong());
}
else if (type == typeof(ulong))
{
ulongAccessor[propertiesName[i]].Set(this, reader.GetULong());
}
else if (type == typeof(float))
{
floatAccessor[propertiesName[i]].Set(this, reader.GetFloat());
}
else if (type == typeof(double))
{
doubleAccessor[propertiesName[i]].Set(this, reader.GetDouble());
}
else if (type == typeof(bool))
{
boolAccessor[propertiesName[i]].Set(this, reader.GetBool());
}
else if (type == typeof(string))
{
stringAccessor[propertiesName[i]].Set(this, reader.GetString());
}
}
}
public static LiteNetLibElementInfo DeserializeInfo(NetDataReader reader)
{
return(new LiteNetLibElementInfo(reader.GetUInt(), reader.GetInt(), reader.GetUShort()));
}
public void Deserialize(NetDataReader reader)
{
kind = (Kind)reader.GetInt();
ownerId = reader.GetUInt();
}
public void Deserialize(NetDataReader reader)
{
pid = reader.GetUInt();
position = reader.GetVector2();
}
