diff --git a/SQCSim-common/netprotocol.cpp b/SQCSim-common/netprotocol.cpp
index 093b902..1053191 100644
--- a/SQCSim-common/netprotocol.cpp
+++ b/SQCSim-common/netprotocol.cpp
@@ -1,29 +1,29 @@
 #include "netprotocol.h"
 
 void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::INPUT;
+	*buf[0] = (char)netprot::PACKET_TYPE::INPUT;
 
 	uint64_t time = in->timestamp;
-	uint8_t time8[sizeof(uint64_t)] = {(time >> 56) & 0xFF,
-									   (time >> 48) & 0xFF,
-									   (time >> 40) & 0xFF,
-									   (time >> 32) & 0xFF,
-									   (time >> 24) & 0xFF,
-									   (time >> 16) & 0xFF,
-									   (time >> 8 ) & 0xFF,
-									    time		& 0xFF};
+	uint8_t time8[sizeof(uint64_t)] = {(uint8_t)((time >> 56) & 0xFF),
+									   (uint8_t)((time >> 48) & 0xFF),
+									   (uint8_t)((time >> 40) & 0xFF),
+									   (uint8_t)((time >> 32) & 0xFF),
+									   (uint8_t)((time >> 24) & 0xFF),
+									   (uint8_t)((time >> 16) & 0xFF),
+									   (uint8_t)((time >> 8 ) & 0xFF),
+									    (uint8_t)(time		  & 0xFF)};
 
 	memcpy(*buf + 1, time8, sizeof(uint64_t));
 
 	uint64_t sid = in->sid;
-	uint8_t sid8[sizeof(uint64_t)] = {(sid >> 56) & 0xFF,
-									  (sid >> 48) & 0xFF,
-									  (sid >> 40) & 0xFF,
-									  (sid >> 32) & 0xFF,
-									  (sid >> 24) & 0xFF,
-									  (sid >> 16) & 0xFF,
-									  (sid >> 8 ) & 0xFF,
-									   sid		  & 0xFF};
+	uint8_t sid8[sizeof(uint64_t)] = {(uint8_t)((sid >> 56) & 0xFF),
+									  (uint8_t)((sid >> 48) & 0xFF),
+									  (uint8_t)((sid >> 40) & 0xFF),
+									  (uint8_t)((sid >> 32) & 0xFF),
+									  (uint8_t)((sid >> 24) & 0xFF),
+									  (uint8_t)((sid >> 16) & 0xFF),
+									  (uint8_t)((sid >> 8 ) & 0xFF),
+									  (uint8_t)( sid		& 0xFF)};
 
 	memcpy(*buf + sizeof(uint64_t) + 1, sid8, sizeof(uint64_t));
 
@@ -40,21 +40,21 @@ void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
 	memcpy(*buf + sizeof(uint64_t) * 2 + 1, &keys8, sizeof(uint8_t));
 
 	uint32_t vec[3];
-	memcpy(vec, &in->direction, sizeof(Vector3f)); // Pour dénaturer les floats.
+	memcpy(vec, &in->direction, sizeof(Vector3f)); // Pour d�naturer les floats.
 
 	uint8_t vec8[3 * sizeof(uint32_t)] = {
-							(vec[0] >> 24) & 0xFF,
-							(vec[0] >> 16) & 0xFF,
-							(vec[0] >> 8) & 0xFF,
-							 vec[0] & 0xFF,
-						(vec[1] >> 24) & 0xFF,
-						(vec[1] >> 16) & 0xFF,
-						(vec[1] >> 8) & 0xFF,
-						 vec[1] & 0xFF,
-					(vec[2] >> 24) & 0xFF,
-					(vec[2] >> 16) & 0xFF,
-					(vec[2] >> 8) & 0xFF,
-					 vec[2] & 0xFF};
+							(uint8_t)((vec[0] >> 24) & 0xFF),
+							(uint8_t)((vec[0] >> 16) & 0xFF),
+							(uint8_t)((vec[0] >> 8) & 0xFF),
+							 (uint8_t)(vec[0] & 0xFF),
+						(uint8_t)((vec[1] >> 24) & 0xFF),
+						(uint8_t)((vec[1] >> 16) & 0xFF),
+						(uint8_t)((vec[1] >> 8) & 0xFF),
+						 (uint8_t)(vec[1] & 0xFF),
+					 (uint8_t)((vec[2] >> 24) & 0xFF),
+					 (uint8_t)((vec[2] >> 16) & 0xFF),
+					(uint8_t)((vec[2] >> 8) & 0xFF),
+					 (uint8_t)(vec[2] & 0xFF)};
 
 	memcpy(*buf + sizeof(uint64_t) * 2 + 2, vec8, sizeof(uint32_t) * 3);
 
