ajouts dans les cmakelists pour leenuqs

SQCSim-common/define.h

@@ -41,22 +41,17 @@ typedef uint8_t BlockType;
 enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_GREENGRASS, BTYPE_LAST };
 typedef uint8_t BoostType;
 enum BOOST_TYPE { BTYPE_SPEED, BTYPE_HEAL, BTYPE_DAMAGE, BTYPE_INVINCIBLE, BTYPE_BOOST_LAST };
+
+//anim 
 enum ANIM_TYPE { STILL = 0, SHOOTING = 8, JUMPING = 16, JUMPINGSHOOTING = 24, DEAD = 32, TYPE_LAST = 40};
 enum ANIM_POS {FRONT, QUARTER_FRONT_LEFT, QUATER_FRONT_RIGHT, PROFIL_LEFT, PROFIL_RIGHT, QUARTER_BACK_LEFT, QUARTER_BACK_RIGHT, BACK , POS_LAST};
-typedef uint64_t Timestamp;
 
-enum Resolution {
-	HD = 0,		// 1280x720	 (High Definition)
-	FHD,		// 1920x1080 (Full HD)
-	QHD,		// 2560x1440 (Quad HD)
-	UHD			// 3840x2160 (Ultra HD)
-};
+typedef uint64_t Timestamp;
 
 #ifdef _WIN32
 
 #pragma comment(lib,"wsock32.lib") // Pour pouvoir faire fonctionner le linker sans le vcxproject
 #pragma comment(lib,"ws2_32.lib")
-
 #include <ws2tcpip.h>
 #include <Windows.h>
 #include <cstdio>
@@ -81,6 +76,7 @@ enum Resolution {
 #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.backward & 0b01000000 |
-		keys.left & 0b00100000 |
-		keys.right & 0b00010000 |
-		keys.jump & 0b00001000 |
-		keys.shoot & 0b00000100 |
-		keys.block & 0b00000010;
+		(keys.forward? 0b10000000: 0) |
+		(keys.backward? 0b01000000: 0) |
+		(keys.left? 0b00100000: 0) |
+		(keys.right? 0b00010000: 0) |
+		(keys.jump? 0b00001000: 0) |
+		(keys.shoot? 0b00000100: 0) |
+		(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.shooting & 0b01000000 |
-		states.hit & 0b00100000 |
-		states.powerup & 0b00010000 |
-		states.dead & 0b00001000 |
-		states.still & 0b00000100 |
-		states.jumpshot & 0b00000010 |
-		states.running & 0b00000001;
+		(states.jumping? 0b10000000: 0) |
+		(states.shooting? 0b01000000: 0) |
+		(states.hit? 0b00100000: 0) |
+		(states.powerup? 0b00010000: 0) |
+		(states.dead? 0b00001000: 0) |
+		(states.still? 0b00000100: 0) |
+		(states.jumpshot? 0b00000010: 0) |
+		(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.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
+		delta += dir;
 	}
 	else if (back) {
-		delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
+		delta -= dir;
 	}
 
 	if (left) {
-		delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
+		delta.x += dir.z;
+		delta.z += -dir.x;
 	}
 	else if (right) {
-		delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
+		delta.x -= dir.z;
+		delta.z -= -dir.x;
 	}
 
 	delta.Normalize();
@@ -246,8 +256,12 @@ 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; }
+
 Vector3f Player::GetVelocity() const { return m_velocity; }
 
 Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }

SQCSim-common/player.h

@@ -25,7 +25,9 @@ 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;
 	Vector3f GetVelocity() const;
 	Vector3f GetPOV() 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,32 +117,36 @@ void Connection::Run(World* world) {
 	if (m_input_manifest.size() < 2)
 		return;
 
-	while (m_last_in < m_input_manifest.size()) {
-		in = m_input_manifest.at(m_last_in + 1);
-		last = m_input_manifest.at(m_last_in);
+	while (m_last_in < m_input_vector.size() - 1) {
+		in = m_input_vector.at(m_last_in + 1);
+		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, 
 														  in.keys.right, 
 														  in.keys.jump, false, el), world, el);
 
-		out.position = player.get()->GetPosition();
+		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())
-		m_input_manifest.erase(wat--);
+//	while (wat != m_input_manifest.begin())
+//		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) {
-					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);
+				m_players[log->sid] = 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) {
-	//	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);
- //       }
-	//}
+		// TODO: Gérer les 2-3 secondes post-game avant le billboard pour pas avoir un whiplash à la fin de la game.
 
 	}
