CMakeLists.txt

@@ -121,20 +121,27 @@ set(EHS_SOURCES
     include/ehs/io/FileMonitor.h
     include/ehs/io/Window.h
 
+    include/ehs/io/socket/Socket.h
     src/io/socket/Request.cpp include/ehs/io/socket/Request.h
     src/io/socket/Response.cpp include/ehs/io/socket/Response.h
     src/io/socket/BaseDNS.cpp include/ehs/io/socket/BaseDNS.h
+    include/ehs/io/socket/DNS.h
     src/io/socket/BaseUDP.cpp include/ehs/io/socket/BaseUDP.h
+    include/ehs/io/socket/UDP.h
     src/io/socket/BaseTCP.cpp include/ehs/io/socket/BaseTCP.h
+    include/ehs/io/socket/TCP.h
     src/io/socket/SSL.cpp include/ehs/io/socket/SSL.h
 
+        include/ehs/io/socket/ehc/NetUtils.h
+        src/io/socket/EHC.cpp include/ehs/io/socket/EHC.h
+        src/io/socket/ehc/NetFrags.cpp include/ehs/io/socket/ehc/NetFrags.h
+        src/io/socket/ehc/NetEnd.cpp include/ehs/io/socket/ehc/NetEnd.h
+        src/io/socket/ehc/NetSys.cpp include/ehs/io/socket/ehc/NetSys.h
+        src/io/socket/ehc/NetOp.cpp include/ehs/io/socket/ehc/NetOp.h
+
     src/io/socket/rest/Twitch.cpp include/ehs/io/socket/rest/Twitch.h
     src/io/socket/rest/TwitchChat.cpp include/ehs/io/socket/rest/TwitchChat.h
     src/io/socket/rest/Spotify.cpp include/ehs/io/socket/rest/Spotify.h
-    include/ehs/io/socket/Socket.h
-    include/ehs/io/socket/TCP.h
-    include/ehs/io/socket/UDP.h
-    include/ehs/io/socket/DNS.h
 
     src/io/audio/Audio.cpp include/ehs/io/audio/Audio.h
     src/io/audio/BaseAudioDevice.cpp include/ehs/io/audio/BaseAudioDevice.h
@@ -178,6 +185,8 @@ set(EHS_SOURCES
     include/ehs/io/BaseDirectory.h
     src/io/BaseDirectory.cpp
     include/ehs/io/Directory.h
+        include/ehs/io/socket/ehc/NetEnc.h
+        src/io/socket/ehc/NetEnc.cpp
 )
 
 if (IS_OS_WINDOWS)

include/ehs/io/audio/Audio.h

@@ -81,10 +81,14 @@ namespace ehs
 
 		UInt_64 GetSampleCount() const;
 
+		UInt_8 GetFrameSize() const;
+
 		UInt_64 GetSize() const;
 
 		float GetLength() const;
 
+		Byte* GetFrame(UInt_64 frameIndex) const;
+
 		Array<Byte> FrameAsMono(UInt_64 frameIndex) const;
 
 		Array<Byte> FrameAsStereo(UInt_64 frameIndex) const;

include/ehs/io/audio/BaseAudioDevice.h

@@ -52,7 +52,9 @@ namespace ehs
 
     	virtual UInt_64 ReceiveStream(void *data, UInt_64 size);
 
-    	void BridgeStreams(UInt_64 bufferSize);
+		void BridgeStreams(BaseAudioDevice *input, UInt_64 frameBufferSize);
+
+    	void BridgeStreams(UInt_64 frameBufferSize);
 
         AudioDeviceType GetType() const;
 

include/ehs/io/socket/EHC.h

@@ -0,0 +1,228 @@
+#pragma once
+
+#include "ehs/io/socket/ehc/NetUtils.h"
+#include "ehs/io/socket/ehc/NetEnc.h"
+#include "ehs/Serializer.h"
+#include "ehs/Vector.h"
+#include "ehs/Array.h"
+#include "Socket.h"
+#include "UDP.h"
+
+namespace ehs
+{
+	class NetSys;
+	class NetEnd;
+	class EHC;
+
+	typedef bool (*ConnectCb)(EHC *, NetEnd **, Serializer<UInt_64>);
+	typedef void (*ConnectedCb)(EHC *, NetEnd *);
+	typedef void (*ActiveCb)(EHC *, NetEnd *);
+	typedef void (*DisconnectCb)(EHC *, NetEnd *, Serializer<UInt_64>);
+	typedef void (*DisconnectedCb)(EHC *, NetEnd *);
+	typedef void (*TimeoutCb)(EHC *, NetEnd *);
+
+	class EHC
+    {
+    private:
+		friend class NetEnc;
+		friend class NetEnd;
+
+		static const Version version;
+		static const UInt_64 internalSys;
+		static const UInt_64 connectOp;
+		static const UInt_64 connectedOp;
+		static const UInt_64 rejectedOp;
+		static const UInt_64 disconnectOp;
+		static const UInt_64 disconnectedOp;
+		static const UInt_64 statusUpdateOp;
+		static const UInt_64 pingOp;
+		static const UInt_64 pongOp;
+		static const UInt_64 latencyOp;
+		static const UInt_64 receivedOp;
+
+		UDP udp;
+		Version appVer;
+		EndDisp disposition;
+		UInt_64 hashName;
+		Str_8 name;
+		bool dropPackets;
+		Byte* buffer;
+		UInt_32 bufferSize;
+		Array<NetEnc *> encryptions;
+		Array<NetSys *> systems;
+		UInt_32 maxEndpoints;
+        UInt_64 lastTSC;
+        float delta;
+		float maxTimeout;
+        float resendRate;
+		ConnectCb connectCb;
+		ConnectedCb connectedCb;
+		ActiveCb activeCb;
+		DisconnectCb disconnectCb;
+		DisconnectedCb disconnectedCb;
+		TimeoutCb timeoutCb;
+
+	protected:
+		Vector<NetEnd*> endpoints;
+
+    public:
+        ~EHC();
+
+		EHC();
+
+		EHC(const Version &ver, Str_8 name, UInt_64 maxEndpoints);
+
+		EHC(const Version &ver, Str_8 name);
+
+		EHC(EHC &&sock) noexcept;
+
+		EHC(const EHC &sock);
+
+		EHC &operator=(EHC&& sock) noexcept;
+
+		EHC &operator=(const EHC &sock);
+
+        void Initialize();
+
+        void Release();
+
+        void Bind(AddrType newType, const Str_8& newAddress, UInt_16 newPort);
+
+		void Connect(AddrType rType, const Str_8& rAddress, UInt_16 rPort, Serializer<UInt_64> data);
+
+		bool Disconnect(EndDisp endDisp, const Char_8 token[64], const Str_8& msg);
+
+		void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, UInt_64 encHashId,
+					   bool ensure, UInt_64 sysHashId, UInt_64 opHashId,
+					   const Serializer<UInt_64> &payload);
+
+		void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, const Str_8 &encId,
+					   bool ensure, const Str_8 &sysId, const Str_8 &opId,
+					   const Serializer<UInt_64> &payload);
+
+		void Poll();
+
+        bool IsInitialized() const;
+
+		AddrType GetLocalAddressType() const;
+
+		Str_8 GetLocalAddress() const;
+
+		UInt_16 GetLocalPort() const;
+
+        bool IsBound() const;
+
+		static Version GetVersion();
+
+		Version GetAppVersion() const;
+
+		EndDisp GetDisposition() const;
+
+		UInt_64 GetHashName() const;
+
+		Str_8 GetName() const;
+
+		void EnableDropPackets(bool enable);
+
+		bool IsDropPacketsEnabled() const;
+
+		bool HasEncryption(UInt_64 encHashId) const;
+
+		bool HasEncryption(const Str_8& encId) const;
+
+		bool AddEncryption(NetEnc *enc);
+
+		NetEnc* GetEncryption(UInt_64 encHashId) const;
+
+		NetEnc* GetEncryption(const Str_8& encId) const;
+
+		bool HasSystem(UInt_64 sysHashId) const;
+
+		bool HasSystem(const Str_8& sysId) const;
+
+		bool AddSystem(NetSys *sys);
+
+		NetSys* GetSystem(UInt_64 sysHashId) const;
+
+		NetSys* GetSystem(const Str_8& sysId) const;
+
+		bool HasEndpoint(EndDisp endDisp, Status endStatus, const Char_8 token[64]) const;
+
+		bool HasEndpoint(EndDisp endDisp, Status endStatus, UInt_64 hashId) const;
+
+		bool HasEndpoint(EndDisp endDisp, Status endStatus, const Str_8 &id) const;
+
+		bool HasEndpoint(EndDisp endDisp, const Char_8 token[64]) const;
+
+		bool HasEndpoint(EndDisp endDisp, UInt_64 hashId) const;
+
+		bool HasEndpoint(EndDisp endDisp, const Str_8 &id) const;
+
+		bool HasEndpoint(const Char_8 token[64]) const;
+
+		bool HasEndpoint(UInt_64 hashId) const;
+
+		bool HasEndpoint(const Str_8 &id) const;
+
+		bool HasEndpoint(const Str_8& rAddress, UInt_16 rPort) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, Status endStatus, const Char_8 token[64]) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, Status endStatus, UInt_64 hashId) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, Status endStatus, const Str_8 &id) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, const Char_8 token[64]) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, UInt_64 hashId) const;
+
+		NetEnd *GetEndpoint(EndDisp endDisp, const Str_8 &id) const;
+
+		NetEnd *GetEndpoint(const Str_8& rAddress, UInt_16 rPort) const;
+
+		Array<NetEnd *> GetEndpoints(EndDisp endDisp, Status endStatus);
+
+		Array<NetEnd *> GetEndpoints(EndDisp endDisp);
+
+		UInt_64 GetEndpointsCount(EndDisp endDisp, Status endStatus);
+
+		UInt_64 GetEndpointsCount(EndDisp endDisp);
+
+		UInt_64 GetMaxEndpoints() const;
+
+		void SetMaxTimeout(float seconds);
+
+		float GetMaxTimeout() const;
+
+        void SetResendRate(float seconds);
+
+        float GetResendRate() const;
+
+		void SetConnectCb(ConnectCb cb);
+
+		void SetConnectedCb(ConnectedCb cb);
+
+		void SetActiveCb(ActiveCb cb);
+
+		void SetDisconnectCb(DisconnectCb cb);
+
+		void SetDisconnectedCb(DisconnectedCb cb);
+
+		void SetTimeoutCb(TimeoutCb cb);
+
+    private:
+		void GenerateToken(Char_8 in[64]);
+
+		void UpdateQueue(UInt_64 active);
+
+		void UpdateQueue();
+
+		bool RemoveEndpoint(EndDisp disposition, const Char_8 token[64]);
+
+		bool RemoveEndpoint(const Str_8& address, UInt_16 port);
+
+		bool RemoveEndpoint(const NetEnd* end);
+
+		void PollEndpoints();
+    };
+}