@@ -62,33 +62,33 @@ void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(Output* out, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::OUTPUT;
+	*buf[0] = (char)netprot::PACKET_TYPE::OUTPUT;
 
 
 }
 
 void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::SYNC;
+	*buf[0] = (char)netprot::PACKET_TYPE::SYNC;
 
 
 }
 
 void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::TEAMINF;
+	*buf[0] = (char)netprot::PACKET_TYPE::TEAMINF;
 
 	size_t namesize = std::strlen(tinfo->name) + 1;
 
 	memcpy(*buf + 1, &tinfo->name, namesize);
 	uint64_t tid = tinfo->id;
 	uint8_t tid8[sizeof(uint64_t)] = {
-									   (tid >> 56) & 0xFF,
-									   (tid >> 48) & 0xFF,
-									   (tid >> 40) & 0xFF,
-									   (tid >> 32) & 0xFF,
-									   (tid >> 24) & 0xFF,
-									   (tid >> 16) & 0xFF,
-									   (tid >> 8) & 0xFF,
-									   tid & 0xFF
+									   (uint8_t)((tid >> 56) & 0xFF),
+									   (uint8_t)((tid >> 48) & 0xFF),
+									   (uint8_t)((tid >> 40) & 0xFF),
+									   (uint8_t)((tid >> 32) & 0xFF),
+									   (uint8_t)((tid >> 24) & 0xFF),
+									   (uint8_t)((tid >> 16) & 0xFF),
+									   (uint8_t)((tid >> 8)  & 0xFF),
+									    (uint8_t)(tid 		 & 0xFF)
 	};
 
 	memcpy(*buf + namesize + 2, tid8, sizeof(uint64_t));
@@ -97,35 +97,35 @@ void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::LOGINF;
+	*buf[0] = (char)netprot::PACKET_TYPE::LOGINF;
 
 	size_t namesize = std::strlen(linfo->name) + 1;
 	
 	memcpy(*buf + 1, &linfo->name, namesize);
 	uint64_t sid = linfo->sid;
 	uint8_t sid8[sizeof(uint64_t)] = { 
-									   (sid >> 56) & 0xFF,
-									   (sid >> 48) & 0xFF,
-									   (sid >> 40) & 0xFF,
-									   (sid >> 32) & 0xFF,
-									   (sid >> 24) & 0xFF,
-									   (sid >> 16) & 0xFF,
-									   (sid >> 8) & 0xFF,
-									   sid & 0xFF
+									   (uint8_t)((sid >> 56) & 0xFF),
+									   (uint8_t)((sid >> 48) & 0xFF),
+									   (uint8_t)((sid >> 40) & 0xFF),
+									   (uint8_t)((sid >> 32) & 0xFF),
+									   (uint8_t)((sid >> 24) & 0xFF),
+									   (uint8_t)((sid >> 16) & 0xFF),
+									   (uint8_t)((sid >> 8)  & 0xFF),
+									    (uint8_t)(sid 		 & 0xFF)
 	};
 
 	memcpy(*buf + namesize + 2, sid8, sizeof(uint64_t));
 
 	uint64_t tid = linfo->tid;
 	uint8_t tid8[sizeof(uint64_t)] = {
-									   (tid >> 56) & 0xFF,
-									   (tid >> 48) & 0xFF,
-									   (tid >> 40) & 0xFF,
-									   (tid >> 32) & 0xFF,
-									   (tid >> 24) & 0xFF,
-									   (tid >> 16) & 0xFF,
-									   (tid >> 8) & 0xFF,
-									   tid & 0xFF
+									   (uint8_t)((tid >> 56) & 0xFF),
+									   (uint8_t)((tid >> 48) & 0xFF),
+									   (uint8_t)((tid >> 40) & 0xFF),
+									   (uint8_t)((tid >> 32) & 0xFF),
+									   (uint8_t)((tid >> 24) & 0xFF),
+									   (uint8_t)((tid >> 16) & 0xFF),
+									   (uint8_t)((tid >> 8)  & 0xFF),
+									   (uint8_t)(tid 		 & 0xFF)
 	};
 
 	memcpy(*buf + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t));
