ajouts dans les cmakelists pour leenuqs

SQCSim-common/define.h

@@ -76,6 +76,7 @@ typedef uint64_t Timestamp;
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <cstring>
+#include <poll.h>
 
 #define flag_t unsigned int
 #define addrlen_t unsigned int

SQCSim-common/netprotocol.cpp

@@ -29,13 +29,13 @@ void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
 
 	Keys keys = in->keys;
 	uint8_t keys8 = // Reste un bit.
-		keys.forward & 0b10000000 |
+		(keys.forward? 0b10000000: 0) |
-		keys.backward & 0b01000000 |
+		(keys.backward? 0b01000000: 0) |
-		keys.left & 0b00100000 |
+		(keys.left? 0b00100000: 0) |
-		keys.right & 0b00010000 |
+		(keys.right? 0b00010000: 0) |
-		keys.jump & 0b00001000 |
+		(keys.jump? 0b00001000: 0) |
-		keys.shoot & 0b00000100 |
+		(keys.shoot? 0b00000100: 0) |
-		keys.block & 0b00000010;
+		(keys.block? 0b00000010: 0);
 
 	memcpy(*buf + sizeof(uint64_t) * 2 + 1, &keys8, sizeof(uint8_t));
 
@@ -90,14 +90,14 @@ void netprot::Serialize(Output* out, char* buf[], uint32_t* buflen) {
 
 	States states = out->states;
 	uint8_t states8 =
-		states.jumping & 0b10000000 |
+		(states.jumping? 0b10000000: 0) |
-		states.shooting & 0b01000000 |
+		(states.shooting? 0b01000000: 0) |
-		states.hit & 0b00100000 |
+		(states.hit? 0b00100000: 0) |
-		states.powerup & 0b00010000 |
+		(states.powerup? 0b00010000: 0) |
-		states.dead & 0b00001000 |
+		(states.dead? 0b00001000: 0) |
-		states.still & 0b00000100 |
+		(states.still? 0b00000100: 0) |
-		states.jumpshot & 0b00000010 |
+		(states.jumpshot? 0b00000010: 0) |
-		states.running & 0b00000001;
+		(states.running? 0b00000001: 0);
 
 	memcpy(*buf + sizeof(uint64_t) * 2 + 1, &states8, sizeof(uint8_t));
 

SQCSim-common/player.cpp

@@ -14,17 +14,6 @@ void Player::TurnLeftRight(float value) {
 	m_rotY += value;
 	if (m_rotY > 360) m_rotY = 0;
 	else if (m_rotY < -360) m_rotY = 0;
-}
-
-void Player::TurnTopBottom(float value) {
-	m_rotX += value;
-	if (m_rotX > 80) m_rotX = 80;
-	else if (m_rotX < -80) m_rotX = -80;
-}
-
-Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
-
-	Vector3f delta = Vector3f(0, 0, 0);
 
 	float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
 	float xrotrad = (m_rotX / 57.2957795056f);
@@ -34,23 +23,44 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
 		cos(xrotrad) * -cos(yrotrad));
 
 	m_direction.Normalize();
+}
+
+void Player::TurnTopBottom(float value) {
+	m_rotX += value;
+	if (m_rotX > 80) m_rotX = 80;
+	else if (m_rotX < -80) m_rotX = -80;
+
+	float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
+	float xrotrad = (m_rotX / 57.2957795056f);
+
+	m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
+		-sin(xrotrad),
+		cos(xrotrad) * -cos(yrotrad));
+
+	m_direction.Normalize();
+}
+
+Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
+	Vector3f delta = Vector3f(0, 0, 0);
+
+	Vector3f dir = m_direction;
+
+	dir.y = 0;
 
 	if (front) {
-		delta.x += float(sin(yrotrad)) * elapsedTime * 10.f;
+		delta += dir;
-		delta.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
 	}
 	else if (back) {
-		delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
+		delta -= dir;
-		delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
 	}
 
 	if (left) {
-		delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
+		delta.x += dir.z;
-		delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
+		delta.z += -dir.x;
 	}
 	else if (right) {
-		delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
+		delta.x -= dir.z;
-		delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
+		delta.z -= -dir.x;
 	}
 
 	delta.Normalize();
@@ -246,6 +256,8 @@ void Player::RemoveBooster(float elapsedtime)
 }
 void Player::SetDirection(Vector3f dir) { m_direction = dir; }
 