include/ehs/io/socket/ehc/NetEnc.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "ehs/Str.h"
+
+namespace ehs
+{
+	class EHC;
+
+	class NetEnc
+	{
+	private:
+		friend class EHC;
+
+		EHC *owner;
+		UInt_64 hashId;
+		Str_8 id;
+
+	public:
+		virtual ~NetEnc() = default;
+
+		NetEnc();
+
+		NetEnc(Str_8 id);
+
+		NetEnc(NetEnc &&enc) noexcept;
+
+		NetEnc(const NetEnc &enc);
+
+		NetEnc &operator=(NetEnc &&enc) noexcept;
+
+		NetEnc &operator=(const NetEnc &enc);
+
+		EHC *GetOwner() const;
+
+		UInt_64 GetHashId() const;
+
+		Str_8 GetId() const;
+
+		virtual void Encrypt(Byte *data, UInt_64 size) const;
+
+		virtual void Decrypt(Byte *data, UInt_64 size) const;
+	};
+}

include/ehs/io/socket/ehc/NetEnd.h

@@ -0,0 +1,134 @@
+#pragma once
+
+#include "NetUtils.h"
+#include "NetFrags.h"
+
+#include "ehs/Str.h"
+#include "ehs/Vector.h"
+#include "ehs/Serializer.h"
+#include "ehs/io/socket/Socket.h"
+
+namespace ehs
+{
+	class EHC;
+
+	class NetEnd
+	{
+	private:
+		friend class EHC;
+
+		EHC* owner;
+		EndDisp disposition;
+		UInt_64 hashName;
+		Str_8 name;
+		Status status;
+		Architecture arch;
+		Char_8 token[64];
+		UInt_64 nextSendId;
+		Vector<Insurance> sent;
+		UInt_64 nextRecvId;
+		Vector<NetFrags> received;
+		AddrType type;
+		Str_8 address;
+		UInt_16 port;
+		float deltaDuration;
+		float deltaRate;
+		float timeout;
+		float lastPing;
+        float oldLatency;
+		float latency;
+		UInt_64 queueSlot;
+
+	public:
+		NetEnd();
+
+		NetEnd(EndDisp disposition, Str_8 id, Architecture arch, AddrType type, Str_8 address, UInt_16 port);
+
+		NetEnd(AddrType type, Str_8 address, UInt_16 port);
+
+		NetEnd(NetEnd &&end) noexcept;
+
+		NetEnd(const NetEnd &end);
+
+		NetEnd &operator=(NetEnd &&end) noexcept;
+
+		NetEnd &operator=(const NetEnd &end);
+
+		EndDisp GetDisposition() const;
+
+		UInt_64 GetHashName() const;
+
+		Str_8 GetName() const;
+
+		Status GetStatus() const;
+
+		Architecture GetArchitecture() const;
+
+		UInt_64 GetNextSendId() const;
+
+		/// Sends data to the remote endpoint.
+		/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
+		/// @param [in] encHashId The hash id of the encryption to use. Can be zero for none.
+		/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
+		/// @param [in] sys The system hash id to execute an operation from.
+		/// @param [in] op The operation hash id in the system to execute.
+		/// @param [in] payload Additional parameters and data to send to the remote endpoint.
+		void Send(bool deltaLocked, UInt_64 encHashId, bool ensure, UInt_64 sys, UInt_64 op, const Serializer<UInt_64>& payload);
+
+		/// Sends data to the remote endpoint.
+		/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
+		/// @param [in] encId The id of the encryption to use. Can be empty for none.
+		/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
+		/// @param [in] sys The system string id to execute an operation from.
+		/// @param [in] op The operation string id in the system to execute.
+		/// @param [in] payload Additional parameters and data to send to the remote endpoint.
+		void Send(bool deltaLocked, const Str_8 &encID, bool ensure, const Str_8& sys, const Str_8& op, const Serializer<UInt_64>& payload);
+
+		UInt_64 GetNextRecvId() const;
+
+		Str_8 GetAddress() const;
+
+		UInt_16 GetPort() const;
+
+		void SetDeltaRate(float newDeltaRate);
+
+		float GetDeltaRate() const;
+
+		float GetTimeout() const;
+
+		float GetLastPing() const;
+
+		void SendLatency();
+
+		float GetLatency() const;
+
+		UInt_64 GetQueueSlot() const;
+
+	private:
+		void Poll(float delta);
+
+		void SetStatus(Status newStatus);
+
+		void RemoveInsurance(UInt_64 msgId, UInt_64 fragment);
+
+		void AddReceived(const Header& header, const Serializer<>& payload);
+
+		Vector<NetFrags>* GetReceived();
+
+		void Ping(float delta);
+
+		void Pong(float delta);
+
+		void SetLatency(float newLatency);
+
+		void SetQueueSlot(UInt_64 slot);
+
+		NetFrags FragmentData(const Header& header, const Serializer<>& data);
+
+		void Send(const Header& header, const Serializer<>& payload);
+
+		bool SortingNeeded() const;
+
+		void SortReceived();
+	};
+}