@@ -134,35 +134,35 @@ void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::PLAYINF;
+	*buf[0] = (char)netprot::PACKET_TYPE::PLAYINF;
 
 	size_t namesize = std::strlen(pinfo->name) + 1;
 
 	memcpy(*buf + 1, &pinfo->name, namesize);
 	uint64_t id = pinfo->id;
 	uint8_t id8[sizeof(uint64_t)] = {
-									   (id >> 56) & 0xFF,
-									   (id >> 48) & 0xFF,
-									   (id >> 40) & 0xFF,
-									   (id >> 32) & 0xFF,
-									   (id >> 24) & 0xFF,
-									   (id >> 16) & 0xFF,
-									   (id >> 8) & 0xFF,
-									   id & 0xFF
+									   (uint8_t)((id >> 56) & 0xFF),
+									   (uint8_t)((id >> 48) & 0xFF),
+									   (uint8_t)((id >> 40) & 0xFF),
+									   (uint8_t)((id >> 32) & 0xFF),
+									   (uint8_t)((id >> 24) & 0xFF),
+									   (uint8_t)((id >> 16) & 0xFF),
+									   (uint8_t)((id >> 8)  & 0xFF),
+									    (uint8_t)(id 		& 0xFF)
 	};
 
 	memcpy(*buf + namesize + 2, id8, sizeof(uint64_t));
 
 	uint64_t tid = pinfo->tid;
 	uint8_t tid8[sizeof(uint64_t)] = {
-									   (tid >> 56) & 0xFF,
-									   (tid >> 48) & 0xFF,
-									   (tid >> 40) & 0xFF,
-									   (tid >> 32) & 0xFF,
-									   (tid >> 24) & 0xFF,
-									   (tid >> 16) & 0xFF,
-									   (tid >> 8) & 0xFF,
-									   tid & 0xFF 
+									   (uint8_t)((tid >> 56) & 0xFF),
+									   (uint8_t)((tid >> 48) & 0xFF),
+									   (uint8_t)((tid >> 40) & 0xFF),
+									   (uint8_t)((tid >> 32) & 0xFF),
+									   (uint8_t)((tid >> 24) & 0xFF),
+									   (uint8_t)((tid >> 16) & 0xFF),
+									   (uint8_t)((tid >> 8)  & 0xFF),
+									    (uint8_t)(tid 		 & 0xFF) 
 	};
 
 	memcpy(*buf + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t));
@@ -171,46 +171,46 @@ void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::GAMEINFO;
+	*buf[0] = (char)netprot::PACKET_TYPE::GAMEINFO;
 
 	uint64_t game = ginfo->seed;
 	uint8_t seed8[sizeof(uint64_t)] = {
-									   (game >> 56) & 0xFF,
-									   (game >> 48) & 0xFF,
-									   (game >> 40) & 0xFF,
-									   (game >> 32) & 0xFF,
-									   (game >> 24) & 0xFF,
-									   (game >> 16) & 0xFF,
-									   (game >> 8) & 0xFF,
-									   game & 0xFF
+									   (uint8_t)((game >> 56) & 0xFF),
+									   (uint8_t)((game >> 48) & 0xFF),
+									   (uint8_t)((game >> 40) & 0xFF),
+									   (uint8_t)((game >> 32) & 0xFF),
+									   (uint8_t)((game >> 24) & 0xFF),
+									   (uint8_t)((game >> 16) & 0xFF),
+									   (uint8_t)((game >> 8)  & 0xFF),
+									    (uint8_t)(game 		  & 0xFF)
 	};
 
 	memcpy(*buf + 1, seed8, sizeof(uint64_t));
 
 	game = ginfo->countdown;
 	uint8_t count8[sizeof(uint64_t)] = {
-									   (game >> 56) & 0xFF,
-									   (game >> 48) & 0xFF,
-									   (game >> 40) & 0xFF,
-									   (game >> 32) & 0xFF,
-									   (game >> 24) & 0xFF,
-									   (game >> 16) & 0xFF,
-									   (game >> 8) & 0xFF,
-									   game & 0xFF
+										(uint8_t)((game >> 56) & 0xFF),
+									    (uint8_t)((game >> 48) & 0xFF),
+									    (uint8_t)((game >> 40) & 0xFF),
+									    (uint8_t)((game >> 32) & 0xFF),
+									    (uint8_t)((game >> 24) & 0xFF),
+									    (uint8_t)((game >> 16) & 0xFF),
+										(uint8_t)((game >> 8)  & 0xFF),
+									     (uint8_t)(game 	   & 0xFF)
 	};
 
 	memcpy(*buf + sizeof(uint64_t) + 1, count8, sizeof(uint64_t));
 
 	game = ginfo->countdown;
 	uint8_t gtype8[sizeof(uint64_t)] = {
-									   (game >> 56) & 0xFF,
-									   (game >> 48) & 0xFF,
-									   (game >> 40) & 0xFF,
-									   (game >> 32) & 0xFF,
-									   (game >> 24) & 0xFF,
-									   (game >> 16) & 0xFF,
-									   (game >> 8) & 0xFF,
-									   game & 0xFF
+									     (uint8_t)((game >> 56) & 0xFF),
+									   (uint8_t)((game >> 48) & 0xFF),
+									   (uint8_t)((game >> 40) & 0xFF),
+									   (uint8_t)((game >> 32) & 0xFF),
+									   (uint8_t)((game >> 24) & 0xFF),
+									   (uint8_t)((game >> 16) & 0xFF),
+									   (uint8_t)((game >> 8)  & 0xFF),
+									    (uint8_t)(game 		  & 0xFF)
 	};
 
 	memcpy(*buf + sizeof(uint64_t) + 1, gtype8, sizeof(uint64_t));