+}
 
 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/SQCSim2021.vcxproj

@@ -27,7 +27,6 @@
     <ClInclude Include="mesh.h" />
     <ClInclude Include="openglcontext.h" />
     <ClInclude Include="remoteplayer.h" />
-    <ClInclude Include="settings.h" />
     <ClInclude Include="shader.h" />
     <ClInclude Include="skybox.h" />
     <ClInclude Include="texture.h" />
@@ -45,7 +44,6 @@
     <ClCompile Include="mesh.cpp" />
     <ClCompile Include="openglcontext.cpp" />
     <ClCompile Include="remoteplayer.cpp" />
-    <ClCompile Include="settings.cpp" />
     <ClCompile Include="shader.cpp" />
     <ClCompile Include="skybox.cpp" />
     <ClCompile Include="texture.cpp" />

SQCSim2021/SQCSim2021.vcxproj.filters

@@ -56,9 +56,6 @@
     <ClInclude Include="booster.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="settings.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="engine.cpp">
@@ -106,8 +103,5 @@
     <ClCompile Include="booster.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="settings.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

SQCSim2021/audio.cpp

@@ -48,7 +48,3 @@ void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& v
 void Audio::ToggleMusicState() { m_music->setIsPaused(!m_music->getIsPaused()); }
 
 void Audio::PauseEngine() { m_engine->setAllSoundsPaused(); }
-
-float Audio::GetMusicVolume() const {
-	return m_music->getVolume();
-}

SQCSim2021/audio.h

@@ -33,8 +33,6 @@ public:
 	void ToggleMusicState();
 
 	void PauseEngine();
-
-	float GetMusicVolume() const;
 };
 
 #endif // AUDIO_H__

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/define.h

@@ -28,8 +28,17 @@
 #define BASE_WIDTH 640
 #define BASE_HEIGHT 480
 
+
 #define ANIME_PATH_JUMP		"./media/textures/AssetOtherPlayer/FinalPNGJumping/"
 #define ANIME_PATH_STILL	"./media/textures/AssetOtherPlayer/FinalPNGStanding/"