include/ehs/io/socket/ehc/NetFrags.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "NetUtils.h"
+
+#include <ehs/Serializer.h>
+
+namespace ehs
+{
+	class NetFrags
+	{
+	private:
+		Header header;
+		Serializer<UInt_64>* data;
+		UInt_64 size;
+
+	public:
+		~NetFrags();
+
+		NetFrags();
+
+		NetFrags(const Header &header, const Serializer<UInt_64> &payload);
+
+        NetFrags(const Header &header, UInt_64 size);
+
+		NetFrags(NetFrags &&frags) noexcept;
+
+		NetFrags(const NetFrags &frags);
+
+		NetFrags &operator=(NetFrags &&frags) noexcept;
+
+		NetFrags &operator=(const NetFrags &frags);
+
+		operator Serializer<UInt_64> *() const;
+
+		Header GetHeader() const;
+
+		UInt_64 Size() const;
+
+		bool IsComplete() const;
+
+		Packet Combine() const;
+	};
+}

include/ehs/io/socket/ehc/NetOp.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ehs/Str.h"
+#include "ehs/Serializer.h"
+
+namespace ehs
+{
+	class EHC;
+	class NetSys;
+	class NetEnd;
+
+	class NetOp
+	{
+	private:
+		friend class NetSys;
+
+		UInt_64 hashId;
+		Str_8 id;
+
+	public:
+		virtual ~NetOp() = default;
+
+		NetOp();
+
+		NetOp(Str_8 id);
+
+		NetOp(NetOp &&op) noexcept;
+
+		NetOp(const NetOp &op);
+
+		NetOp &operator=(NetOp &&op) noexcept;
+
+		NetOp &operator=(const NetOp &op);
+
+		Str_8 GetId() const;
+
+		UInt_64 GetHashId() const;
+
+	private:
+		virtual void Process(EHC *ehc, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload);
+	};
+}

include/ehs/io/socket/ehc/NetSys.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "ehs/Str.h"
+#include "ehs/Array.h"
+#include "ehs/Serializer.h"
+
+namespace ehs
+{
+	class EHC;
+	class NetEnd;
+	class NetOp;
+
+	class NetSys
+	{
+	private:
+		friend class EHC;
+
+		UInt_64 hashId;
+		Str_8 id;
+		Array<NetOp*> ops;
+
+	public:
+		virtual ~NetSys();
+
+		NetSys();
+
+		NetSys(Str_8 id);
+
+		NetSys(NetSys &&sys) noexcept;
+
+		NetSys(const NetSys &sys);
+
+		NetSys &operator=(NetSys &&sys) noexcept;
+
+		NetSys &operator=(const NetSys &sys);
+
+		Str_8 GetId() const;
+
+		UInt_64 GetHashId() const;
+
+		bool HasOperation(UInt_64 hashId) const;
+
+		bool AddOperation(NetOp *op);
+
+	private:
+		void Execute(EHC *ehc, NetEnd *endpoint, UInt_64 hashId, Serializer<UInt_64> &payload);
+	};
+}

include/ehs/io/socket/ehc/NetUtils.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "ehs/Serializer.h"
+
+namespace ehs
+{
+	enum class EndDisp : UInt_8
+	{
+		ENDPOINT,
+		SERVICE
+	};
+
+	enum class Status : UInt_8
+	{
+		ACTIVE,
+		PENDING,
+		IN_LOCAL_QUEUE,
+		IN_REMOTE_QUEUE,
+	};
+
+	struct Header
+	{
+		UInt_64 encHashId = 0;
+		UInt_64 id = 0;
+		UInt_64 fragments = 0;
+		UInt_64 fragment = 0;
+		bool ensure = false;
+		EndDisp disposition = EndDisp::ENDPOINT;
+		Char_8 token[64] = {};
+		UInt_64 system = 0;
+		UInt_64 op = 0;
+	};
+
+	struct Packet
+	{
+		Header header;
+		Serializer<UInt_64> payload;
+	};
+
+    struct Insurance
+    {
+        Header header;
+        Serializer<UInt_64> payload;
+        float lastResend;
+    };
+}
+
+#ifndef EHC_IPV4_PAYLOAD
+	#define EHC_IPV4_PAYLOAD (EHS_IPV4_UDP_PAYLOAD - (UInt_16)sizeof(Header))
+#endif
+
+#ifndef EHC_IPV6_PAYLOAD
+	#define EHC_IPV6_PAYLOAD (EHS_IPV6_UDP_PAYLOAD - (UInt_16)sizeof(Header))
+#endif

src/io/audio/Audio.cpp

@@ -290,6 +290,11 @@ namespace ehs
 		return channels * frames;
 	}
 
+	UInt_8 Audio::GetFrameSize() const
+	{
+		return byteDepth * channels;
+	}
+
 	UInt_64 Audio::GetSize() const
 	{
 		return byteDepth * channels * frames;
@@ -300,6 +305,11 @@ namespace ehs
 		return length;
 	}
 
+	Byte* Audio::GetFrame(UInt_64 frameIndex) const
+	{
+		return &data[frameIndex * GetFrameSize()];
+	}
+
 	Array<Byte> Audio::FrameAsMono(const UInt_64 frameIndex) const
 	{
 		Array<Byte> result(byteDepth);
@@ -1743,161 +1753,161 @@ namespace ehs
 	void Audio::SInt_16_to_SInt_8(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			newData[a] = (Byte)((float)((SInt_16*)data)[a] / (float)EHS_SINT_16_MAX * (float)EHS_SINT_8_MAX);
+			newData[a] = (Byte)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
 
-		*(SInt_8*)newPeak = (SInt_8)((float)*(SInt_16*)peak / (float)EHS_SINT_16_MAX * (float)EHS_SINT_8_MAX);
+		*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
 	}
 
 	void Audio::Float_to_SInt_8(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_8*)newData)[a] = (SInt_8)(((float*)data)[a] * (float)EHS_SINT_8_MAX);
+			((SInt_8*)newData)[a] = (SInt_8)((double)((float*)data)[a] * (double)EHS_SINT_8_MAX);
 
-		*(SInt_8*)newPeak = (SInt_8)(*(float*)peak * (float)EHS_SINT_8_MAX);
+		*(SInt_8*)newPeak = (SInt_8)((double)(*(float*)peak) * (double)EHS_SINT_8_MAX);
 	}
 
 	void Audio::SInt_32_to_SInt_8(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			newData[a] = (Byte)((float)((SInt_32*)data)[a] / (float)EHS_SINT_32_MAX * (float)EHS_SINT_8_MAX);
+			newData[a] = (Byte)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
 
-		*(SInt_8*)newPeak = (SInt_8)((float)*(SInt_32*)peak / (float)EHS_SINT_32_MAX * (float)EHS_SINT_8_MAX);
+		*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
 	}
 
 	void Audio::SInt_64_to_SInt_8(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			newData[a] = (Byte)((float)((SInt_64*)data)[a] / (float)EHS_SINT_64_MAX * (float)EHS_SINT_8_MAX);
+			newData[a] = (Byte)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
 
-		*(SInt_8*)newPeak = (SInt_8)((float)*(SInt_64*)peak / (float)EHS_SINT_64_MAX * (float)EHS_SINT_8_MAX);
+		*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
 	}
 
 	void Audio::SInt_8_to_SInt_16(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_16*)newData)[a] = (SInt_16)((float)(SInt_8)data[a] / (float)EHS_SINT_8_MAX * (float)EHS_SINT_16_MAX);