@@ -219,46 +219,46 @@ void netprot::Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::CHAT;
+	*buf[0] = (char)netprot::PACKET_TYPE::CHAT;
 
 	uint64_t src = chat->src_id;
 	uint8_t src8[sizeof(uint64_t)] = {
-									   (src >> 56) & 0xFF,
-									   (src >> 48) & 0xFF,
-									   (src >> 40) & 0xFF,
-									   (src >> 32) & 0xFF,
-									   (src >> 24) & 0xFF,
-									   (src >> 16) & 0xFF,
-									   (src >> 8) & 0xFF,
-									   src & 0xFF
+									   (uint8_t)((src >> 56) & 0xFF),
+									   (uint8_t)((src >> 48) & 0xFF),
+									   (uint8_t)((src >> 40) & 0xFF),
+									   (uint8_t)((src >> 32) & 0xFF),
+									   (uint8_t)((src >> 24) & 0xFF),
+									   (uint8_t)((src >> 16) & 0xFF),
+									   (uint8_t)((src >> 8)  & 0xFF),
+									    (uint8_t)(src 		 & 0xFF)
 	};
 
 	memcpy(*buf + 1, src8, sizeof(uint64_t));
 
 	uint64_t dst = chat->dest_id;
 	uint8_t dst8[sizeof(uint64_t)] = {
-									   (dst >> 56) & 0xFF,
-									   (dst >> 48) & 0xFF,
-									   (dst >> 40) & 0xFF,
-									   (dst >> 32) & 0xFF,
-									   (dst >> 24) & 0xFF,
-									   (dst >> 16) & 0xFF,
-									   (dst >> 8) & 0xFF,
-									   dst & 0xFF
+									   (uint8_t)((dst >> 56) & 0xFF),
+									   (uint8_t)((dst >> 48) & 0xFF),
+									   (uint8_t)((dst >> 40) & 0xFF),
+									   (uint8_t)((dst >> 32) & 0xFF),
+									   (uint8_t)((dst >> 24) & 0xFF),
+									   (uint8_t)((dst >> 16) & 0xFF),
+									   (uint8_t)((dst >> 8)  & 0xFF),
+									    (uint8_t)(dst 		 & 0xFF)
 	};
 
 	memcpy(*buf + 1 + sizeof(uint64_t), dst8, sizeof(uint64_t));
 
 	uint64_t dstteam = chat->dest_id;
 	uint8_t dstt8[sizeof(uint64_t)] = {
-									   (dstteam >> 56) & 0xFF,
-									   (dstteam >> 48) & 0xFF,
-									   (dstteam >> 40) & 0xFF,
-									   (dstteam >> 32) & 0xFF,
-									   (dstteam >> 24) & 0xFF,
-									   (dstteam >> 16) & 0xFF,
-									   (dstteam >> 8) & 0xFF,
-									   dstteam & 0xFF
+									   (uint8_t)((dstteam >> 56) & 0xFF),
+									   (uint8_t)((dstteam >> 48) & 0xFF),
+									   (uint8_t)((dstteam >> 40) & 0xFF),
+									   (uint8_t)((dstteam >> 32) & 0xFF),
+									   (uint8_t)((dstteam >> 24) & 0xFF),
+									   (uint8_t)((dstteam >> 16) & 0xFF),
+									   (uint8_t)((dstteam >> 8)  & 0xFF),
+									    (uint8_t)(dstteam 		 & 0xFF)
 	};
 	
 	memcpy(*buf + 1 + sizeof(uint64_t) * 2, dstt8, sizeof(uint64_t));
