void RecvUnconnectedPacket(UdpBitStream buff, UdpEndPoint ep) { buff.Ptr = UdpHeader.GetSize(this); if (buff.ReadByte(8) == (byte)UdpCommandType.Connect) { if (Config.AllowIncommingConnections && ((connLookup.Count + pendingConnections.Count) < Config.ConnectionLimit || Config.ConnectionLimit == -1)) { if (Config.AutoAcceptIncommingConnections) { AcceptConnection(ep); } else { if (pendingConnections.Add(ep)) { Raise(UdpEvent.PUBLIC_CONNECT_REQUEST, ep); } } } else { SendRefusedCommand(ep); } } else { UdpLog.Debug("received invalid header byte in unconnected packet from {0}", ep.ToString()); } }
public static void WriteColorRGBAHalf(ref UdpBitStream stream, Color value) { stream.WriteHalf(value.r); stream.WriteHalf(value.g); stream.WriteHalf(value.b); stream.WriteHalf(value.a); }
public static void WriteRigidbodyHalf(ref UdpBitStream stream, Rigidbody rigidbody) { UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.position); UdpBitStreamExt.WriteQuaternionHalf(ref stream, rigidbody.rotation); UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.velocity); UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.angularVelocity); }
public static void WriteVector4Half(ref UdpBitStream stream, Vector4 value) { stream.WriteHalf(value.x); stream.WriteHalf(value.y); stream.WriteHalf(value.z); stream.WriteHalf(value.w); }
public static void ReadRigidbodyHalf(ref UdpBitStream stream, Rigidbody rigidbody) { rigidbody.position = UdpBitStreamExt.ReadVector3Half(ref stream); rigidbody.rotation = UdpBitStreamExt.ReadQuaternionHalf(ref stream); rigidbody.velocity = UdpBitStreamExt.ReadVector3Half(ref stream); rigidbody.angularVelocity = UdpBitStreamExt.ReadVector3Half(ref stream); }
public static Plane ReadPlaneHalf(ref UdpBitStream stream) { return(new Plane( UdpBitStreamExt.ReadVector3Half(ref stream), stream.ReadHalf() )); }
public static Plane ReadPlane(ref UdpBitStream stream) { return(new Plane( UdpBitStreamExt.ReadVector3(ref stream), stream.ReadFloat() )); }
public static void WriteColor32RGBA(ref UdpBitStream stream, Color32 value) { stream.WriteByte(value.r, 8); stream.WriteByte(value.g, 8); stream.WriteByte(value.b, 8); stream.WriteByte(value.a, 8); }
public static void WriteQuaternionHalf(ref UdpBitStream stream, Quaternion value) { stream.WriteHalf(value.x); stream.WriteHalf(value.y); stream.WriteHalf(value.z); stream.WriteHalf(value.w); }
public static Ray ReadRayHalf(ref UdpBitStream stream) { return(new Ray( UdpBitStreamExt.ReadVector3Half(ref stream), UdpBitStreamExt.ReadVector3Half(ref stream) )); }
void OnCommandReceived(UdpBitStream buffer) { if (ParseHeader(ref buffer)) { stats.CommandsReceived += 1; buffer.Ptr = UdpHeader.GetSize(socket); UdpCommandType cmd = (UdpCommandType)buffer.ReadByte(8); switch (cmd) { case UdpCommandType.Connect: OnCommandConnect(buffer); break; case UdpCommandType.Accepted: OnCommandAccepted(buffer); break; case UdpCommandType.Refused: OnCommandRefused(buffer); break; case UdpCommandType.Disconnected: OnCommandDisconnected(buffer); break; case UdpCommandType.Ping: OnCommandPing(buffer); break; default: ConnectionError(UdpConnectionError.IncorrectCommand); break; } } }
public static void WriteRectHalf(ref UdpBitStream stream, Rect rect) { stream.WriteHalf(rect.xMin); stream.WriteHalf(rect.yMin); stream.WriteHalf(rect.width); stream.WriteHalf(rect.height); }
public static void ReadRigidbodyHalf(ref UdpBitStream stream, out Vector3 position, out Quaternion rotation, out Vector3 velocity, out Vector3 angularVelocity) { position = UdpBitStreamExt.ReadVector3Half(ref stream); rotation = UdpBitStreamExt.ReadQuaternionHalf(ref stream); velocity = UdpBitStreamExt.ReadVector3Half(ref stream); angularVelocity = UdpBitStreamExt.ReadVector3Half(ref stream); }
void OnCommandDisconnected(UdpBitStream buffer) { EnsureClientIsConnected(); if (CheckState(UdpConnectionState.Connected)) { ChangeState(UdpConnectionState.Disconnected); } }
public static Rect ReadRectHalf(ref UdpBitStream stream) { return(new Rect( stream.ReadHalf(), stream.ReadHalf(), stream.ReadHalf(), stream.ReadHalf() )); }
public static Rect ReadRect(ref UdpBitStream stream) { return(new Rect( stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat() )); }
public override bool Unpack(ref UdpBitStream stream, ref object o) { // read length and create array, then read bytes into array byte[] bytes = new byte[stream.ReadInt()]; stream.ReadByteArray(bytes); // convert bytes to string o = Encoding.UTF8.GetString(bytes); return true; }
public override bool Pack(ref UdpBitStream stream, ref object o) { // cast to string and get bytes string msg = (string) o; byte[] bytes = Encoding.UTF8.GetBytes(msg); // write length and bytes into buffer stream.WriteInt(bytes.Length); stream.WriteByteArray(bytes); return true; }
internal void OnPacket(UdpBitStream buffer) { recvTime = socket.GetCurrentTime(); if ((buffer.Data[0] & 1) == 1) { OnObjectReceived(buffer); } else { OnCommandReceived(buffer); } }
internal void SendObject(object o) { serializer.SendNext(o); while (serializer.HasQueuedObjects) { UdpSendFailReason reason = CheckCanSend(false); if (reason != UdpSendFailReason.None) { while (serializer.HasQueuedObjects) { socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, serializer.NextObject(), reason); } break; } UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket)); object obj = serializer.NextObject(); if (serializer.Pack(ref stream, ref obj)) { if (stream.Overflowing && (socket.Config.AllowPacketOverflow == false)) { UdpLog.Error("stream to {0} is overflowing, not sending", endpoint.ToString()); socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.StreamOverflow); return; } UdpHeader header = MakeHeader(true); header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket); UdpHandle handle = MakeHandle(ref header); handle.Object = obj; if (SendStream(stream, handle, alwaysSendMtu) == false) { socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SocketError); } else { stats.PacketSent(); } } else { socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SerializerReturnedFalse); } } }
void OnCommandAccepted(UdpBitStream buffer) { if (IsClient) { if (CheckState(UdpConnectionState.Connecting)) { ChangeState(UdpConnectionState.Connected); } } else { ConnectionError(UdpConnectionError.IncorrectCommand); } }
void OnCommandConnect(UdpBitStream buffer) { if (IsServer) { if (CheckState(UdpConnectionState.Connected)) { SendCommand(UdpCommandType.Accepted); } } else { ConnectionError(UdpConnectionError.IncorrectCommand); } }
bool SendStream(UdpBitStream stream, UdpHandle handle, bool expandToMtu) { int bytesToSend = UdpMath.BytesRequired(stream.Ptr); if (bytesToSend < mtu && expandToMtu) { bytesToSend = mtu; } sendTime = handle.SendTime; sendSequence = handle.ObjSequence; sendWindow.Enqueue(handle); recvSinceLastSend = 0; return(socket.Send(endpoint, stream.Data, bytesToSend)); }
bool ParseHeader(ref UdpBitStream buffer) { UdpHeader header = new UdpHeader(); header.Unpack(new UdpBitStream(buffer.Data, buffer.Length, 0), socket); // Assign bit size if (socket.Config.WritePacketBitSize) { buffer.Length = header.BitSize; } int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD); // we have to be within window size if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow) { ConnectionError(UdpConnectionError.SequenceOutOfBounds); return(false); } // this is an old packet if (seqDistance <= 0) { return(false); } // update receive history if (seqDistance >= socket.Config.AckRedundancy) { recvHistory = 1UL; } else { recvHistory = (recvHistory << seqDistance) | 1UL; } // update our receive stats recvSequence = header.ObjSequence; recvSinceLastSend += 1; // ack sent objects AckHandles(header, true); return(true); }
void OnCommandRefused(UdpBitStream buffer) { if (IsClient) { if (CheckState(UdpConnectionState.Connecting)) { socket.Raise(UdpEvent.PUBLIC_CONNECT_REFUSED, endpoint); // destroy this connection on next timeout check ChangeState(UdpConnectionState.Destroy); } } else { ConnectionError(UdpConnectionError.IncorrectCommand); } }
public static void WriteMatrix4x4Half(ref UdpBitStream stream, ref Matrix4x4 m) { stream.WriteHalf(m.m00); stream.WriteHalf(m.m01); stream.WriteHalf(m.m02); stream.WriteHalf(m.m03); stream.WriteHalf(m.m10); stream.WriteHalf(m.m11); stream.WriteHalf(m.m12); stream.WriteHalf(m.m13); stream.WriteHalf(m.m20); stream.WriteHalf(m.m21); stream.WriteHalf(m.m22); stream.WriteHalf(m.m23); stream.WriteHalf(m.m30); stream.WriteHalf(m.m31); stream.WriteHalf(m.m32); stream.WriteHalf(m.m33); }
void SendRefusedCommand(UdpEndPoint endpoint) { UdpBitStream stream = new UdpBitStream(GetWriteBuffer(), Config.DefaultMtu, UdpHeader.GetSize(this)); stream.WriteByte((byte)UdpCommandType.Refused, 8); UdpHeader header = new UdpHeader(); header.IsObject = false; header.AckHistory = 0; header.AckSequence = 1; header.ObjSequence = 1; header.Now = 0; header.Pack(new UdpBitStream(stream.Data, Config.DefaultMtu, 0), this); if (Send(endpoint, stream.Data, UdpMath.BytesRequired(stream.Ptr)) == false) { // do something here? } }
internal void SendCommand(UdpCommandType cmd) { if (CheckCanSend(true) == UdpSendFailReason.None) { UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket)); stream.WriteByte((byte)cmd, 8); UdpHeader header = MakeHeader(false); header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket); UdpHandle handle = MakeHandle(ref header); handle.Object = null; if (SendStream(stream, handle, false) == false) { // do something here? } stats.CommandSent += 1; } }
public static Matrix4x4 ReadMatrix4x4(ref UdpBitStream stream) { Matrix4x4 m = default(Matrix4x4); m.m00 = stream.ReadFloat(); m.m01 = stream.ReadFloat(); m.m02 = stream.ReadFloat(); m.m03 = stream.ReadFloat(); m.m10 = stream.ReadFloat(); m.m11 = stream.ReadFloat(); m.m12 = stream.ReadFloat(); m.m13 = stream.ReadFloat(); m.m20 = stream.ReadFloat(); m.m21 = stream.ReadFloat(); m.m22 = stream.ReadFloat(); m.m23 = stream.ReadFloat(); m.m30 = stream.ReadFloat(); m.m31 = stream.ReadFloat(); m.m32 = stream.ReadFloat(); m.m33 = stream.ReadFloat(); return m; }
public static Matrix4x4 ReadMatrix4x4Half(ref UdpBitStream stream) { Matrix4x4 m = default(Matrix4x4); m.m00 = stream.ReadHalf(); m.m01 = stream.ReadHalf(); m.m02 = stream.ReadHalf(); m.m03 = stream.ReadHalf(); m.m10 = stream.ReadHalf(); m.m11 = stream.ReadHalf(); m.m12 = stream.ReadHalf(); m.m13 = stream.ReadHalf(); m.m20 = stream.ReadHalf(); m.m21 = stream.ReadHalf(); m.m22 = stream.ReadHalf(); m.m23 = stream.ReadHalf(); m.m30 = stream.ReadHalf(); m.m31 = stream.ReadHalf(); m.m32 = stream.ReadHalf(); m.m33 = stream.ReadHalf(); return(m); }
void OnObjectReceived(UdpBitStream buffer) { EnsureClientIsConnected(); if (CheckState(UdpConnectionState.Connected) == false) { return; } if (ParseHeader(ref buffer)) { object obj = null; buffer.Ptr = UdpHeader.GetSize(socket); if (serializer.Unpack(ref buffer, ref obj)) { socket.Raise(UdpEvent.PUBLIC_OBJECT_RECEIVED, this, obj); } stats.PacketReceived(); } }
public static void ReadAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements) where T : TransformElement { Frame frame = buffer.frames[packetId]; bool isCurrentFrame = (packetId == buffer.CurrentIndex); bool isPos = ((typeof(T) == typeof(PositionElement))); for (int i = 0; i < elements.Count; i++) { TransformElement e = elements[i]; bool forcedUpdate = e.IsUpdateForced(msgType, packetId); bool isKeyframe = e.IsKeyframe(packetId); // Read element from the buffer if it is expected if (forcedUpdate || e.sendCulling.ChangesType()) { bool hasChanged = e.ReadFromBitstream(ref bitstream, msgType, frame, i, forcedUpdate, isKeyframe); // reapply snapshot if this frame is mid lerping (current), this is more accurate than the reconstructed rot being used. if (isCurrentFrame && hasChanged) { DebugX.Log("Mid lerp child update"); if (isPos) e.Snapshot(frame.positions, i, true); else e.Snapshot(frame.rotations, i, true); } // Set the mask if this element sent an update if (isPos) i.SetBitInMask(ref frame.positionsMask, hasChanged); else i.SetBitInMask(ref frame.rotationsMask, hasChanged); } } }
public static void WriteAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements) where T : TransformElement { Frame frame = buffer.frames[packetId]; for (int i = 0; i < elements.Count; i++) { TransformElement e = elements[i]; bool forcedUpdate = e.IsUpdateForced(msgType, packetId); bool isKeyframe = e.IsKeyframe(packetId); // Write this element to the stream if it is expected if (forcedUpdate || e.sendCulling.ChangesType()) e.WriteToBitstream(ref bitstream, msgType, forcedUpdate, isKeyframe); // Store the current transform in the frame buffer if this has local authority TODO: (may not actually be used anywhere) if ((typeof(T) == typeof(PositionElement))) frame.positions[i] = (e as PositionElement).Localized; else frame.rotations[i] = (e as RotationElement).Localized; } }
public static Color32 ReadColor32RGBA(ref UdpBitStream stream) { return new Color32(stream.ReadByte(8), stream.ReadByte(8), stream.ReadByte(8), stream.ReadByte(8)); }
public static void WriteLayerMask(ref UdpBitStream stream, LayerMask mask) { stream.WriteInt(mask.value, 32); }
public static void WritePlaneHalf(ref UdpBitStream stream, Plane plane) { UdpBitStreamExt.WriteVector3Half(ref stream, plane.normal); stream.WriteHalf(plane.distance); }
public static void WriteRayHalf(ref UdpBitStream stream, Ray ray) { UdpBitStreamExt.WriteVector3Half(ref stream, ray.origin); UdpBitStreamExt.WriteVector3Half(ref stream, ray.direction); }
public static void WriteTransformHalf(ref UdpBitStream stream, Transform transform) { UdpBitStreamExt.WriteVector3Half(ref stream, transform.position); UdpBitStreamExt.WriteQuaternionHalf(ref stream, transform.rotation); }
void OnCommandReceived(UdpBitStream buffer) { if (ParseHeader(ref buffer)) { stats.CommandsReceived += 1; buffer.Ptr = UdpHeader.GetSize(socket); UdpCommandType cmd = (UdpCommandType) buffer.ReadByte(8); switch (cmd) { case UdpCommandType.Connect: OnCommandConnect(buffer); break; case UdpCommandType.Accepted: OnCommandAccepted(buffer); break; case UdpCommandType.Refused: OnCommandRefused(buffer); break; case UdpCommandType.Disconnected: OnCommandDisconnected(buffer); break; case UdpCommandType.Ping: OnCommandPing(buffer); break; default: ConnectionError(UdpConnectionError.IncorrectCommand); break; } } }
void OnCommandPing(UdpBitStream buffer) { EnsureClientIsConnected(); }
internal void SendCommand(UdpCommandType cmd) { if (CheckCanSend(true) == UdpSendFailReason.None) { UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket)); stream.WriteByte((byte) cmd, 8); UdpHeader header = MakeHeader(false); header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket); UdpHandle handle = MakeHandle(ref header); handle.Object = null; if (SendStream(stream, handle, false) == false) { // do something here? } stats.CommandSent += 1; } }
public static void WriteVector3(ref UdpBitStream stream, Vector3 value) { stream.WriteFloat(value.x); stream.WriteFloat(value.y); stream.WriteFloat(value.z); }
void OnObjectReceived(UdpBitStream buffer) { EnsureClientIsConnected(); if (CheckState(UdpConnectionState.Connected) == false) return; if (ParseHeader(ref buffer)) { object obj = null; buffer.Ptr = UdpHeader.GetSize(socket); if (serializer.Unpack(ref buffer, ref obj)) { socket.Raise(UdpEvent.PUBLIC_OBJECT_RECEIVED, this, obj); } stats.PacketReceived(); } }
public static Bounds ReadBoundsHalf(ref UdpBitStream stream) { return new Bounds(UdpBitStreamExt.ReadVector3Half(ref stream), UdpBitStreamExt.ReadVector3Half(ref stream)); }
bool ParseHeader(ref UdpBitStream buffer) { UdpHeader header = new UdpHeader(); header.Unpack(new UdpBitStream(buffer.Data, buffer.Length, 0), socket); // Assign bit size if (socket.Config.WritePacketBitSize) { buffer.Length = header.BitSize; } int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD); // we have to be within window size if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow) { ConnectionError(UdpConnectionError.SequenceOutOfBounds); return false; } // this is an old packet if (seqDistance <= 0) return false; // update receive history if (seqDistance >= socket.Config.AckRedundancy) { recvHistory = 1UL; } else { recvHistory = (recvHistory << seqDistance) | 1UL; } // update our receive stats recvSequence = header.ObjSequence; recvSinceLastSend += 1; // ack sent objects AckHandles(header, true); return true; }
bool SendStream(UdpBitStream stream, UdpHandle handle, bool expandToMtu) { int bytesToSend = UdpMath.BytesRequired(stream.Ptr); if (bytesToSend < mtu && expandToMtu) { bytesToSend = mtu; } sendTime = handle.SendTime; sendSequence = handle.ObjSequence; sendWindow.Enqueue(handle); recvSinceLastSend = 0; return socket.Send(endpoint, stream.Data, bytesToSend); }
public static Color ReadColorRGBA(ref UdpBitStream stream) { return new Color(stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat()); }
public static Color ReadColorRGBHalf(ref UdpBitStream stream) { return new Color(stream.ReadHalf(), stream.ReadHalf(), stream.ReadHalf()); }
public static LayerMask ReadLayerMask(ref UdpBitStream stream) { return stream.ReadInt(32); }