+			((SInt_16*)newData)[a] = (SInt_16)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
 
-		*(SInt_16*)newPeak = (SInt_16)((float)*(SInt_8*)peak / (float)EHS_SINT_8_MAX * (float)EHS_SINT_16_MAX);
+		*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
 	}
 
 	void Audio::Float_to_SInt_16(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_16*)newData)[a] = (SInt_16)(((float*)data)[a] * (float)EHS_SINT_16_MAX);
+			((SInt_16*)newData)[a] = (SInt_16)((double)((float*)data)[a] * (double)EHS_SINT_16_MAX);
 
-		*(SInt_16*)newPeak = (SInt_16)(*(float*)peak * (float)EHS_SINT_16_MAX);
+		*(SInt_16*)newPeak = (SInt_16)((double)(*(float*)peak) * (double)EHS_SINT_16_MAX);
 	}
 
 	void Audio::SInt_32_to_SInt_16(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_16*)newData)[a] = (SInt_16)((float)((SInt_32*)data)[a] / (float)EHS_SINT_32_MAX * (float)EHS_SINT_16_MAX);
+			((SInt_16*)newData)[a] = (SInt_16)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
 
-		*(SInt_16*)newPeak = (SInt_16)((float)*(SInt_32*)peak / (float)EHS_SINT_32_MAX * (float)EHS_SINT_16_MAX);
+		*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
 	}
 
 	void Audio::SInt_64_to_SInt_16(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_16*)newData)[a] = (SInt_16)((float)((SInt_64*)data)[a] / (float)EHS_SINT_64_MAX * (float)EHS_SINT_16_MAX);
+			((SInt_16*)newData)[a] = (SInt_16)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
 
-		*(SInt_16*)newPeak = (SInt_16)((float)*(SInt_64*)peak / (float)EHS_SINT_64_MAX * (float)EHS_SINT_16_MAX);
+		*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
 	}
 
 	void Audio::SInt_8_to_Float(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((float*)newData)[a] = (float)(((SInt_8*)data)[a]) / (float)EHS_SINT_8_MAX;
+			((float*)newData)[a] = (float)((double)(((SInt_8*)data)[a]) / (double)EHS_SINT_8_MAX);
 
-		*(float*)newPeak = (float)*(SInt_8*)peak / (float)EHS_SINT_8_MAX;
+		*(float*)newPeak = (float)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX);
 	}
 
 	void Audio::SInt_16_to_Float(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((float*)newData)[a] = (float)(((SInt_16*)data)[a]) / (float)EHS_SINT_16_MAX;
+			((float*)newData)[a] = (float)((double)(((SInt_16*)data)[a]) / (double)EHS_SINT_16_MAX);
 
-		*(float*)newPeak = (float)*(SInt_16*)peak / (float)EHS_SINT_16_MAX;
+		*(float*)newPeak = (float)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX);
 	}
 
 	void Audio::SInt_32_to_Float(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((float*)newData)[a] = (float)(((SInt_32*)data)[a]) / (float)EHS_SINT_32_MAX;
+			((float*)newData)[a] = (float)((double)(((SInt_32*)data)[a]) / (double)EHS_SINT_32_MAX);
 
-		*(float*)newPeak = (float)*(SInt_32*)peak / (float)EHS_SINT_32_MAX;
+		*(float*)newPeak = (float)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX);
 	}
 
 	void Audio::SInt_64_to_Float(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((float*)newData)[a] = (float)(((SInt_64*)data)[a]) / (float)EHS_SINT_64_MAX;
+			((float*)newData)[a] = (float)((double)(((SInt_64*)data)[a]) / (double)EHS_SINT_64_MAX);
 
-		*(float*)newPeak = (float)*(SInt_64*)peak / (float)EHS_SINT_64_MAX;
+		*(float*)newPeak = (float)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX);
 	}
 
 	void Audio::SInt_8_to_SInt_32(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_32*)newData)[a] = (SInt_32)((float)(SInt_8)data[a] / (float)EHS_SINT_8_MAX * (float)EHS_SINT_32_MAX);
+			((SInt_32*)newData)[a] = (SInt_32)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
 
-		*(SInt_32*)newPeak = (SInt_32)((float)*(SInt_8*)peak / (float)EHS_SINT_8_MAX * (float)EHS_SINT_32_MAX);
+		*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
 	}
 
 	void Audio::SInt_16_to_SInt_32(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_32*)newData)[a] = (SInt_32)((float)((SInt_16*)data)[a] / (float)EHS_SINT_16_MAX * (float)EHS_SINT_32_MAX);
+			((SInt_32*)newData)[a] = (SInt_32)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
 
-		*(SInt_32*)newPeak = (SInt_32)((float)*(SInt_16*)peak / (float)EHS_SINT_16_MAX * (float)EHS_SINT_32_MAX);
+		*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
 	}
 
 	void Audio::Float_to_SInt_32(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_32*)newData)[a] = (SInt_32)(((float*)data)[a] * (float)EHS_SINT_32_MAX);
+			((SInt_32*)newData)[a] = (SInt_32)(((double*)data)[a] * (double)EHS_SINT_32_MAX);
 
-		*(SInt_32*)newPeak = (SInt_32)(*(float*)peak * (float)EHS_SINT_32_MAX);
+		*(SInt_32*)newPeak = (SInt_32)(*(double*)peak * (double)EHS_SINT_32_MAX);
 	}
 
 	void Audio::SInt_64_to_SInt_32(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_32*)newData)[a] = (SInt_32)((float)((SInt_64*)data)[a] / (float)EHS_SINT_64_MAX * (float)EHS_SINT_32_MAX);
+			((SInt_32*)newData)[a] = (SInt_32)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
 
-		*(SInt_32*)newPeak = (SInt_32)((float)*(SInt_64*)peak / (float)EHS_SINT_64_MAX * (float)EHS_SINT_32_MAX);
+		*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
 	}
 
 	void Audio::SInt_8_to_SInt_64(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_64*)newData)[a] = (SInt_64)((float)(SInt_8)data[a] / (float)EHS_SINT_8_MAX * (float)EHS_SINT_64_MAX);
+			((SInt_64*)newData)[a] = (SInt_64)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
 
-		*(SInt_64*)newPeak = (SInt_64)((float)*(SInt_8*)peak / (float)EHS_SINT_8_MAX * (float)EHS_SINT_64_MAX);
+		*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
 	}
 
 	void Audio::SInt_16_to_SInt_64(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_64*)newData)[a] = (SInt_64)((float)((SInt_16*)data)[a] / (float)EHS_SINT_16_MAX * (float)EHS_SINT_64_MAX);
+			((SInt_64*)newData)[a] = (SInt_64)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
 
-		*(SInt_64*)newPeak = (SInt_64)((float)*(SInt_16*)peak / (float)EHS_SINT_16_MAX * (float)EHS_SINT_64_MAX);
+		*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
 	}
 
 	void Audio::Float_to_SInt_64(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_64*)newData)[a] = (SInt_64)(((float*)data)[a] * (float)EHS_SINT_64_MAX);
+			((SInt_64*)newData)[a] = (SInt_64)(((double*)data)[a] * (double)EHS_SINT_64_MAX);
 