@@ -271,7 +271,7 @@ void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) {
 }
 
 void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
-	*buf[0] = netprot::PACKET_TYPE::ERRLOG;
+	*buf[0] = (char)netprot::PACKET_TYPE::ERRLOG;
 
 	size_t messize = std::strlen(errlog->mess) + 1;
 
@@ -313,13 +313,13 @@ bool netprot::Deserialize(Input* in, char* buf, const uint32_t buflen) {
 
 	uint8_t keys = 0;
 	memcpy(&keys, &buf[1 + sizeof(uint64_t) * 2], sizeof(uint8_t));
-	in->keys.forward	= keys && 0b10000000;
-	in->keys.backward	= keys && 0b01000000;
-	in->keys.left		= keys && 0b00100000;
-	in->keys.right		= keys && 0b00010000;
-	in->keys.jump		= keys && 0b00001000;
-	in->keys.shoot		= keys && 0b00000100;
-	in->keys.block		= keys && 0b00000010;
+	in->keys.forward	= keys & 0b10000000;
+	in->keys.backward	= keys & 0b01000000;
+	in->keys.left		= keys & 0b00100000;
+	in->keys.right		= keys & 0b00010000;
+	in->keys.jump		= keys & 0b00001000;
+	in->keys.shoot		= keys & 0b00000100;
+	in->keys.block		= keys & 0b00000010;
 
 	uint8_t subvec[3 * sizeof(uint32_t)] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
 	memcpy(subvec, &buf[2 + sizeof(uint64_t) * 2], sizeof(uint8_t) * 12);
@@ -555,12 +555,12 @@ bool netprot::Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen) {
 	return true;
 }
 