+void Player::Move(Vector3f diff) { m_position -= diff; }
+
 Vector3f Player::GetPosition() const { return Vector3f(m_position.x + CHUNK_SIZE_X * WORLD_SIZE_X / 2, m_position.y, m_position.z + CHUNK_SIZE_Z * WORLD_SIZE_Y / 2); }
 
 Vector3f Player::GetPositionAbs() const { return m_position; }

SQCSim-common/player.h

@@ -25,6 +25,7 @@ public:
 	void ApplyTransformation(Transformation& transformation, bool rel = true, bool rot = true) const;
 
 	void SetDirection(Vector3f dir);
+	void Move(Vector3f diff);
 	Vector3f GetPosition() const;
 	Vector3f GetPositionAbs() const;
 	Vector3f GetDirection() const;

SQCSim-srv/connection.cpp

@@ -21,7 +21,7 @@ uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
 
 std::string Connection::GetName() const { return m_loginfo.name; }
 
-void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); }
+void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); m_input_vector.push_back(in); }
 
 Output* Connection::getOutput(Timestamp time) {
 	auto out = m_output_manifest.find(time);
@@ -50,33 +50,62 @@ sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
 void Connection::getPacks(SOCKET sock) {
 	std::vector<char*> lsPck;
 	Input in;
-	while (true) {
+	Sync sync;
 		lsPck = recvPacksFrom(sock, &m_buf, m_addr);
-
 		for (auto& pck : lsPck) {
 			uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
 			switch (netprot::getType(pck, 1)) {
 				using enum netprot::PACKET_TYPE;
 			case INPUT:
-				if (Deserialize(&in, pck, &bsize))
+				if (Deserialize(&in, pck, &bsize)) {
 					m_input_manifest[in.timestamp] = in;
+					m_input_vector.push_back(in);
+				}
+				break;
+			case SYNC:
+				if (Deserialize(&sync, pck, &bsize))
+					m_nsync = true;
 				break;
 			default: break;
 			}
 		}
 		lsPck.clear();
 }
-}
-
-void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns) {
-	while (m_last_out < m_output_manifest.size()) {
-		Output out = m_output_manifest.at(m_last_out++);
 
+void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer) {
+	static int outs = 0;
+	static Timestamp last = 0;
+	while (!m_output_vector.empty()) {
+		Output out = m_output_vector.front();
 		for (auto& [key, conn] : conns) {
-			if (m_playinfo.id == conn->GetHash(true))
+			if (m_playinfo.id == conn->GetHash(false))
 				continue;
+			//std::cout << m_playinfo.id << ": " << m_playinfo.name << ": " << conn->GetName() << std::endl;
+			//std::cout << out.id << ": " << out.position << std::endl;
+
 			sendPackTo<Output>(sock, &out, &m_bufout, conn->getAddr());
 		}
+		++outs;
+
+		[[unlikely]] if (last == 0) // !
+			last = out.timestamp;
+
+		outs += out.timestamp + last;
+
+		if (outs >= 1000) {
+			outs -= 1000;
+			Sync sync;
+			sync.hp = player.get()->GetHP();
+			sync.timestamp = out.timestamp;
+			sync.position = out.position;
+			sync.sid = m_loginfo.sid;
+			sync.timer = timer;
+			sync.timestamp = out.timestamp;
+			sync.ammo = -1;
+			sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
+		}
+
+		m_output_vector.pop_front();
 	}
 }
 
@@ -88,12 +117,14 @@ void Connection::Run(World* world) {
 	if (m_input_manifest.size() < 2)
 		return;
 
-	while (m_last_in < m_input_manifest.size()) {
+	while (m_last_in < m_input_vector.size() - 1) {
-		in = m_input_manifest.at(m_last_in + 1);
+		in = m_input_vector.at(m_last_in + 1);
-		last = m_input_manifest.at(m_last_in);
+		last = m_input_vector.at(m_last_in);
 
-		el = (float)(in.timestamp - last.timestamp) / 1000.;
+		el = (double)(in.timestamp - last.timestamp) / 1000.;
+		std::cout << 1. / el << std::endl;
 		player.get()->SetDirection(in.direction);
+		std::cout << in.direction << std::endl;
 		player.get()->ApplyPhysics(player.get()->GetInput(in.keys.forward, 
 														  in.keys.backward, 
 														  in.keys.left, 
@@ -101,19 +132,21 @@ void Connection::Run(World* world) {
 														  in.keys.jump, false, el), world, el);
 
 		out.position = player.get()->GetPositionAbs();
+		player.get()->GetPositionAbs().Afficher();
 		out.direction = in.direction;
 		out.timestamp = in.timestamp;
 		out.id = m_playinfo.id;
 
 		m_output_manifest[out.timestamp] = out;
+		m_output_vector.push_back(out);
 		
 		++m_last_in;
 	}
 }
 
 void Connection::CleanInputManifest(Timestamp time) {
-	auto wat = m_input_manifest.find(time);
+//	auto wat = m_input_manifest.find(time);
 
-	while (wat != m_input_manifest.begin())
+//	while (wat != m_input_manifest.begin())
-		m_input_manifest.erase(wat--);
+//		m_input_manifest.erase(wat--);
 }

SQCSim-srv/connection.h

@@ -34,14 +34,18 @@ public:
 	sockaddr_in* getAddr() const;
 
 	void getPacks(SOCKET sock);
-	void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns);
+	void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer);
 
 	void Run(World* world);
 
 	void CleanInputManifest(Timestamp time);
+	
+	bool m_nsync = true;
 private:
 	std::unordered_map<Timestamp, Input> m_input_manifest;
+	std::vector<Input> m_input_vector;
 	std::unordered_map<Timestamp, Output> m_output_manifest;
+	std::deque<Output> m_output_vector;
 	std::unordered_map<Timestamp, Chat> m_chatlog;
 
 	SOCKET m_sock;

SQCSim-srv/server.cpp

@@ -21,6 +21,7 @@ Server::~Server() {
 	for (const auto& [key, player] : m_players)
 			closesocket(player->getSock());
 	m_players.clear();
+	delete m_world;
 #ifdef _WIN32
 	WSACleanup();
 #endif
@@ -85,7 +86,7 @@ int Server::Ready() {
 		Log("Entrez le seed de la partie: ", false, false);
 		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
 		try {	
-			m_game.seed = std::stoi(m_buf.ptr);
+			m_game.seed = 9370707;//std::stoi(m_buf.ptr);
 		} catch(const std::exception& e) {
 			Log(e.what(), true, false);
 			m_game.seed = 0;
@@ -145,24 +146,23 @@ int Server::Ready() {
 				Log(str.append(" Nom: ").append(log->name), false, false);
 				str.clear();
 					
-				Log(str.append(log->name).append(" SID: [").append(std::to_string(log->sid).append("]")), false, false);
 
-				sendPack<LoginInfo>(sock, log, &m_buf);
+				sendPackTo<LoginInfo>(m_sock_udp, log, &m_buf, &sockad);
 				
 				play.id = getUniqueId();
+				play.tid = log->tid;
 				strcpy(play.name, log->name);
 
+				Log(str.append(play.name).append(" SID: [").append(std::to_string(log->sid)).append("]")
+										 .append(" ID: [").append(std::to_string(play.id)).append("]")
+									     .append(" TID: [").append(std::to_string(play.tid)).append("]"), false, false);
 				play.tid = log->tid;
 
-				sendPack<GameInfo>(sock, &m_game, &m_buf);
+				sendPackTo<GameInfo>(m_sock_udp, &m_game, &m_buf, &sockad);
+				std::cout << m_game.seed << std::endl;
 				Connection* conn = new Connection(sock, sockad, *log, play);
 
-				for (auto& [key, player] : m_players) {
+				m_players[log->sid] = conn;
-					sendPack<PlayerInfo>(player->getSock(), &play, &m_buf); // Envoyer les infos de joueur distant aux joueurs d<>j<EFBFBD> connect<63>s		
-					sendPack<PlayerInfo>(sock, player->getInfo(), &m_buf); // et envoyer les infos des joueurs distants au nouveau joueur.
-				}
-
-				m_players[log->sid] = std::move(conn);
 
 				delete log;
 
@@ -171,6 +171,13 @@ int Server::Ready() {
 			}
 		}
 	}
+	for (auto& [keyin, playin] : m_players) // Not pretty, but it works.
+		for (auto& [keyout, playout] : m_players) {
+			if (keyin == keyout)
+				continue;	
+			sendPackTo<PlayerInfo>(m_sock_udp, playout->getInfo(), &m_buf, playin->getAddr()); // et envoyer les infos des joueurs distants au nouveau joueur.
+		}
+
 	return 0;
 }
 
@@ -190,53 +197,77 @@ void Server::Run() {
 	m_world->BuildWorld();
 
 	for (auto& [key, conn] : m_players) { // Creation des instances de joueurs et premier sync.
-		conn->player = std::make_unique<Player>(Vector3f(8.5f, CHUNK_SIZE_Y + 1.8f, 8.5f));
+		int x = rand() % (CHUNK_SIZE_X + WORLD_SIZE_X - 1), y = rand() % (CHUNK_SIZE_Y + WORLD_SIZE_Y - 1);
+		conn->player = std::make_unique<Player>(Vector3f(x + .5f, CHUNK_SIZE_Y + 1.8f, y + .5f));
 		Sync sync;
-		sync.position = conn->player->GetPosition();
+		sync.position = conn->player->GetPositionAbs();
 		sync.hp = conn->player->GetHP();
 		sync.sid = key;
 		sync.ammo = 0;
 		sync.timestamp = 0;
 		sync.timer = m_game.countdown;
-		sendPack<Sync>(conn->getSock(), &sync, &m_buf);
+		sendPackTo<Sync>(m_sock_udp, &sync, &m_buf, conn->getAddr());
-	}
+
+		int timer = m_game.countdown, sync_acc = 0;
+		std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
+		Timestamp last = 0;
 
 		while (!endgame) {
+			using namespace std::chrono;
+			Timestamp tstamp = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();
+
+			if (last == 0)
+				last = tstamp;
+			sync_acc += tstamp - last;
+			if (sync_acc >= 1000) {
+				sync_acc -= 1000;
+				--timer;
+			}
+
 			for (auto& [key, conn] : m_players) {
-			conn->getPacks(m_sock_udp);
+				int deadplayers = 0;
+				std::vector<char*> lsPck;
+				Input in;
+				Sync sync;
+				lsPck = recvPacks(m_sock_udp, &m_buf);
+				for (auto& pck : lsPck) {
+					uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
+					switch (netprot::getType(pck, 1)) {
+						using enum netprot::PACKET_TYPE;
+					case INPUT:
+						if (Deserialize(&in, pck, &bsize)) {
+							m_players[in.sid]->AddInput(in);
+						}
+						break;
+					case SYNC:
+						if (Deserialize(&sync, pck, &bsize)) {}
+						break;
+					case CHAT:
+						// TODO: Pitcher les chats à tous le monde.
+						break;
+					default: break;
+					}
+				}
+				lsPck.clear();
+
+				if (conn->m_nsync) {
+					if (conn->player->AmIDead()) {
+						++deadplayers;
+						continue;
+					}
 					conn->Run(m_world);
-			conn->sendPacks(m_sock_udp, m_players);
+					conn->sendPacks(m_sock_udp, m_players, timer);
+				}
+
+				if (deadplayers == players - 1 || timer <= 0)
+					endgame = true;
 			}
 		}
 
-	//while (true) {
+		// TODO: Gérer les 2-3 secondes post-game avant le billboard pour pas avoir un whiplash à la fin de la game.
-	//	if (recvfrom(m_sock_udp, m_buf.ptr, m_buf.len, 0, (sockaddr*)&sockad, &socklen) > 0) {
-	//		Packet pck = getPack(&m_buf);
-	//		switch (pck.type) {
-	//			using enum netprot::PACKET_TYPE;
- //           	case ERR:			std::puts("ERROR!");		break;
- //               case INPUT:			std::puts("INPUT!");		break;
- //               case OUTPUT:		std::puts("OUTPUT!");		break;
-	//			case SYNC:			std::puts("SYNC!");			break;
- //               case TEAMINF:		std::puts("TEAMINF!");		break;
- //               case SELFINF:		std::puts("SELFINF!");		break;
- //               case PLAYINF:		std::puts("PLAYINF!");		break;
- //               case LOGINF:		std::puts("LOGINF!");		break;
- //               case CHUNKMOD:		std::puts("CHUNKMOD!");		break;
- //               case PLAYERMOD:		std::puts("PLAYERMOD!");	break;
- //               case PICKUPMOD:		std::puts("PICKUPMOD!");	break;
- //               case GAMEINFO:		std::puts("GAMEINFO!");		break;
- //               case ENDINFO:		std::puts("ENDINFO!");		break;
- //               case CHAT:			std::puts("CHAT!");			break;
- //               case ERRLOG:		std::puts("ERRLOG!");		break;
-	//			case LAST_PACK:									[[falltrough]];
-	//			default:			std::puts("wtf?!");			break;
- //           }
-	//		netprot::emptyPack(pck);
- //       }
-	//}
 
 	}
+}
 
 inline std::string Server::LogTimestamp() {
 	time_t rawtime;
@@ -279,6 +310,7 @@ void Server::Log(std::string str, bool is_error = false, bool is_fatal = false)
 		for (const auto& [key, player] : m_players) {
 			closesocket(player->getSock());
 		}
+		delete m_world;
 		m_players.clear();
 #ifdef _WIN32
 		WSACleanup();

SQCSim2021/booster.cpp

@@ -1,4 +1,4 @@
-#include "booster.h";
+#include "booster.h"
 
 void Booster::RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas,  Shader& shader, Transformation tran)
 {

SQCSim2021/cmake/CMakeLists.txt

@@ -28,6 +28,7 @@ include_directories(
 
 
 add_library(SQCSim-common
+			"${SQCSIM_COMMON_DIR}boostinfo.cpp"
 			"${SQCSIM_COMMON_DIR}blockinfo.cpp"
 			"${SQCSIM_COMMON_DIR}bullet.cpp"
 			"${SQCSIM_COMMON_DIR}chunk.cpp"
@@ -40,6 +41,7 @@ add_library(SQCSim-common
 
 add_executable(SQCSim-client
 			"../audio.cpp"
+			"../booster.cpp"
 			"../connector.cpp"
 			"../engine.cpp"
 			"../mesh.cpp"

SQCSim2021/connector.cpp

@@ -78,7 +78,7 @@ int Connector::Connect(const char* srv_addr, std::string name) {
 	int errors = 0;
 	std::vector<char*> lsPck;
 	while (!ready) {
-		lsPck = netprot::recvPacks(m_sock_tcp, &bf);
+		lsPck = netprot::recvPacks(m_sock_udp, &bf);
 
 		for (auto& pck : lsPck) {
 			uint32_t bsize = bf.len - (pck - bf.ptr);
@@ -97,7 +97,9 @@ int Connector::Connect(const char* srv_addr, std::string name) {
 				pl = new netprot::PlayerInfo();
 				if (!netprot::Deserialize(pl, pck, &bsize))
 					++errors;
-				else m_players[pl->id] = pl;
+				else {
+					m_players[pl->id] = pl;
+				}
 				break;
 			case TEAMINF:
 				// TODO: Faire dequoi avec TeamInfo si on fini par avoir des teams.

SQCSim2021/engine.cpp

@@ -319,33 +319,8 @@ void Engine::DrawPause()
 
 void Engine::Init() {
 
-	GLenum glewErr = glewInit();
-	if (glewErr != GLEW_OK) {
-		std::cerr << " ERREUR GLEW : " << glewGetErrorString(glewErr) << std::endl;
-		abort();
-	}
-
 	uint64_t seed = SEED;
 
-	glDisable(GL_FRAMEBUFFER_SRGB);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_STENCIL_TEST);
-	glEnable(GL_POINT_SMOOTH);
-	glEnable(GL_BLEND);
-	//glEnable(GL_CULL_FACE);
-	glEnable(GL_TEXTURE_2D);
-
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-
-	gluPerspective(45.0f, (float)Width() / (float)Height(), 0.1f, VIEW_DISTANCE);
-	glShadeModel(GL_SMOOTH);
-
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-	glDisable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glBlendEquation(GL_FUNC_SUBTRACT);
-
 	if (m_istarted)
 		return;
 	else m_istarted = true;
@@ -363,6 +338,9 @@ void Engine::Init() {
 		m_whoosh[x] = nullptr;
 	}
 
+	// Init Chunks
+	m_world.GetChunks().Reset(nullptr);
+
 	char* ch = new char[2];
 
 	std::cout << "Jouer en ligne? [o/N] ";
@@ -395,13 +373,16 @@ void Engine::Init() {
 			if (!m_conn.Connect(srvname.c_str(), playname)) {
 				// setup jeu en reseau.
 				std::cout << "ID recu du serveur: " << std::to_string(m_conn.getId()) << "!" << std::endl;
-				std::cout << "Seed recu du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl;
+				//std::cout << "Seed recu du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl;
 				m_player = Player(m_conn.getOrigin().position);
 
-				for (auto& [key, player] : m_conn.m_players)
+				for (auto& [key, player] : m_conn.m_players) {
 					m_players[key] = new RemotePlayer(player);
+					RemotePlayer* rt = (RemotePlayer*)m_players[key];
+					rt->SetPosition(Vector3f(555, 555, 555));
+				}
 
-				seed = m_conn.getSeed();
+				seed = 9370707;//m_conn.getSeed();
 				m_networkgame = true;
 			}
 			else std::cout << "Erreur de connexion." << std::endl;
@@ -412,12 +393,8 @@ void Engine::Init() {
 
 	m_world.SetSeed(seed);
 
-	// Init Chunks
-	m_world.GetChunks().Reset(nullptr);
-
 	m_startTime = std::chrono::high_resolution_clock::now();
 
-	m_remotePlayer.SetPosition(Vector3f(.5,CHUNK_SIZE_Y + 10., .5));
 	// Gestion de souris.
 	CenterMouse();
 	HideCursor();
@@ -426,6 +403,31 @@ void Engine::Init() {
 void Engine::DeInit() {}
 
 void Engine::LoadResource() {
+	GLenum glewErr = glewInit();
+	if (glewErr != GLEW_OK) {
+		std::cerr << " ERREUR GLEW : " << glewGetErrorString(glewErr) << std::endl;
+		abort();
+	}
+
+	glDisable(GL_FRAMEBUFFER_SRGB);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_STENCIL_TEST);
+	glEnable(GL_POINT_SMOOTH);
+	glEnable(GL_BLEND);
+	glEnable(GL_CULL_FACE);
+	glEnable(GL_TEXTURE_2D);
+
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+
+	gluPerspective(45.0f, (float)Width() / (float)Height(), 0.1f, VIEW_DISTANCE);
+	glShadeModel(GL_SMOOTH);
+
+	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+	glDisable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendEquation(GL_FUNC_SUBTRACT);
+
 	LoadTexture(m_skybox.GetTexture(), TEXTURE_PATH "skybox.png", true);
 	//LoadTexture(m_skybox2.GetTexture(), TEXTURE_PATH "skybox.png", true);
 	LoadTexture(m_textureCrosshair, TEXTURE_PATH "cross.bmp", true);
@@ -736,6 +738,7 @@ void Engine::DisplayHud(int timer) {
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glLoadIdentity();
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glClear(GL_STENCIL_BUFFER_BIT);
 
 	float itemBackgroundWidthProportion = 0.25f;
 	float itemBackgroundHeightProportion = 0.175f;
@@ -868,7 +871,7 @@ void Engine::DisplayInfo(float elapsedTime, BlockType bloc) {
 	fPosY = fPosYJump;
 	fPosY -= charSize;
 
-	ss << " Velocity  : " << m_remotePlayer.GetVelocity();
+	ss << " Velocity  : " << m_player.GetVelocity();
 	PrintText(fPosX, fPosY, ss.str());
 	ss.str("");
 	fPosY -= charSize;
@@ -878,7 +881,7 @@ void Engine::DisplayInfo(float elapsedTime, BlockType bloc) {
 	ss.str("");
 	fPosY -= charSize;
 
-	ss << " Remote Position  : " << m_remotePlayer.GetPosition();//m_player.GetPosition();
+	ss << " Remote Position  : " << m_otherplayerpos;
 	PrintText(fPosX, fPosY, ss.str());
 	ss.str("");
 	fPosY -= charSize;
@@ -1120,11 +1123,11 @@ int Engine::GetCountdown(float elapsedTime) {
 void Engine::Render(float elapsedTime) {
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
-	m_time_SplashScreen += elapsedTime;
+	/*m_time_SplashScreen += elapsedTime;
 	if (m_time_SplashScreen < 2) {
 		DrawSplachScreen();
 	}
-	else if (m_gamestate == GameState::PLAY)
+	else */if (m_gamestate == GameState::PLAY)
 	{
 		HideCursor();
 		CenterMouse(); //D<>placement de centermouse dans l'action de jouer
@@ -1241,18 +1244,10 @@ void Engine::Render(float elapsedTime) {
 
 		gameTime += elapsedTime * 10;
 
-		Vector3f dance = Vector3f(sin(gameTime), 0, cos(-gameTime));
-		dance.Normalize();
-		m_remotePlayer.ApplyPhysics(dance, &m_world, elapsedTime);
 		m_world.Update(m_bullets, m_player.GetPosition(), m_blockinfo);
 		m_renderer.UpdateMesh(&m_world, m_player.GetPosition(), m_blockinfo);
-		m_remotePlayer.Render(m_animeAtlas, m_shader01, all, elapsedTime);
-		m_booster.RenderBillboard({ 195,16,195 }, m_textureAtlas, m_shader01, all);
 
-		if (m_isSkybox) m_renderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas);
+		//m_booster.RenderBillboard({ 195,16,195 }, m_textureAtlas, m_shader01, all);
-
-		//glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-		//m_remotePlayer.Render(m_textureAtlas, m_shader01, all, elapsedTime);
 
 		m_renderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas);
 
@@ -1276,15 +1271,21 @@ void Engine::Render(float elapsedTime) {
 		}
 
 		if (m_networkgame) { // Pour se gerer le paquet.
+			static bool has_synced = false;
 			using namespace std::chrono;
 			using namespace netprot;
 			Timestamp tstamp = duration_cast<milliseconds>(high_resolution_clock::now() - m_startTime).count();
+			static Timestamp last = 0;
 			Input input;
 			Sync sync;
 			uint64_t id = m_conn.getId();
 			static std::vector<char*> lsPck;
-			static uint64_t sync_acc = 0;
+			static int sync_acc = 0;
-			sync_acc += tstamp;
+
+			if (last == 0)
+				last = tstamp;
+
+			sync_acc += tstamp - last;
 
 			if (sync_acc >= 1000) {
 				sync_acc -= 1000;
@@ -1292,8 +1293,11 @@ void Engine::Render(float elapsedTime) {
 				sync.timestamp = tstamp;
 				sync.position = m_player.GetPositionAbs();
 				sync.hp = m_player.GetHP();
-				
+				if (!has_synced) {
-				// TODO: Garrocher ca quelque-part. 
+					has_synced = true;
+					sendPackTo<Sync>(m_conn.m_sock_udp, &sync, &m_bufout, &m_conn.m_srvsockaddr);
+				}
+				m_syncs[sync.timestamp] = sync;
 			}
 
 			input.sid = id;
@@ -1322,23 +1326,61 @@ void Engine::Render(float elapsedTime) {
 					using enum PACKET_TYPE;
 				case SYNC:
 					if (Deserialize(&sync, pck, &bsize)) {
-						if (sync.sid != m_conn.getId())
+						if (sync.sid != m_conn.getId()) {
+							std::cout << "syncsid be no good.";
 							break;
-						// TODO: Vérifier si les positions concordent au sync local.
+						}
+						if (m_syncs.count(sync.timestamp)) {
+							Sync comp = m_syncs[sync.timestamp];
+							m_player.InflictDamage(sync.hp - comp.hp);
+
+							Vector3f diff = sync.position - comp.position;
+							
+							if (diff.y < 1.)
+								diff.y = 0;
+
+							//std::cout << sync.timestamp << " ms: " << comp.position << " - " << sync.position << " Diff: " << diff.Length() << std::endl;
+
+							if (diff.Length() > 1.5) {
+								diff.Normalize();
+								m_player.Move(-diff);
+							}
+
+							// TODO: Syncer sync.timer avec le timer
+
+							m_syncs.erase(sync.timestamp);
+						}
+						else std::cout << "sync be no good.";
 					}
 					break;
 				case OUTPUT:
 					if (Deserialize(&out, pck, &bsize)) {
-						RemotePlayer* r = (RemotePlayer*)m_players[out.id];
+						if (!m_players.contains(out.id)) {
-						r->Feed(out);
+							
+							std::cout << out.id << " is id no good." << std::endl;
+							break;
+						}
+						RemotePlayer* rt = static_cast<RemotePlayer*>(m_players[out.id]);
+						rt->Feed(out);
 					}
 					break;
 				default:
+					std::cout << "packet be no good.";
 					break;
 				}
 			}
 			lsPck.clear();
+
+			glDisable(GL_CULL_FACE);
+			for (auto& [key, player] : m_players) {
+				RemotePlayer* rt = static_cast<RemotePlayer*>(player);
+				glClear(GL_STENCIL_BUFFER_BIT);
+				rt->Render(m_animeAtlas, m_shader01, all, elapsedTime);
+				m_otherplayerpos = player->GetPosition(); // Aller chercher GetPosition des deux façon, voir si ça chie.
 			}
+			glEnable(GL_CULL_FACE);
+		}
+
 	}
 	else if (m_gamestate == GameState::MAIN_MENU || m_gamestate == GameState::OPTIONS)
 	{

SQCSim2021/engine.h

@@ -108,7 +108,7 @@ private:
 
     //Menu
     enum class GameState: uint8_t { MAIN_MENU, OPTIONS, QUIT, NEWG, PLAY, PAUSE };
-    GameState m_gamestate = GameState::MAIN_MENU;
+    GameState m_gamestate = GameState::PLAY;
     Texture MenuTitleTexture;
     Texture MenuBGTexture;
     Texture MenuStartTexture;
@@ -117,6 +117,7 @@ private:
     Texture PauseBGTexture;
     Texture SplachScreenTexture;
 
+    Vector3f m_otherplayerpos = Vector3f(999, 999, 999);
 
     float m_scale;
     float m_time = 0;
@@ -165,6 +166,7 @@ private:
 
     bool m_networkgame = false;
     netprot::PlayerInfo m_pinfo;
+    std::unordered_map<uint64_t, netprot::Sync> m_syncs;
     RemotePlayer m_remotePlayer = RemotePlayer(netprot::PlayerInfo(),Vector3f(5.5f, CHUNK_SIZE_Y + 1.8f, 5.5f));
     std::string m_messageNotification = "";
 };

SQCSim2021/main.cpp

@@ -5,5 +5,5 @@
 int main() {
     Engine engine;
     engine.SetMaxFps(60);
-    engine.Start("Syndicat Quebecois de la Construction Simulator 2023", BASE_WIDTH, BASE_HEIGHT, false);
+    engine.Start("Syndicat Quebecois de la Construction Simulator 2023", 800, 600, false);
 }

SQCSim2021/openglcontext.cpp

@@ -16,8 +16,8 @@ bool OpenglContext::Start(const std::string& title, int width, int height, bool
     m_fullscreen = fullscreen;
     InitWindow(width, height);
     
-    Init();
     LoadResource();
+    Init();
 
     sf::Clock clock;
 

SQCSim2021/remoteplayer.cpp

@@ -33,63 +33,62 @@ void RemotePlayer::Init()
 
 void RemotePlayer::Feed(const netprot::Output out) {
 
-	current.position = out.position;
+	m_position = Vector3f(out.position);
-	current.direction = out.direction;
+	//current.position = out.position;
-	current.states = out.states;
+	//current.direction = out.direction;
-	current.id = out.id;
+	//current.states = out.states;
+	//current.id = out.id;
 
-	if (current.position != previous.position)
+	//if (current.position != previous.position)
-	{
+	//{
-		Vector3f positionDelta = current.position - previous.position;
+	//	Vector3f positionDelta = current.position - previous.position;
-		m_position = current.position + positionDelta;
+	//	m_position = current.position + positionDelta;
-		m_direction = current.direction;		
+	//	m_direction = current.direction;		
 
-	}
+	//}
 
-	if(current.direction != previous.direction)
+	//if(current.direction != previous.direction)
-	{
+	//{
-		m_direction = current.direction;
+	//	m_direction = current.direction;
-		current.direction = current.direction;
+	//	current.direction = current.direction;
-	}
+	//}
 
-	if (current.states.shooting) {
+	//if (current.states.shooting) {
-		m_animstate = Anim::SHOOTING;
+	//	m_animstate = Anim::SHOOTING;
-	}
+	//}
-	else if (current.states.jumping) {
+	//else if (current.states.jumping) {
-		m_animstate = Anim::JUMPING;
+	//	m_animstate = Anim::JUMPING;
-	}
+	//}
-	else if (current.states.dead) {
+	//else if (current.states.dead) {
-		m_animstate = Anim::DEAD;
+	//	m_animstate = Anim::DEAD;
-	}
+	//}
-	else if(current.states.powerup){
+	//else if(current.states.powerup){
-		m_animstate = Anim::POWERUP;
+	//	m_animstate = Anim::POWERUP;
-	}
+	//}
-	else if (current.states.still) {
+	//else if (current.states.still) {
-		m_animstate = Anim::STILL;
+	//	m_animstate = Anim::STILL;
-	}
+	//}
-	else if (current.states.running) {
+	//else if (current.states.running) {
-		m_animstate = Anim::RUNNING;
+	//	m_animstate = Anim::RUNNING;
-	}
+	//}
 
-	previous.direction = current.direction;
+	//previous.direction = current.direction;
-	previous.position = current.position;
+	//previous.position = current.position;
-	previous.states = current.states;
+	//previous.states = current.states;
-	previous.id = current.id;
+	//previous.id = current.id;
 
-	m_direction = current.direction;
+	//m_direction = current.direction;
-	m_position = current.position;
+	//m_position = current.position;
 }
 
 void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tran, float elapsedTime)
 {
-
 	float x = GetPosition().x;
 	float y = GetPosition().y;
 	float z = GetPosition().z;
 	float width = 1.f;
 	float height = 1.7f;
 	
-	
 	//Matrix4 mat4 = tran.GetMatrix();
 	//mat4 VP = pMatrix * vMatrix;
 	//Vector3f CameraRight = Vector3f(mat4.Get11(), mat4.Get21(), mat4.Get31());