-		*(SInt_64*)newPeak = (SInt_64)(*(float*)peak * (float)EHS_SINT_64_MAX);
+		*(SInt_64*)newPeak = (SInt_64)(*(double*)peak * (double)EHS_SINT_64_MAX);
 	}
 
 	void Audio::SInt_32_to_SInt_64(Byte* newData, Byte* newPeak) const
 	{
 		for (UInt_64 a = 0; a < GetSampleCount(); ++a)
-			((SInt_64*)newData)[a] = (SInt_64)((float)((SInt_32*)data)[a] / (float)EHS_SINT_32_MAX * (float)EHS_SINT_64_MAX);
+			((SInt_64*)newData)[a] = (SInt_64)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
 
-		*(SInt_64*)newPeak = (SInt_64)((float)*(SInt_32*)peak / (float)EHS_SINT_32_MAX * (float)EHS_SINT_64_MAX);
+		*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
 	}
 
 	bool EncodeEHA(const ehs::AudioCodec* const codec, ehs::Serializer<ehs::UInt_64>& out, const ehs::Audio* const in)

src/io/audio/AudioDevice_W32.cpp

@@ -341,6 +341,8 @@ namespace ehs
 			return 0;
 		}
 
+		Util::Copy(buffer, data, frameSize * byteDepth * channels);
+
 		r = playbackClient->ReleaseBuffer(frameSize, 0);
 		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
 		{

src/io/audio/BaseAudioDevice.cpp

@@ -1,4 +1,5 @@
 #include "ehs/io/audio/BaseAudioDevice.h"
+#include "ehs/log.h"
 
 namespace ehs
 {
@@ -49,19 +50,48 @@ namespace ehs
 		return 0;
 	}
 
-	void BaseAudioDevice::BridgeStreams(const UInt_64 bufferSize)
+	void BaseAudioDevice::BridgeStreams(BaseAudioDevice* input, UInt_64 frameBufferSize)
 	{
-		Byte* buffer = new Byte[bufferSize];
+		if (type != AudioDeviceType::OUTPUT)
+		{
+			EHS_LOG_INT(LogType::WARN, 0, "The current audio device object is not an output device.");
+			return;
+		}
 
-		UInt_64 result = ReceiveStream(buffer, bufferSize);
-		while (result < bufferSize)
-			result += ReceiveStream(&buffer[result], bufferSize - result);
+		if (input->type != AudioDeviceType::INPUT)
+		{
+			EHS_LOG_INT(LogType::WARN, 1, "The provided audio device is not an input device.");
+			return;
+		}
+
+		Byte* buffer = new Byte[frameBufferSize * GetFrameSize()];
+
+		UInt_64 result = 0;
+		while (result < frameBufferSize)
+			result += input->ReceiveStream(&buffer[result * GetFrameSize()], frameBufferSize - result);
 
-		result -= SendStream(buffer, result);
 		while (result)
-			result -= SendStream(&buffer[bufferSize - result], result);
+			result -= SendStream(&buffer[(frameBufferSize - result) * GetFrameSize()], result);
 
 		delete[] buffer;
+
+		EHS_LOG_SUCCESS();
+	}
+
+	void BaseAudioDevice::BridgeStreams(const UInt_64 frameBufferSize)
+	{
+		Byte* buffer = new Byte[frameBufferSize * GetFrameSize()];
+
+		UInt_64 result = ReceiveStream(buffer, frameBufferSize);
+		while (result < frameBufferSize)
+			result += ReceiveStream(&buffer[result * GetFrameSize()], frameBufferSize - result);
+
+		while (result)
+			result -= SendStream(&buffer[(frameBufferSize - result) * GetFrameSize()], result);
+
+		delete[] buffer;
+
+		EHS_LOG_SUCCESS();
 	}
 
 	AudioDeviceType BaseAudioDevice::GetType() const

src/io/socket/ehc/NetEnc.cpp

@@ -0,0 +1,76 @@
+#include "ehs/io/socket/ehc/NetEnc.h"
+
+namespace ehs
+{
+	NetEnc::NetEnc()
+		: owner(nullptr), hashId(0)
+	{
+	}
+
+	NetEnc::NetEnc(Str_8 id)
+		: owner(nullptr), hashId(id.Hash_64()), id((Str_8 &&)id)
+	{
+	}
+
+	NetEnc::NetEnc(NetEnc&& enc) noexcept
+		: owner(enc.owner), hashId(enc.hashId), id((Str_8 &&)enc.id)
+	{
+		enc.owner = nullptr;
+		enc.hashId = 0;
+	}
+
+	NetEnc::NetEnc(const NetEnc& enc)
+		: owner(nullptr), hashId(enc.hashId), id(enc.id)
+	{
+	}
+
+	NetEnc& NetEnc::operator=(NetEnc&& enc) noexcept
+	{
+		if (this == &enc)
+			return *this;
+
+		owner = enc.owner;
+		hashId = enc.hashId;
+		id = (Str_8 &&)enc.id;
+
+		enc.owner = nullptr;
+		enc.hashId = 0;
+
+		return *this;
+	}
+
+	NetEnc& NetEnc::operator=(const NetEnc& enc)
+	{
+		if (this == &enc)
+			return *this;
+
+		owner = nullptr;
+		hashId = enc.hashId;
+		id = enc.id;
+
+		return *this;
+	}
+
+	EHC* NetEnc::GetOwner() const
+	{
+		return owner;
+	}
+
+	UInt_64 NetEnc::GetHashId() const
+	{
+		return hashId;
+	}
+
+	Str_8 NetEnc::GetId() const
+	{
+		return id;
+	}
+
+	void NetEnc::Encrypt(Byte *data, UInt_64 size) const
+	{
+	}
+
+	void NetEnc::Decrypt(Byte *data, UInt_64 size) const
+	{
+	}
+}

src/io/socket/ehc/NetEnd.cpp

@@ -0,0 +1,535 @@
+#include "ehs/io/socket/ehc/NetEnd.h"
+#include "ehs/io/socket/EHC.h"
+#include "ehs/io/socket/ehc/NetEnc.h"
+#include "ehs/system/CPU.h"
+
+namespace ehs
+{
+	NetEnd::NetEnd()
+		: owner(nullptr), disposition(EndDisp::ENDPOINT), hashName(0), status(Status::PENDING),
+		arch(Architecture::UNKNOWN), token{}, nextSendId(0), nextRecvId(0), type(AddrType::IPV6), port(0),
+		deltaDuration(0.0f), deltaRate(1.0f / 60.0f), timeout(0.0f), lastPing(0.0f), oldLatency(0.0f), latency(0.0f),
+		queueSlot(0)
+	{
+	}
+
+	NetEnd::NetEnd(const EndDisp disposition, Str_8 id, const Architecture arch, const AddrType type,
+			Str_8 address, const UInt_16 port)
+		: owner(nullptr), disposition(disposition), hashName(id.Hash_64()), name((Str_8&&)id), status(Status::ACTIVE),
+		arch(arch), token{}, nextSendId(0), nextRecvId(0), type(type), address((Str_8&&)address), port(port),
+		deltaDuration(0.0f), deltaRate(1.0f / 60.0f), timeout(0.0f), lastPing(0.0f), oldLatency(0.0f), latency(0.0f),
+		queueSlot(0)
+	{
+	}
+
+	NetEnd::NetEnd(const AddrType type, Str_8 address, const UInt_16 port)
+		: owner(nullptr), disposition(EndDisp::ENDPOINT), hashName(0), status(Status::PENDING),
+		arch(Architecture::UNKNOWN), token{}, nextSendId(0), nextRecvId(0), type(type), address((Str_8&&)address),
+		port(port), deltaDuration(0.0f), deltaRate(1.0f / 60.0f), timeout(0.0f), lastPing(0.0f), oldLatency(0.0f),
+		latency(0.0f), queueSlot(0)
+	{
+	}
+
+	NetEnd::NetEnd(NetEnd &&end) noexcept
+		: owner(end.owner), disposition(end.disposition), hashName(end.hashName), name((Str_8&&)end.name), status(end.status), arch(end.arch), token{},
+		  nextSendId(end.nextSendId), sent((Vector<Insurance>&&)end.sent), nextRecvId(end.nextRecvId),
+		  received((Vector<NetFrags>&&)end.received), type(end.type), address((Str_8&&)end.address), port(end.port),
+		  deltaDuration(end.deltaDuration), deltaRate(end.deltaRate), timeout(end.timeout), lastPing(end.lastPing),
+		  oldLatency(end.oldLatency), latency(end.latency), queueSlot(end.queueSlot)
+	{
+		end.owner = nullptr;
+		end.disposition = EndDisp::ENDPOINT;
+		end.hashName = 0;
+		end.status = Status::PENDING;
+		end.arch = Architecture::UNKNOWN;
+		Util::Copy(token, end.token, 64);
+		Util::Zero(end.token, 64);
+		end.nextSendId = 0;
+		end.nextRecvId = 0;
+		end.type = AddrType::IPV6;
+		end.port = 0;
+		end.deltaDuration = 0.0f;
+		end.deltaRate = 1.0f / 60.0f;
+		end.timeout = 0.0f;
+		end.lastPing = 0.0f;
+		end.oldLatency = 0.0f;
+		end.latency = 0.0f;
+		end.queueSlot = 0;
+	}
+
+	NetEnd::NetEnd(const NetEnd& end)
+		: owner(nullptr), disposition(EndDisp::ENDPOINT), hashName(end.hashName), name(end.name), status(Status::PENDING), arch(Architecture::UNKNOWN),
+		token{}, nextSendId(0), nextRecvId(0), type(end.type), port(0), deltaDuration(0.0f), deltaRate(1.0f / 60.0f),
+		timeout(0.0f), lastPing(0.0f), oldLatency(0.0f), latency(0.0f), queueSlot(0)
+	{
+	}
+
+	NetEnd& NetEnd::operator=(NetEnd&& end) noexcept
+	{
+		if (this == &end)
+			return *this;
+
+		owner = end.owner;
+		disposition = end.disposition;
+		hashName = end.hashName;
+		name = (Str_8&&)end.name;
+		status = end.status;
+		arch = end.arch;
+		Util::Copy(token, end.token, 64);
+		nextSendId = end.nextSendId;
+		sent = (Vector<Insurance>&&)end.sent;
+		nextRecvId = end.nextRecvId;
+		received = (Vector<NetFrags>&&)end.received;
+		type = end.type;
+		address = (Str_8&&)end.address;
+		port = end.port;
+		deltaDuration = end.deltaDuration;
+		deltaRate = end.deltaRate;
+		timeout = end.timeout;
+		lastPing = end.lastPing;
+		oldLatency = end.oldLatency;
+		latency = end.latency;
+		queueSlot = end.queueSlot;
+
+		end.owner = nullptr;
+		end.disposition = EndDisp::ENDPOINT;
+		end.hashName = 0;
+		end.status = Status::PENDING;
+		end.arch = Architecture::UNKNOWN;
+		Util::Zero(end.token, 64);
+		end.nextSendId = 0;
+		end.nextRecvId = 0;
+		end.type = AddrType::IPV6;
+		end.port = 0;
+		end.deltaDuration = 0.0f;
+		end.deltaRate = 1.0f / 60.0f;
+		end.timeout = 0.0f;
+		end.lastPing = 0.0f;
+		end.oldLatency = 0.0f;
+		end.latency = 0.0f;
+		end.queueSlot = 0;
+
+		return *this;
+	}
+
+	NetEnd &NetEnd::operator=(const NetEnd &end)
+	{
+		if (this == &end)
+			return *this;
+
+		owner = nullptr;
+		disposition = EndDisp::ENDPOINT;
+		hashName = end.hashName;
+		name = end.name;
+		status = Status::PENDING;
+		arch = Architecture::UNKNOWN;
+		Util::Zero(token, 64);
+		nextSendId = 0;
+		sent = {};
+		nextRecvId = 0;
+		received = {};
+		type = AddrType::IPV6;
+		address = {};
+		port = 0;
+		deltaDuration = 0.0f;
+		deltaRate = 1.0f / 60.0f;
+		timeout = 0.0f;
+		lastPing = 0.0f;
+        oldLatency = 0.0f;
+		latency = 0.0f;
+		queueSlot = 0;
+
+		return *this;
+	}
+
+	EndDisp NetEnd::GetDisposition() const
+	{
+		return disposition;
+	}
+
+	UInt_64 NetEnd::GetHashName() const
+	{
+		return hashName;
+	}
+
+	Str_8 NetEnd::GetName() const
+	{
+		return name;
+	}
+
+	Status NetEnd::GetStatus() const
+	{
+		return status;
+	}
+
+	Architecture NetEnd::GetArchitecture() const
+	{
+		return arch;
+	}
+
+	UInt_64 NetEnd::GetNextSendId() const
+	{
+		return nextSendId;
+	}
+
+	void NetEnd::Send(const bool deltaLocked, const UInt_64 encHashId, const bool ensure, const UInt_64 sys,
+					  const UInt_64 op, const Serializer<UInt_64> &payload)
+	{
+		if (deltaLocked && deltaDuration < deltaRate)
+			return;
+
+		Header header = {
+				encHashId,
+				nextSendId++,
+				1,
+				0,
+				ensure,
+				owner->GetDisposition(),
+				"",
+				sys,
+				op
+		};
+
+		Util::Copy(header.token, token, 64);
+
+		if ((owner->GetLocalAddressType() == AddrType::IPV6 && payload.Size() > EHC_IPV6_PAYLOAD) || (owner->GetLocalAddressType() == AddrType::IPV4 && payload.Size() > EHC_IPV4_PAYLOAD))
+		{
+			NetFrags frags = FragmentData(header, payload);
+			for (UInt_64 i = 0; i < frags.Size(); ++i)
+            {
+                Header newHeader = frags.GetHeader();
+                newHeader.fragment = i;
+
+                Send(newHeader, frags[i]);
+            }
+		}
+		else
+		{
+			Send(header, payload);
+		}
+	}
+
+	void NetEnd::Send(const bool deltaLocked, const Str_8 &encId, const bool ensure, const Str_8& sys,
+					  const Str_8& op, const Serializer<>& payload)
+	{
+		Send(deltaLocked, encId.Hash_64(), ensure, sys.Hash_64(), op.Hash_64(), payload);
+	}
+
+	UInt_64 NetEnd::GetNextRecvId() const
+	{
+		return nextRecvId;
+	}
+
+	Str_8 NetEnd::GetAddress() const
+	{
+		return address;
+	}
+
+	UInt_16 NetEnd::GetPort() const
+	{
+		return port;
+	}
+
+	float NetEnd::GetDeltaRate() const
+	{
+		return deltaRate;
+	}
+
+	float NetEnd::GetTimeout() const
+	{
+		return timeout;
+	}
+
+	float NetEnd::GetLastPing() const
+	{
+		return lastPing;
+	}
+
+	float NetEnd::GetLatency() const
+	{
+		return oldLatency;
+	}
+
+	UInt_64 NetEnd::GetQueueSlot() const
+	{
+		return queueSlot;
+	}
+
+	void NetEnd::Poll(const float delta)
+	{
+		SortReceived();
+
+		if (deltaDuration >= deltaRate)
+			deltaDuration = Math::Mod(deltaDuration, deltaRate);
+
+		deltaDuration += delta;
+		timeout += delta;
+		latency += delta;
+
+		if (sent.Size())
+		{
+			for (UInt_64 i = 0; i < sent.Size(); ++i)
+			{
+				sent[i].lastResend += delta;
+				if (sent[i].lastResend >= owner->GetResendRate())
+				{
+					Serializer result(Endianness::LE);
+					result.Write(sent[i].header);
+					result.WriteSer(sent[i].payload);
+
+					if (sent[i].header.encHashId)
+					{
+						NetEnc *enc = owner->GetEncryption(sent[i].header.encHashId);
+						if (!enc)
+						{
+							EHS_LOG_INT(LogType::WARN, 0, "The network encryption with the hash id " +
+										Str_8::FromNum(sent[i].header.encHashId) + ", does not exist.");
+
+							continue;
+						}
+
+						enc->Encrypt(&result[sizeof(bool)], result.Size() - sizeof(bool));
+					}
+
+					owner->udp.Send(type, address, port, result, result.Size());
+
+					sent[i].lastResend = Math::Mod(sent[i].lastResend, owner->GetResendRate());
+				}
+			}
+		}
+
+		if (owner->GetDisposition() == EndDisp::SERVICE)
+		{
+			lastPing += delta;
+			if (lastPing >= 1.0f)
+				Ping(delta);
+		}
+
+		EHS_LOG_SUCCESS();
+	}
+
+	void NetEnd::SetStatus(const Status newStatus)
+	{
+		status = newStatus;
+	}
+
+	void NetEnd::RemoveInsurance(const UInt_64 msgId, const UInt_64 fragment)
+	{
+		for (UInt_64 i = 0; i < sent.Size(); ++i)
+		{
+			if (sent[i].header.id == msgId && sent[i].header.fragment == fragment)
+			{
+				sent.Remove(i);
+				break;
+			}
+		}
+
+		timeout = 0.0f;
+	}
+
+	void NetEnd::AddReceived(const Header& header, const Serializer<>& payload)
+	{
+		NetFrags* frags = nullptr;
+
+		for (UInt_64 i = 0; i < received.Size(); ++i)
+		{
+			if (received[i].GetHeader().id == header.id)
+			{
+				if (received[i][header.fragment].Size())
+					return;
+
+				frags = &received[i];
+				break;
+			}
+		}
+
+		if (header.id > nextRecvId)
+			nextRecvId = header.id + 1;
+
+		if (frags)
+			(*frags)[header.fragment] = payload;
+		else
+			received.Push({header, payload});
+
+		timeout = 0.0f;
+	}
+
+	Vector<NetFrags>* NetEnd::GetReceived()
+	{
+		return &received;
+	}
+
+	void NetEnd::SetDeltaRate(const float newDeltaRate)
+	{
+		deltaRate = newDeltaRate;
+	}
+
+	void NetEnd::Ping(const float delta)
+	{
+		Serializer payload(Endianness::LE);
+		payload.Write(delta);
+
+		Send(false, true, false, "Internal", "Ping", payload);
+		lastPing = 0.0f;
+		latency = 0.0f;
+	}
+
+	void NetEnd::Pong(const float delta)
+	{
+		Serializer payload(Endianness::LE);
+		payload.Write(delta);
+
+		Send(false, true, false, "Internal", "Pong", payload);
+
+		timeout = 0.0f;
+	}
+
+	void NetEnd::SendLatency()
+	{
+		oldLatency = latency * 1000;
+
+		Serializer sPayload(Endianness::LE);
+		sPayload.Write(oldLatency);
+
+		Send(false, true, false, "Internal", "Latency", sPayload);
+
+		latency = 0.0f;
+		timeout = 0.0f;
+	}
+
+	void NetEnd::SetLatency(const float newLatency)
+	{
+		oldLatency = newLatency;
+	}
+
+	void NetEnd::SetQueueSlot(const UInt_64 slot)
+	{
+		queueSlot = slot;
+	}
+
+	NetFrags NetEnd::FragmentData(const Header& header, const Serializer<>& data)
+	{
+		NetFrags result;
+
+		if (owner->GetLocalAddressType() == AddrType::IPV6)
+		{
+            UInt_64 frags = data.Size() / EHC_IPV6_PAYLOAD;
+            if (data.Size() % EHC_IPV6_PAYLOAD)
+                ++frags;
+
+			result = NetFrags(header, frags);
+
+			UInt_64 size = EHC_IPV6_PAYLOAD;
+
+			for (UInt_64 i = 0; i < result.Size(); ++i)
+			{
+				size = EHC_IPV6_PAYLOAD;
+				if (i == result.Size() - 1)
+					size = data.Size() % EHC_IPV6_PAYLOAD;
+
+				result[i] = {data.GetEndianness(), &data[i * EHC_IPV6_PAYLOAD], size};
+			}
+		}
+		else if (owner->GetLocalAddressType() == AddrType::IPV4)
+		{
+            UInt_64 frags = data.Size() / EHC_IPV4_PAYLOAD;
+            if (data.Size() % EHC_IPV4_PAYLOAD)
+                ++frags;
+
+			result = NetFrags(header, frags);
+
+			UInt_64 size = EHC_IPV4_PAYLOAD;
+
+			for (UInt_64 i = 0; i < result.Size(); ++i)
+			{
+				size = EHC_IPV4_PAYLOAD;
+				if (i == result.Size() - 1)
+					size = data.Size() % EHC_IPV4_PAYLOAD;
+
+				result[i] = {data.GetEndianness(), &data[i * EHC_IPV4_PAYLOAD], size};
+			}
+		}
+
+		return result;
+	}
+
+	void NetEnd::Send(const Header& header, const Serializer<UInt_64>& payload)
+	{
+		Serializer result(Endianness::LE);
+		result.Write(header);
+		result.WriteSer(payload);
+
+		if (header.encHashId)
+		{
+			NetEnc *enc = owner->GetEncryption(header.encHashId);
+			if (!enc)
+			{
+				EHS_LOG_INT(LogType::WARN, 0, "The network encryption with the hash id " +
+							Str_8::FromNum(header.encHashId) + ", does not exist.");
+
+				return;
+			}
+
+			enc->Encrypt(&result[sizeof(bool)], result.Size() - sizeof(bool));
+		}
+
+		if (header.ensure)
+			sent.Push({header, payload});
+
+		owner->udp.Send(type, address, port, result, result.Size());
+	}
+
+	bool NetEnd::SortingNeeded() const
+	{
+		UInt_64 lastPacket = 0;
+
+		for (UInt_64 i = 0; i < received.Size(); ++i)
+		{
+			if (received[i].GetHeader().id < lastPacket)
+				return true;
+			else
+				lastPacket = received[i].GetHeader().id;
+		}
+
+		return false;
+	}
+
+	void NetEnd::SortReceived()
+	{
+		if (!SortingNeeded())
+			return;
+
+		Vector<NetFrags> sorted(0, received.Stride());
+
+		for (UInt_64 a = 0; a < received.Size(); ++a)
+		{
+			if (sorted.Size())
+			{
+				for (UInt_64 b = sorted.Size(); b; --b)
+				{
+					if (received[a].GetHeader().id > sorted[b - 1].GetHeader().id)
+					{
+						if (b == sorted.Size())
+							sorted.Push(received[a]);
+						else
+							sorted.Insert(b, received[a]);
+
+						break;
+					}
+					else
+					{
+						sorted.Insert(b - 1, received[a]);
+
+						break;
+					}
+				}
+			}
+			else
+			{
+				sorted.Push(received[a]);
+			}
+		}
+
+		received = sorted;
+	}
+}

src/io/socket/ehc/NetFrags.cpp

@@ -0,0 +1,122 @@
+#include "ehs/io/socket/ehc/NetFrags.h"
+
+namespace ehs
+{
+	NetFrags::~NetFrags()
+	{
+		delete[] data;
+	}
+
+	NetFrags::NetFrags()
+		: data(nullptr), size(0)
+	{
+	}
+
+	NetFrags::NetFrags(const Header &header, const Serializer<UInt_64> &payload)
+		: header(header), data(new Serializer<UInt_64>[header.fragments]), size(header.fragments)
+	{
+        this->header.fragment = 0;
+		data[header.fragment] = payload;
+	}
+
+	NetFrags::NetFrags(const Header &header, const UInt_64 size)
+		: header(header), data(new Serializer<UInt_64>[size]), size(size)
+	{
+        this->header.fragments = size;
+        this->header.fragment = 0;
+	}
+
+	NetFrags::NetFrags(NetFrags &&frags) noexcept
+		: header(frags.header), data(frags.data), size(frags.size)
+	{
+		frags.header = {};
+		frags.data = nullptr;
+		frags.size = 0;
+	}
+
+	NetFrags::NetFrags(const NetFrags &frags)
+		: header(frags.header), data(new Serializer<UInt_64>[frags.size]), size(frags.size)
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			data[i] = frags.data[i];
+	}
+
+	NetFrags &NetFrags::operator=(NetFrags &&frags) noexcept
+	{
+		if (this == &frags)
+			return *this;
+
+		header = frags.header;
+
+		delete[] data;
+		data = frags.data;
+
+		size = frags.size;
+
+		frags.header = {};
+		frags.data = nullptr;
+		frags.size = 0;
+
+		return *this;
+	}
+
+	NetFrags &NetFrags::operator=(const NetFrags &frags)
+	{
+		if (this == &frags)
+			return *this;
+
+        header = frags.header;
+		delete[] data;
+		data = new Serializer<UInt_64>[frags.size];
+		for (UInt_64 i = 0; i < frags.size; ++i)
+			data[i] = frags.data[i];
+		size = frags.size;
+
+		return *this;
+	}
+
+	NetFrags::operator Serializer<UInt_64> *() const
+	{
+		return data;
+	}
+
+	Header NetFrags::GetHeader() const
+	{
+		return header;
+	}
+
+	UInt_64 NetFrags::Size() const
+	{
+		return size;
+	}
+
+	bool NetFrags::IsComplete() const
+	{
+		for (UInt_64 i = 0; i < size; ++i)
+			if (!data[i].Size())
+				return false;
+
+		return true;
+	}
+
+	Packet NetFrags::Combine() const
+	{
+        UInt_64 rSize = 0;
+        for (UInt_64 i = 0; i < size; ++i)
+            rSize += data[i].Size();
+
+		Packet result =
+		{
+		    header,
+            {Endianness::LE, rSize}
+		};
+		result.header.fragments = 0;
+
+        for (UInt_64 i = 0; i < size; ++i)
+            result.payload.WriteSer(data[i]);
+
+        result.payload.SetOffset(0);
+
+		return result;
+	}
+}