+
+//1 = jump shoot sans anim, 2 = jump shoot avec anim
+#define ANIM_PATH_JSHOOT1    "./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/"
+#define ANIM_PATH_JSHOOT2	"./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/ShootingJump/"
+//1 = shoot sans anim, 2 = shoot avec anim
+#define ANIM_PATH_SSHOOT1	"./media/textures/AssetOtherPlayer/FinalPNGShooting/"
+#define ANIM_PATH_SSHOOT2	"./media/textures/AssetOtherPlayer/FinalPNGShooting/Shooting/"
+
 #define TEXTURE_PATH        "./media/textures/"
 #define SHADER_PATH		    "./media/shaders/"
 #define AUDIO_PATH			"./media/audio/"

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);
@@ -459,28 +461,70 @@ void Engine::LoadResource() {
 
 	//AJOUTER LES TEXTURES DANS L'ORDRE DE L'ÉNUM 
 
+	//STILL//STANDING
+	TextureAtlas::TextureIndex StillFront = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueFrontRight.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontLeft = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueLeft.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontRight = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueRight.png");
+	//TextureAtlas::TextureIndex StillProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueProfilLeft.png");
+	//TextureAtlas::TextureIndex StillProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueProfilRight.png");
+	//TextureAtlas::TextureIndex StillQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueLeftBack.png");
+	//TextureAtlas::TextureIndex StillQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueRightBack.png");
+	//TextureAtlas::TextureIndex StillBack = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueBackRight.png");
+
+	//SHOOTINGSTILL SANS TIRER
+	//TextureAtlas::TextureIndex StillFrontShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueFrontRightShootingRight.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueFrontRightShootingRight.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueRightShootingRight.png");
+	//TextureAtlas::TextureIndex StillProfiltLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueProfilShootingLeft.png");
+	//TextureAtlas::TextureIndex StillProfiltRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueProfilShootingRight.png");
+	//TextureAtlas::TextureIndex StillQuarterBackLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueBackLeftShootingLeft.png");
+	//TextureAtlas::TextureIndex StillQuarterBackRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueBackRightShootingRight.png");
+	//TextureAtlas::TextureIndex StillBackShoot = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT1 "BlueShootingBackRight.png");
+
+	//SHOOTINGSTILL TIRER
+	//TextureAtlas::TextureIndex StillFrontShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueFrontRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontLeftFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueLeftShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex StillQuarterFrontRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex StillProfiltLeftShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueProfilShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex StillProfiltRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueProfilShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex StillQuarterBackLeftShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueBackLeftShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex StillQuarterBackRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueBackRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex StillBackShootFire = m_animeAtlas.AddTexture(ANIM_PATH_SSHOOT2  "BlueShootingBackRightShoot1.png");
+
+
 	//JUMP
-	//TextureAtlas::TextureIndex JumpBack = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueBackJumpRight.png");
 	//TextureAtlas::TextureIndex JumpFront = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueFrontJumpRight.png");
-	//TextureAtlas::TextureIndex JumpQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftBackJumpLeft.png");
-	//TextureAtlas::TextureIndex JumpQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightBackJumpRight.png");
-	//TextureAtlas::TextureIndex JumpProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpLeft.png");
-	//TextureAtlas::TextureIndex JumpProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpRight.png");
 	//TextureAtlas::TextureIndex JumpQuarterFrontLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftFrontJumpLeft.png");
 	//TextureAtlas::TextureIndex JumpQuarterFrontRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightFrontJumpRight.png");
+	//TextureAtlas::TextureIndex JumpProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpLeft.png");
+	//TextureAtlas::TextureIndex JumpProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpRight.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftBackJumpLeft.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightBackJumpRight.png");
+	//TextureAtlas::TextureIndex JumpBack = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueBackJumpRight.png");
+
+
+	//SHOOTINGJUMP SANS TIRER 
+	//TextureAtlas::TextureIndex JumpFrontShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueFrontJumpRightShootingRight.png");
+	//TextureAtlas::TextureIndex JumpQuarterFrontLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueFrontLeftJumpLeftShootingLeft.png");
+	//TextureAtlas::TextureIndex JumpQuarterFrontRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueFrontRightJumpRightShootingRight.png");
+	//TextureAtlas::TextureIndex JumpProfiltLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueProfilLeftJumpLeftShootingLeft.png");
+	//TextureAtlas::TextureIndex JumpProfiltRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BluerProfilRightJumprightShootingRight.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackLeftShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueBackLeftJumpLeftShootingLeft.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackRightShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueBackRightJumpRightShootingRight.png");
+	//TextureAtlas::TextureIndex JumpBackShoot = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT1  "BlueBackJumpRightShootingRight.png");
+
+
+	//SHOOTINGJUMP TIRER
+	//TextureAtlas::TextureIndex JumpFrontShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueFrontJumpRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex JumpQuarterFrontLeftShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueFrontLeftJumpLeftShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex JumpQuarterFrontRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueFrontRightJumpRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex JumpProfiltLeftShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueProfilLeftJumpLeftShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex JumpProfiltRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BluerProfilRightJumprightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackLeftShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueBackLeftJumpLeftShootingLeftShoot1.png");
+	//TextureAtlas::TextureIndex JumpQuarterBackRightShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueBackRightJumpRightShootingRightShoot1.png");
+	//TextureAtlas::TextureIndex JumpBackShootFire = m_animeAtlas.AddTexture(ANIM_PATH_JSHOOT2  "BlueBackJumpRightShootingRightShoot1.png");
 	
-	//STILL
-	//TextureAtlas::TextureIndex StillBack = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueBackRight.png");
-	TextureAtlas::TextureIndex StillFront = m_animeAtlas.AddTexture(ANIME_PATH_STILL "BlueFrontRight.png");
-	//TextureAtlas::TextureIndex StillQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftBack.png");
-	//TextureAtlas::TextureIndex StillQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightBack.png");
-	//TextureAtlas::TextureIndex StillProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilLeft.png");
-	//TextureAtlas::TextureIndex StillProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilRight.png");
-	//TextureAtlas::TextureIndex StillQuarterFrontLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeft.png");
-	//TextureAtlas::TextureIndex StillQuarterFrontRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRight.png");
 	
-	//SHOOTINGSTILL
-	//SHOOTINGJUMP
 	
 	if (!m_animeAtlas.Generate(TEXTURE_SIZE, false)) {
 		std::cout << " Unable to generate texture atlas ..." << std::endl;
@@ -694,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;
@@ -826,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;
@@ -836,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;
@@ -1078,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
@@ -1199,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);
-
-		//glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-		//m_remotePlayer.Render(m_textureAtlas, m_shader01, all, elapsedTime);
+		//m_booster.RenderBillboard({ 195,16,195 }, m_textureAtlas, m_shader01, all);
 
 		m_renderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas);
 