-netprot::PacketType netprot::getType(char* buf, const uint32_t buflen) {
+netprot::PACKET_TYPE netprot::getType(char* buf, const uint32_t buflen) {
 	if (buflen < 1 || 
-		buf[0] >= netprot::PACKET_TYPE::LAST_PACK || 
-		buf[0] <= netprot::PACKET_TYPE::ERR)
+		buf[0] >= (char)netprot::PACKET_TYPE::LAST_PACK || 
+		buf[0] <= (char)netprot::PACKET_TYPE::ERR)
 		return netprot::PACKET_TYPE::ERR;
-	return buf[0];
+	return (netprot::PACKET_TYPE)buf[0];
 }
 
 netprot::Packet netprot::getPack(char* buf, uint32_t buflen) {
@@ -629,6 +629,10 @@ netprot::Packet netprot::getPack(char* buf, uint32_t buflen) {
 	return pck;
 }
 
+netprot::Packet netprot::getPack(netprot::Buffer* buf) { 
+	return netprot::getPack(buf->ptr, buf->len); 
+}
+
 bool netprot::emptyPack(netprot::Packet pck) {
 	switch (pck.type) {
 	case PACKET_TYPE::INPUT:
diff --git a/SQCSim-common/netprotocol.h b/SQCSim-common/netprotocol.h
index 97c880b..23e9c4a 100644
--- a/SQCSim-common/netprotocol.h
+++ b/SQCSim-common/netprotocol.h
@@ -1,26 +1,33 @@
 #ifndef NETPROTOCOL_H__
 #define NETPROTOCOL_H__
 
-#include "define.h"
 #include <string>
+#include "define.h"
 #include "vector3.h"
 
-/* Protocole Particulier de Partie à Plusieurs Personnes (PPPPP) */
+/* Protocole Particulier de Partie a Plusieurs Personnes (PPPPP) */
 
 // Packet: packet[0] = PacketType, packet[1..n-1] = {packet}
 
 namespace netprot {
-	typedef uint8_t PacketType;
-	enum PACKET_TYPE {
+	enum class PACKET_TYPE: uint8_t {
 				ERR, INPUT, OUTPUT, SYNC,
 				TEAMINF, SELFINF, PLAYINF, LOGINF,
 				CHUNKMOD, PLAYERMOD, PICKUPMOD,
 				GAMEINFO, ENDINFO , CHAT, ERRLOG,
 				LAST_PACK
 			};
+	
+	struct Buffer { // Pour pouvoir rendre l'utilisation des buffers plus clean.
+		char* ptr = new char[BUFFER_LENGTH];
+		int32_t len = BUFFER_LENGTH;
 
-	struct Packet {
-		void* ptr = nullptr;
+		~Buffer() { delete[] ptr; }
+		void rstLen() { len = BUFFER_LENGTH; }
+	};
+
+	struct Packet { // Pour pouvoir recevoir les paquets du recv() sans avoir à les aiguiller dans la même thread.
+		void* ptr = nullptr; // Notez que le pointeur doit être supprimé séparément lorsqu'il n'est plus utile.
 		PACKET_TYPE type;
 	};
 
@@ -120,14 +127,19 @@ namespace netprot {
 	bool Deserialize(Chat* chat, char* buf, const uint32_t buflen); // srv/cli
 	bool Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen); // srv
 
-	PacketType getType(char* buf, uint32_t buflen);
+	PACKET_TYPE getType(char* buf, uint32_t buflen);
 
 	Packet getPack(char* buf, uint32_t buflen);
+	Packet getPack(Buffer* buf);
+
 	bool emptyPack(Packet pck);
 
 	template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
 	template <class T> void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad);
 
+	template <class T> void sendPack(SOCKET sock, T* pack, Buffer* buf);
+	template <class T> void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad);
+
 	template <class T>
 	void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
 		netprot::Serialize(pack, buf, buflen);
@@ -143,6 +155,19 @@ namespace netprot {
 		*buflen = BUFFER_LENGTH;
 	}
 
-};
+	template <class T>
+	void sendPack(SOCKET sock, T* pack, Buffer* buf) {
+		netprot::Serialize(pack, buf->ptr, buf->len);
+		send(sock, buf->ptr, buf->len, 0);
+		buf->rstLen();
+	}
 
+	template <class T>
+	void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad) {
+		sockaddr_in addr = *sockad;
+		netprot::Serialize(pack, buf->ptr, buf->len);
+		sendto(sock, buf->ptr, buf->len, 0, (sockaddr*)&addr, sizeof(addr));
+		buf->rstLen();
+	}
+};
 #endif
diff --git a/SQCSim-srv/server.cpp b/SQCSim-srv/server.cpp
index 600752a..90cce82 100644
--- a/SQCSim-srv/server.cpp
+++ b/SQCSim-srv/server.cpp
@@ -75,21 +75,20 @@ int Server::Ready() {
 	uint32_t buflen = BUFFER_LENGTH,
 			 strbuflen = BUFFER_LENGTH;
 	bool readystart = false;
-
 	do {
-		Log("Entrez la dur�e de la partie: ", false, false);
-		std::cin >> m_game.countdown;
-		std::cout << std::endl;
+		Log("Entrez la duree de la partie: ", false, false);
+		std::cin.getline(strbuf, BUFFER_LENGTH);
+		m_game.countdown = std::stoi(strbuf);
 	} while (m_game.countdown < 1);
 	do {
 		Log("Entrez le seed de la partie: ", false, false);
-		std::cin >> m_game.seed;
-		std::cout << std::endl;
+		std::cin.getline(strbuf, BUFFER_LENGTH);
+		m_game.seed = std::stoi(strbuf);
 	} while (m_game.seed < 1);
 	do {
 		Log("Entrez le nombre de joueurs: ", false, false);
-		std::cin >> nbrjoueurs;
-		std::cout << std::endl;
+		std::cin.getline(strbuf, BUFFER_LENGTH);
+		nbrjoueurs = std::stoi(strbuf);
 	} while (nbrjoueurs > 0 && nbrjoueurs >= MAX_CONNECTIONS);
 
 	m_game.gameType = 1;
@@ -128,7 +127,7 @@ int Server::Ready() {
 				log = (LoginInfo*)pck.ptr;
 
 				log->sid = getUniqueId();
-				log->tid = 0;
+				log->tid = 0; // TODO: À changer si on implemente un mode en equipe.
 
 				Log(str.append(" Nom: ").append(log->name), false, false);
 				str.clear();
@@ -154,8 +153,6 @@ int Server::Ready() {
 
 				m_players[log->sid] = conn;
 
-				delete log; // le pck va se supprimer tout seul, mais le pointer du log qui vient de lui, non.
-
 				if (++nbrconn >= nbrjoueurs)
 					readystart = true;
 			}