src/io/socket/ehc/NetOp.cpp

@@ -0,0 +1,66 @@
+#include "ehs/io/socket/ehc/NetOp.h"
+#include "ehs/io/socket/EHC.h"
+#include "ehs/io/socket/ehc/NetEnd.h"
+#include "ehs/io/socket/ehc/NetSys.h"
+
+namespace ehs
+{
+	NetOp::NetOp()
+		: hashId(0)
+	{
+	}
+
+	NetOp::NetOp(Str_8 id)
+		: hashId(id.Hash_64()), id((Str_8 &&)id)
+	{
+	}
+
+	NetOp::NetOp(NetOp&& op) noexcept
+		: hashId(op.hashId), id((Str_8 &&)op.id)
+	{
+		op.hashId = 0;
+	}
+
+	NetOp::NetOp(const NetOp &op)
+		: hashId(op.hashId), id(op.id)
+	{
+	}
+
+	NetOp& NetOp::operator=(NetOp&& op) noexcept
+	{
+		if (this == &op)
+			return *this;
+
+		hashId = op.hashId;
+		id = (Str_8 &&)op.id;
+
+		op.hashId = 0;
+
+		return *this;
+	}
+
+	NetOp &NetOp::operator=(const NetOp &op)
+	{
+		if (this == &op)
+			return *this;
+
+		hashId = op.hashId;
+		id = op.id;
+
+		return *this;
+	}
+
+	Str_8 NetOp::GetId() const
+	{
+		return id;
+	}
+
+	UInt_64 NetOp::GetHashId() const
+	{
+		return hashId;
+	}
+
+	void NetOp::Process(EHC *ehc, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload)
+	{
+	}
+}