@@ -1234,20 +1271,33 @@ 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 int sync_acc = 0;
 
-			if (false) { // TODO: Faire un checkup pour chaque ~1000ms.
+			if (last == 0)
+				last = tstamp;
+
+			sync_acc += tstamp - last;
+
+			if (sync_acc >= 1000) {
+				sync_acc -= 1000;
 				sync.sid = id;
 				sync.timestamp = tstamp;
-				sync.position = m_player.GetPosition();
+				sync.position = m_player.GetPositionAbs();
 				sync.hp = m_player.GetHP();
-				// TODO: Garrocher ca quelque-part. 
+				if (!has_synced) {
+					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;
@@ -1276,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];
-						r->Feed(out);
+						if (!m_players.contains(out.id)) {
+							
+							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

@@ -24,7 +24,7 @@
 #include "renderer.h"
 #include "remoteplayer.h"
 #include "booster.h"
-#include "settings.h"
+
 
 class Engine : public OpenglContext {
 public:
@@ -64,6 +64,10 @@ private:
     void DrawHud(float elapsedTime, BlockType bloc);
     void PrintText(float x, float y, const std::string& t, float charSizeMultiplier = 1.0f);
 
+
+    
+
+
     Connector m_conn;
     Shader m_shader01;
     BlockInfo* m_blockinfo[BTYPE_LAST];
@@ -95,7 +99,6 @@ private:
     irrklang::ISound *m_whoosh[MAX_BULLETS];
 
     Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
-    Settings m_parameters = Settings(m_audio);
     
     Bullet* m_bullets[MAX_BULLETS];
 
@@ -105,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;
@@ -114,12 +117,15 @@ private:
     Texture PauseBGTexture;
     Texture SplachScreenTexture;
 
+    Vector3f m_otherplayerpos = Vector3f(999, 999, 999);
 
     float m_scale;
     float m_time = 0;
     float m_time_SplashScreen = 0;
     float m_titleX = 0;
     float m_titleY = 0;
+    float m_Width = 0;
+    float m_Height = 0;
 
     int m_renderCount = 0;
     int m_countdown = COUNTDOWN;
@@ -160,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,6 +33,7 @@ void RemotePlayer::Init()
 
 void RemotePlayer::Feed(const netprot::Output out) {
 
+	m_position = Vector3f(out.position);
 	//current.position = out.position;
 	//current.direction = out.direction;
 	//current.states = out.states;
@@ -75,18 +76,19 @@ void RemotePlayer::Feed(const netprot::Output out) {
 	//previous.position = current.position;
 	//previous.states = current.states;
 	//previous.id = current.id;
+
+	//m_direction = current.direction;
+	//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());

SQCSim2021/settings.cpp

@@ -1,146 +0,0 @@
-#include "settings.h"
-
-Settings::Settings(Audio& audio)
-    : m_audio(audio),
-    m_mainVolume(0.5f),
-    m_musicVolume(0.5f),
-    m_sfxVolume(0.5f),
-    m_resolution(FHD),
-    m_fullscreen(false),
-    m_brightness(0.5f),
-    m_contrast(0.5f),
-    m_mouseSensitivity(0.5f) {
-    ApplyResolution(m_resolution);
-}
-
-void Settings::SaveFile(const std::string& filename) {
-    std::ofstream file(filename);
-    if (!file.is_open()) {
-        std::cerr << "Failed to open file for saving parameters" << std::endl;
-        return;
-    }
-
-    file << m_mainVolume << '\n';
-    file << m_musicVolume << '\n';
-    file << m_sfxVolume << '\n';
-
-    file << static_cast<int>(m_resolution) << '\n';
-    file << m_fullscreen << '\n';
-    file << m_brightness << '\n';
-    file << m_contrast << '\n';
-
-    file << m_mouseSensitivity << '\n';
-
-    file.close();
-}
-
-void Settings::LoadFile(const std::string& filename) {
-    std::ifstream file(filename);
-    if (!file.is_open()) {
-        std::cerr << "Failed to open file for loading parameters" << std::endl;
-        return;
-    }
-
-    file >> m_mainVolume;
-    file >> m_musicVolume;
-    file >> m_sfxVolume;
-
-    int resolutionValue;
-    file >> resolutionValue;
-    m_resolution = static_cast<Resolution>(resolutionValue);
-
-    file >> m_fullscreen;
-    file >> m_brightness;
-    file >> m_contrast;
-
-    file >> m_mouseSensitivity;
-
-    file.close();
-}
-
-float Settings::GetMainVolume() const {
-    return m_mainVolume;
-}
-
-void Settings::SetMainVolume(float volume) {
-    m_mainVolume = volume;
-}
-
-void Settings::GetMusicVolume() {
-    m_musicVolume = m_audio.GetMusicVolume();
-}
-
-void Settings::SetMusicVolume(float volume) {
-    m_musicVolume = volume;
-}
-
-float Settings::GetSfxVolume() const {
-    return m_sfxVolume;
-}
-
-void Settings::SetSfxVolume(float volume) {
-    m_sfxVolume = volume;
-}
-
-float Settings::GetBrightness() const {
-    return m_brightness;
-}
-
-void Settings::SetBrightness(float brightness) {
-    m_brightness = brightness;
-}
-
-float Settings::GetContrast() const {
-    return m_contrast;
-}
-
-void Settings::SetContrast(float contrast) {
-    m_contrast = contrast;
-}
-
-bool Settings::GetFullscreen() const {
-    return m_fullscreen;
-}
-
-void Settings::SetFullscreen(bool fullscreen) {
-    m_fullscreen = fullscreen;
-}
-
-const Resolution& Settings::GetResolution() const {
-    return m_resolution;
-}
-
-void Settings::SetResolution(const Resolution& resolution) {
-    m_resolution = resolution;
-}
-
-float Settings::GetMouseSensitivity() const {
-    return m_mouseSensitivity;
-}
-
-void Settings::SetMouseSensitivity(float sensitivity) {
-    m_mouseSensitivity = sensitivity;
-}
-
-void Settings::ApplyResolution(Resolution resolution) {
-    switch (resolution) {
-    case HD:
-        m_rezWidth = 1280;
-        m_rezHeight = 720;
-        break;
-    case FHD:
-        m_rezWidth = 1920;
-        m_rezHeight = 1080;
-        break;
-    case QHD:
-        m_rezWidth = 2560;
-        m_rezHeight = 1440;
-        break;
-    case UHD:
-        m_rezWidth = 3840;
-        m_rezHeight = 2160;
-        break;
-    default:
-        break;
-    }
-}

SQCSim2021/settings.h

@@ -1,70 +0,0 @@
-#ifndef SETTINGS_H__
-#define SETTINGS_H__
-
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <map>
-
-#include "define.h"
-#include "audio.h"
-
-class Settings {
-public:
-	Settings(Audio& audio);
-
-	void SaveFile(const std::string& filename);
-	void LoadFile(const std::string& filename);
-
-	// Audio
-	float GetMainVolume() const;
-	void SetMainVolume(float volume);
-
-	void GetMusicVolume();
-	void SetMusicVolume(float volume);
-
-	float GetSfxVolume() const;
-	void SetSfxVolume(float volume);
-
-	// Graphic
-	float GetBrightness() const;
-	void SetBrightness(float brightness);
-
-	float GetContrast() const;
-	void SetContrast(float contrast);
-
-	bool GetFullscreen() const;
-	void SetFullscreen(bool fullscreen);
-
-	const Resolution& GetResolution() const;
-	void SetResolution(const Resolution& resolution);
-
-	// Gameplay
-	float GetMouseSensitivity() const;
-	void SetMouseSensitivity(float sensitivity);
-
-	void ApplyResolution(Resolution resolution);
-
-private:
-
-	Audio& m_audio;
-	// Audio
-	float m_mainVolume;
-	float m_musicVolume;
-	float m_sfxVolume;
-
-	// Graphic
-	Resolution m_resolution;
-	bool m_fullscreen;
-	int m_rezWidth;
-	int m_rezHeight;
-	float m_brightness;
-	float m_contrast;
-
-	// Gameplay
-	float m_mouseSensitivity;
-};
-
-
-#endif // PARAMETERS_H