src/io/socket/ehc/NetSys.cpp

@@ -0,0 +1,105 @@
+#include "ehs/io/socket/ehc/NetSys.h"
+#include "ehs/io/socket/EHC.h"
+#include "ehs/io/socket/ehc/NetEnd.h"
+#include "ehs/io/socket/ehc/NetOp.h"
+
+namespace ehs
+{
+	NetSys::~NetSys()
+	{
+		for (UInt_64 i = 0; i < ops.Size(); ++i)
+			delete ops[i];
+
+		ops.Clear();
+	}
+
+	NetSys::NetSys()
+		: hashId(0)
+	{
+	}
+
+	NetSys::NetSys(Str_8 id)
+		: hashId(id.Hash_64()), id((Str_8&&)id)
+	{
+	}
+
+	NetSys::NetSys(NetSys&& sys) noexcept
+		: hashId(sys.hashId), id((Str_8&&)sys.id), ops((Array<NetOp*>&&)sys.ops)
+	{
+		sys.hashId = 0;
+	}
+
+	NetSys::NetSys(const NetSys& sys)
+		: hashId(sys.hashId), id(sys.id)
+	{
+	}
+
+	NetSys& NetSys::operator=(NetSys&& sys) noexcept
+	{
+		if (this == &sys)
+			return *this;
+
+		hashId = sys.hashId;
+		id = (Str_8&&)sys.id;
+		ops = (Array<NetOp*>&&)sys.ops;
+
+		sys.hashId = 0;
+
+		return *this;
+	}
+
+	NetSys& NetSys::operator=(const NetSys& sys)
+	{
+		if (this == &sys)
+			return *this;
+
+		hashId = sys.hashId;
+		id = sys.id;
+		ops = Array<NetOp*>();
+
+		return *this;
+	}
+
+	Str_8 NetSys::GetId() const
+	{
+		return id;
+	}
+
+	UInt_64 NetSys::GetHashId() const
+	{
+		return hashId;
+	}
+
+	bool NetSys::HasOperation(const UInt_64 hashId) const
+	{
+		for (UInt_64 i = 0; i < ops.Size(); ++i)
+			if (ops[i]->GetHashId() == hashId)
+				return true;
+
+		return false;
+	}
+
+	bool NetSys::AddOperation(NetOp* op)
+	{
+		if (HasOperation(op->GetHashId()))
+			return false;
+
+		ops.Push(op);
+
+		return true;
+	}
+
+	void NetSys::Execute(EHC *ehc, NetEnd *endpoint, const UInt_64 hashId, Serializer<UInt_64> &payload)
+	{
+		for (UInt_64 i = 0; i < ops.Size(); ++i)
+		{
+			if (ops[i]->GetHashId() == hashId)
+			{
+				ops[i]->Process(ehc, endpoint, this, payload);
+				return;
+			}
+		}
+
+		EHS_LOG_INT(LogType::INFO, 0, "System not found.");
+	}
+}