SQCSim-common/SQCSim-common.vcxproj

@@ -48,7 +48,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>ClangCL</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -131,7 +131,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="booster.h" />
     <ClInclude Include="array2d.h" />
     <ClInclude Include="array3d.h" />
     <ClInclude Include="blockinfo.h" />
@@ -148,7 +147,6 @@
     <ClInclude Include="world.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="booster.cpp" />
     <ClCompile Include="blockinfo.cpp" />
     <ClCompile Include="boostinfo.cpp" />
     <ClCompile Include="bullet.cpp" />

SQCSim-common/SQCSim-common.vcxproj.filters

@@ -54,9 +54,6 @@
     <ClInclude Include="transformation.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="booster.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="boostinfo.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
@@ -86,9 +83,6 @@
     <ClCompile Include="transformation.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="booster.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="boostinfo.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>

SQCSim-common/booster.cpp

@@ -1,39 +0,0 @@
-#include "booster.h"
-
-Booster::Booster()
-{
-}
-
-Booster::Booster(Vector3f tpos, BOOST_TYPE ttype, uint64_t id): m_id(id), pos(tpos), type(ttype){}
-
-Booster::~Booster()
-{
-
-}
-
-Vector3f Booster::GetPosition()
-{
-	return pos;
-}
-
-BOOST_TYPE Booster::GetType()
-{
-	return type;
-}
-
-uint64_t Booster::GetId() const
-{
-	return m_id;
-}
-
-bool Booster::GetAvailability()
-{
-	return available;
-}
-
-void Booster::SetAvailability(bool value)
-{
-	available = value;
-	modified = true;
-}
-

SQCSim-common/booster.h

@@ -1,23 +0,0 @@
-#ifndef BOOSTER_H__
-#define BOOSTER_H__
-#include "define.h"
-#include "vector3.h"
-
-class Booster {
-public:
-	Booster();
-	Booster(Vector3f tpos, BOOST_TYPE ttype, uint64_t id);
-	~Booster();
-	Vector3f GetPosition();
-	BOOST_TYPE GetType();
-	uint64_t GetId() const;
-	bool GetAvailability();
-	void SetAvailability(bool value);
-	bool modified = true;
-private:
-	Vector3f pos;
-	BOOST_TYPE type;
-	uint64_t m_id;
-	bool available = true;
-};
-#endif

SQCSim-common/bullet.cpp

@@ -3,40 +3,27 @@
 
 Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
 
-Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id) : m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id) {}
+Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id) {}
-
-
-Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id, bool canhurt): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id), m_canhurt(canhurt) {}
 
 Bullet::~Bullet() {}
 
 bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> mapPlayer, netprot::ChunkMod** chunkmod) {
 	int max = 100 / perframe;
-	Player* shooter = nullptr;
+	float damage = 0.057f;
-	float damage = 0.098f;
-	if (mapPlayer.count(m_shooter_id)) {
-		shooter = mapPlayer.at(m_shooter_id);
-		damage = shooter->boostdamage ? 0.123f : 0.098f;
-	}
-
 	for (int x = 0; x < max; ++x) {
 		m_currentpos += m_velocity * elapsedtime;
 
 		for (auto& [key, player] : mapPlayer) {
-			if (key == m_shooter_id)
-				continue;
-
 			bool hit = false;
-			if ((m_currentpos - player->GetPosition()).Length() < 1.5f) {
+			if ((m_currentpos - player->GetPosition()).Length() < .6f) {
 				hit = true;
 			}
-			else if ((m_currentpos - player->GetPOV()).Length() < .7f) {
+			if ((m_currentpos - player->GetPOV()).Length() < .2f) {
 				damage *= 2; // HEADSHOT!
 				hit = true;
 			}
 			if (hit && !player->AmIDead()) {
-				if (m_canhurt && !player->boostinvincible)
+				player->InflictDamage(damage);
-					player->InflictDamage(damage);
 				player->m_hit = true;
 
 				if (player->AmIDead())
@@ -49,17 +36,15 @@ bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordere
 		if (!world->ChunkAt(m_currentpos))
 			return true;
 		else if (world->BlockAt(m_currentpos) != BTYPE_AIR) {
-			if (m_canhurt) {
+			if (chunkmod) {
-				if (chunkmod) {
+				using namespace netprot;
-					using namespace netprot;
+				*chunkmod = new ChunkMod();
-					*chunkmod = new ChunkMod();
+				(*chunkmod)->old_b_type = world->BlockAt(m_currentpos);
-					(*chunkmod)->old_b_type = world->BlockAt(m_currentpos);
+				(*chunkmod)->b_type = BTYPE_AIR;
-					(*chunkmod)->b_type = BTYPE_AIR;
+				(*chunkmod)->pos = m_currentpos;
-					(*chunkmod)->pos = m_currentpos;
-				}
-
-				world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
 			}
+
+			world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
 			return true;
 		}
 		else if ((m_currentpos - m_startpos).Length() > VIEW_DISTANCE) return true;

SQCSim-common/bullet.h

@@ -14,7 +14,6 @@ class Bullet {
 public:
 	Bullet(Vector3f pos, Vector3f dir);
 	Bullet(Vector3f pos, Vector3f dir, uint64_t tid);
-	Bullet(Vector3f pos, Vector3f dir, uint64_t tid, bool canhurt);
 	~Bullet();
 
 	bool Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> m_mapPlayer, netprot::ChunkMod** chunkmod);
@@ -28,8 +27,6 @@ private:
 			 m_currentpos, 
 			 m_velocity;
 	uint64_t m_shooter_id = 0;
-
-	bool m_canhurt = true;
 	
 
 };

SQCSim-common/define.h

@@ -31,15 +31,11 @@
 #define TEXTURE_SIZE 512
 #define MAX_BULLETS 512
 
-#define NB_BOOST 2
 #define TIME_SPEED_BOOST 10		//secondes
 #define TIME_DAMAGE_BOOST 10	//secondes
 #define TIME_INVINCIBLE_BOOST 4	//secondes
-#define STRENGTH_SPEED_BOOST 1000	//Pourcentage
+#define STRENGTH_SPEED_BOOST 10	//Pourcentage
-#define BULLET_TIME .2 //secondes
+#define BULLET_TIME .1
-
-#define SYNC_ACC 600  // ms
-#define CMOD_ACC 1000  // ms
 
 typedef uint8_t BlockType;
 enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_GREENGRASS, BTYPE_LAST };

SQCSim-common/netprotocol.cpp

@@ -212,14 +212,7 @@ void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) {
 
 	memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + 1, hp8, sizeof(float));
 
-	Boosts boost = sync->boost;
+	*buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + sizeof(float) + 1;
-	uint8_t boost8 = // Reste 6 bits.
-		(boost.invincible ? 0b10000000 : 0) |
-		(boost.damage ? 0b01000000 : 0);
-
-	memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 5 + sizeof(uint16_t) + 1, &boost8, sizeof(uint8_t));
-
-	*buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 5 + sizeof(uint16_t) + sizeof(float) + 2;
 }
 
 void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
@@ -521,53 +514,6 @@ void netprot::Serialize(BulletAdd* bull, char* buf[], uint32_t* buflen) {
 	*buflen = 1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 6;
 }
 
-void netprot::Serialize(PickupMod* pmod, char* buf[], uint32_t* buflen) {
-	*buf[0] = (char)netprot::PACKET_TYPE::PICKUPMOD;
-
-	uint64_t id = pmod->id;
-	uint8_t id8[sizeof(uint64_t)] = { (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 + 1, id8, sizeof(uint64_t));
-
-	uint32_t vec[3];
-	memcpy(vec, &pmod->pos, sizeof(Vector3f)); // Pour d<>naturer les floats.
-
-	uint8_t vec8[3 * sizeof(uint32_t)] = {
-							(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, vec8, sizeof(uint32_t) * 3);
-
-	Boosts boost = pmod->boost;
-	uint8_t boost8 = // Reste 5 bits.
-		(boost.invincible ? 0b10000000 : 0) |
-		(boost.damage ? 0b01000000 : 0) |
-		(boost.hp ? 0b00100000 : 0);
-
-	memcpy(*buf + sizeof(uint64_t) + sizeof(uint32_t) * 3 + 1, &boost8, sizeof(uint8_t));
-
-	memcpy(*buf + 2 + sizeof(uint64_t) + sizeof(uint32_t) * 3, &pmod->available, sizeof(bool));
-
-	*buflen = 2 + sizeof(uint64_t) + sizeof(uint32_t) * 3 + 3;
-}
-
 void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
 	*buf[0] = (char)netprot::PACKET_TYPE::ERRLOG;
 
@@ -582,7 +528,6 @@ void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
 
 
 
-
 bool netprot::Deserialize(Input* in, char* buf, uint32_t* buflen) {
 	if (*buflen <= sizeof(Input))
 		return false;
@@ -791,12 +736,7 @@ bool netprot::Deserialize(Sync* sync, char* buf, uint32_t* buflen) {
 
 	memcpy(&sync->hp, &hp, sizeof(float));
 
-	uint8_t boost = 0;
+	*buflen = 1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + sizeof(float);
-	memcpy(&boost, &buf[2 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 5 + sizeof(uint16_t)], sizeof(uint8_t));
-	sync->boost.invincible = boost & 0b10000000;
-	sync->boost.damage = boost & 0b01000000;
-
-	*buflen = 2 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 5 + sizeof(uint16_t) + sizeof(float);
 
 	return true;
 }
@@ -1119,53 +1059,6 @@ bool netprot::Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen) {
 	return true;
 }
 
-bool netprot::Deserialize(PickupMod* pmod, char* buf, uint32_t* buflen) {
-	if (*buflen <= sizeof(PickupMod))
-		return false;
-
-	uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
-	memcpy(diff, &buf[1], sizeof(uint64_t));
-	pmod->id =
-		(uint64_t)diff[0] << 56 |
-		(uint64_t)diff[1] << 48 |
-		(uint64_t)diff[2] << 40 |
-		(uint64_t)diff[3] << 32 |
-		(uint64_t)diff[4] << 24 |
-		(uint64_t)diff[5] << 16 |
-		(uint64_t)diff[6] << 8 |
-		(uint64_t)diff[7];
-
-	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)], sizeof(uint8_t) * 12);
-	uint32_t vec[3] = {
-		(uint32_t)subvec[0] << 24 |
-		(uint32_t)subvec[1] << 16 |
-		(uint32_t)subvec[2] << 8 |
-		(uint32_t)subvec[3],
-			(uint32_t)subvec[4] << 24 |
-			(uint32_t)subvec[5] << 16 |
-			(uint32_t)subvec[6] << 8 |
-			(uint32_t)subvec[7],
-				(uint32_t)subvec[8] << 24 |
-				(uint32_t)subvec[9] << 16 |
-				(uint32_t)subvec[10] << 8 |
-				(uint32_t)subvec[11] };
-
-	memcpy(&pmod->pos, vec, sizeof(uint32_t) * 3);
-
-	uint8_t boosts = 0;
-	memcpy(&boosts, &buf[1 + sizeof(uint64_t) + sizeof(uint32_t) * 3], sizeof(uint8_t));
-	pmod->boost.invincible = boosts & 0b10000000;
-	pmod->boost.damage = boosts & 0b01000000;
-	pmod->boost.hp = boosts & 0b00100000;
-
-	memcpy(&pmod->available, &buf[2 + sizeof(uint64_t) + sizeof(uint32_t) * 3], sizeof(bool));
-
-	*buflen = 3 + sizeof(uint64_t) + sizeof(uint32_t) * 3;
-
-	return true;
-}
-
 
 
 netprot::PACKET_TYPE netprot::getType(char* buf, const uint32_t buflen) {

SQCSim-common/netprotocol.h

@@ -58,12 +58,6 @@ namespace netprot {
 			running = false;
 	};
 
-	struct Boosts {
-		bool invincible = false,
-			damage = false,
-			hp = false;
-	};
-
 	/* Structures de paquets */
 
 	struct Input {										// cli -> srv			UDP			~frame
@@ -86,11 +80,10 @@ namespace netprot {
 		uint64_t sid = 0;
 		uint32_t timer = 0;
 		uint16_t ammo = 0;
-		Boosts boost;
 		float hp = 0;
 		Vector3f position;
 		Sync() {}
-		Sync(Sync* sync) : timestamp(sync->timestamp), sid(sync->sid), timer(sync->timer), ammo(sync->ammo), hp(sync->hp), position(sync->position), boost(sync->boost) {}
+		Sync(Sync* sync) : timestamp(sync->timestamp), sid(sync->sid), timer(sync->timer), ammo(sync->ammo), hp(sync->hp), position(sync->position) {}
 	};
 
 	struct TeamInfo {									// cli <-> srv			TCP			once
@@ -128,15 +121,6 @@ namespace netprot {
 		GameInfo(GameInfo* gam) : seed(gam->seed), countdown(gam->countdown), gameType(gam->gameType) {}
 	};
 
-	struct PickupMod {
-		uint64_t id;
-		Vector3f pos;
-		Boosts boost;
-		bool available = true;
-		PickupMod() {}
-		PickupMod(PickupMod* pmod) : id(pmod->id), pos(pmod->pos), boost(pmod->boost), available(pmod->available) {}
-	};
-
 	struct Chat {										// cli <-> srv			TCP			event
 		uint64_t src_id = 0,
 			dest_id = 0,
@@ -177,7 +161,6 @@ namespace netprot {
 	void Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen); // cli/srv
 	void Serialize(Chat* chat, char* buf[], uint32_t* buflen); // cli/srv
 	void Serialize(ChunkMod* chmod, char* buf[], uint32_t* buflen); // srv
-	void Serialize(PickupMod* chmod, char* buf[], uint32_t* buflen); // srv
 	void Serialize(BulletAdd* bull, char* buf[], uint32_t* buflen); // srv
 	void Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen); // srv
 
@@ -190,7 +173,6 @@ namespace netprot {
 	bool Deserialize(GameInfo* ginfo, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(Chat* chat, char* buf, uint32_t* buflen); // srv/cli
 	bool Deserialize(ChunkMod* chmod, char* buf, uint32_t* buflen); // cli
-	bool Deserialize(PickupMod* chmod, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(BulletAdd* bull, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen); // srv
 

SQCSim-common/player.cpp

@@ -4,15 +4,14 @@
 Player::Player(const Vector3f& position, float rotX, float rotY) : m_position(position), m_rotX(rotX), m_rotY(rotY) {
 	m_velocity = Vector3f(0, 0, 0);
 	m_airborne = true;
-	m_hp = 1.0f;
+	m_hp = 1.0f; //TODO: Remettre <20> 1.0f
-	m_sensitivity = 0.5f;
 	m_username = "Zelda Bee-Bop56";
 }
 
 Player::~Player() {}
 
-void Player::TurnLeftRight(float value, float sensitivity) {
+void Player::TurnLeftRight(float value) {
-	m_rotY += value * sensitivity;
+	m_rotY += value;
 	if (m_rotY > 360) m_rotY = 0;
 	else if (m_rotY < -360) m_rotY = 0;
 
@@ -26,8 +25,8 @@ void Player::TurnLeftRight(float value, float sensitivity) {
 	m_direction.Normalize();
 }
 
-void Player::TurnTopBottom(float value, float sensitivity) {
+void Player::TurnTopBottom(float value) {
-	m_rotX += value * sensitivity;
+	m_rotX += value;
 	if (m_rotX > 80) m_rotX = 80;
 	else if (m_rotX < -80) m_rotX = -80;
 
@@ -68,8 +67,8 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
 	delta.x *= .6f;
 	delta.z *= .6f;
 
-	if ((jump || shoot) && !m_airborne) {
+	if ((jump || shoot ) && !m_airborne) {
-		delta.y += jump ? .32f : shoot ? .1f : 0.f;
+		delta.y += jump? .32f: shoot? .1f : 0.f;
 		m_airborne = true;
 	}
 	if (boostspeed)
@@ -79,7 +78,7 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
 	}
 
 	if (shoot) // Recoil!
-		TurnTopBottom(-1, 1.0f);
+		TurnTopBottom(-1);
 
 	return delta;
 }
@@ -123,18 +122,32 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
 	bt1 = world->BlockAt(GetPosition().x + input.x, GetPosition().y, GetPosition().z);
 	bt2 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 0.9f, GetPosition().z);
 	bt3 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 1.7f, GetPosition().z);
-	if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+	if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
-		m_velocity.y += .04f;
+		if (input.x > 0)
+			input.x = m_velocity.x = 0.5f;
+		else
+			input.x = m_velocity.x = -0.5f;
+		m_velocity.y = 0.3;
+		m_velocity.z *= .5f;
+	}
+	else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+		input.x = m_velocity.x = 0;
 		m_velocity.z *= .5f;
-		m_velocity.x *= .5f;
 	}
 
 	bt1 = world->BlockAt(GetPosition().x, GetPosition().y, GetPosition().z + input.z);
 	bt2 = world->BlockAt(GetPosition().x, GetPosition().y - 0.9f, GetPosition().z + input.z);
 	bt3 = world->BlockAt(GetPosition().x, GetPosition().y - 1.7f, GetPosition().z + input.z);
-	if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+	if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
-		m_velocity.y += .04f;
+		if (input.z > 0)
-		m_velocity.z *= .5f; 
+			input.z = m_velocity.z = 0.5f;
+		else
+			input.z = m_velocity.z = -0.5f;
+		m_velocity.y = 0.3;
+		m_velocity.x *= .5f;
+	}
+	else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+		input.z = m_velocity.z = 0;
 		m_velocity.x *= .5f;
 	}
 
@@ -142,8 +155,8 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
 	/* Gestion de la friction */
 
 	if (!m_airborne) {
-		m_velocity.x += input.x * (boostspeed ? 2.5f : 2.f) * elapsedTime;
+		m_velocity.x += input.x * 2.f * elapsedTime;
-		m_velocity.z += input.z * (boostspeed ? 2.5f : 2.f) * elapsedTime;
+		m_velocity.z += input.z * 2.f * elapsedTime;
 
 		if (input.x == 0.f)
 			m_velocity.x *= .8f;
@@ -161,7 +174,7 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
 	/* Fin gestion de la friction */
 
 	float vy = m_velocity.y;
-	m_velocity.y = boostspeed ? 0.f: 1.f; // Padding pour limiter le x et z lors du Normalize().
+	m_velocity.y = 1.f; // Padding pour limiter le x et z lors du Normalize().
 	if (m_velocity.Length() >= 1.f) m_velocity.Normalize(); // Limiteur de vitesse en x/z.
 	m_velocity.y = 0;
 	if (m_velocity.Length() < .005f) m_velocity.Zero(); // Threshold en x/z.
@@ -188,51 +201,33 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
 	return snd;
 }
 
-void Player::Put(Vector3f pos) {
-	m_position = pos;
-}
-
 void Player::ApplyTransformation(Transformation& transformation, bool rel, bool rot) const {
-
 	transformation.ApplyRotation(-m_rotX, 1, 0, 0);
 	transformation.ApplyRotation(-m_rotY, 0, 1, 0);
+	
+
 	if (rel) transformation.ApplyTranslation(-GetPOV());
+	
+
 }
 
-uint64_t Player::TakeBooster(std::unordered_map<uint64_t, Booster*> booster_table, float elapsedtime)
+void Player::GetBooster(Booster boosttype)
 {
-	uint64_t boostid = 0;
+	if (boosttype == SPEED)
-	Vector3f playerpos = GetPosition();
-	for (auto& [key, booster]: booster_table) {
-		Vector3f pos = booster->GetPosition();
-		if (booster->GetAvailability() && abs(playerpos.x - pos.x) <= 0.5f && abs(playerpos.y - pos.y) <= 1.0f && abs(playerpos.z - pos.z) <= 0.5f)
-		{
-			boostid = booster->GetId();
-			GetBooster(booster->GetType(), elapsedtime);
-			booster->SetAvailability(false);
-			break;
-		}
-	}
-	return boostid;
-}
-
-void Player::GetBooster(BOOST_TYPE boosttype, float elapsedtime)
-{
-	if (boosttype == BTYPE_SPEED)
 	{
 		boostspeed = true;
 		timeboostspeed = 0;
 	}
-	if (boosttype == BTYPE_HEAL)
+	if (boosttype == HEAL)
 	{
-		m_hp = 1.0f;
+		m_hp = 100;
 	}
-	if (boosttype == BTYPE_DAMAGE)
+	if (boosttype == DAMAGE)
 	{
 		boostdamage = true;
 		timeboostdamage = 0;
 	}
-	if (boosttype == BTYPE_INVINCIBLE)
+	if (boosttype == INVINCIBLE)
 	{
 		boostinvincible = true;
 		boostinvincible = 0;
@@ -243,17 +238,19 @@ void Player::RemoveBooster(float elapsedtime)
 	if (boostspeed)
 	{
 		timeboostspeed += elapsedtime;
-		if (timeboostspeed >= TIME_SPEED_BOOST && boostspeed == true)
+		if (timeboostspeed >= TIME_SPEED_BOOST)
 			boostspeed = false;
 	}
 	if (boostdamage)
 	{
-		if (timeboostdamage >= TIME_DAMAGE_BOOST && boostdamage == true)
+		timeboostdamage += elapsedtime;
+		if (timeboostdamage >= TIME_DAMAGE_BOOST)
 			boostdamage = false;
 	}
 	if (boostinvincible)
 	{
-		if (timeboostinvincible >= TIME_INVINCIBLE_BOOST && boostinvincible == true)
+		timeboostinvincible += elapsedtime;
+		if (timeboostinvincible >= TIME_INVINCIBLE_BOOST)
 			boostinvincible = false;
 	}
 }
@@ -273,24 +270,8 @@ Vector3f Player::GetDirection() const { return m_direction; }
 
 std::string Player::GetUsername() const { return m_username; }
 
-void Player::SetUsername(std::string username) {
-	m_username = username;
-}
-
-float Player::GetSensitivity() const {
-	return m_sensitivity;
-}
-
-void Player::SetSensitivity(float sensitivity) {
-	m_sensitivity = sensitivity;
-}
-
 float Player::GetHP() const { return m_hp; }
 
-void Player::SetHP(float hp) {
-	m_hp = hp;
-}
-
 void Player::Teleport(int& x, int& z) {
 	m_position.x -= x * CHUNK_SIZE_X;
 	m_position.z -= z * CHUNK_SIZE_Z;
@@ -304,6 +285,9 @@ void Player::InflictDamage(float hitPoints) {
 
 	if (m_hp < 0)
 		m_hp == 0;
+	//if (AmIDead())
+	//{ // Quand le joueur est mort.
+	//}
 }
 
 int Player::getScore() const { return m_score; }

SQCSim-common/player.h

@@ -2,11 +2,8 @@
 #define PLAYER_H__
 
 #include <cmath>
-#include <unordered_map>
 #include "transformation.h"
 #include "vector3.h"
-#include "booster.h"
-#include "define.h"
 
 
 class World; 
@@ -14,17 +11,16 @@ class World;
 class Player {
 public:
 	enum Sound { NOSOUND, STEP, FALL };
-	//enum BoosterType { SPEED, HEAL, DAMAGE, INVINCIBLE };
+	enum Booster { SPEED, HEAL, DAMAGE, INVINCIBLE };
 
 	Player(const Vector3f& position, float rotX = 0, float rotY = 0);
 	~Player();
 
-	void TurnLeftRight(float value, float sensitivity);
+	void TurnLeftRight(float value);
-	void TurnTopBottom(float value, float sensitivity);
+	void TurnTopBottom(float value);
 	Vector3f GetInput(bool front, bool back, bool left, bool right, bool jump, bool dash, float elapsedTime);
 	Sound ApplyPhysics(Vector3f input, World* world, float elapsedTime);
-	uint64_t TakeBooster(std::unordered_map<uint64_t, Booster*> booster_table, float elapsedTime);
+	void GetBooster(Booster boosttype);
-	void GetBooster(BOOST_TYPE boosttype, float elapsedTime);
 	void RemoveBooster(float elapsedtime);
 	void ApplyTransformation(Transformation& transformation, bool rel = true, bool rot = true) const;
 
@@ -36,11 +32,7 @@ public:
 	Vector3f GetVelocity() const;
 	Vector3f GetPOV() const;
 	std::string GetUsername() const;
-	void SetUsername(std::string username);
-	float GetSensitivity() const;
-	void SetSensitivity(float sensitivity);
 	float GetHP() const;
-	void SetHP(float hp);
 	void Teleport(int& x, int& z);
 
 	bool GetIsAirborne() const;
@@ -52,14 +44,6 @@ public:
 	std::string m_username;
 	bool m_hit = false;
 
-	bool Eulogy = false;
-
-	bool boostspeed = false;
-	bool boostdamage = false;
-	bool boostinvincible = false;
-
-	void Put(Vector3f pos);
-
 private:
 	uint64_t getId() const;
 
@@ -77,11 +61,15 @@ protected:
 	float timeboostspeed;
 	float timeboostdamage;
 	float timeboostinvincible;
-	float m_sensitivity;
 
 	float m_hp;
 
 	bool m_airborne;
+	bool boostspeed;
+	bool boostdamage;
+	bool boostinvincible;
+
+
 
 	Vector3f InterpolatePosition(const Vector3f& vec1, const Vector3f& vec2, const Timestamp& tim1, const Timestamp& tim2, const Timestamp& now);
 };

SQCSim-common/world.cpp

@@ -49,6 +49,8 @@ void World::RemoveChunk(int nbReduit)
 			if (x > WORLD_SIZE_X - nbReduit)
 				chk = m_chunks.Remove(x, y);
 
+			// TODO: MakeDirty() les voisins pour qu'ils se redessinent.
+
 			if (!chk)
 				continue;
 
@@ -165,6 +167,7 @@ void World::GetScope(unsigned int& x, unsigned int& y) {
 
 void World::Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]) {
 	UpdateWorld(player_pos, blockinfo);
+	//TransposeWorld(player_pos, bullets);
 }
 
 netprot::ChunkMod* World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block, bool net) {
@@ -255,6 +258,7 @@ void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]
 	int side = 0;
 	int threads = 0;
 	std::future<Chunk*> genThList[THREADS_GENERATE_CHUNKS];
+	//std::future<void> delThList[THREADS_DELETE_CHUNKS];
 	
 	if (frameGenerate > 0) --frameGenerate;
 	if (frameUpdate > 0) --frameUpdate;
@@ -345,6 +349,101 @@ void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]
 
 	side = 0;
 	threads = 0;
+
+	//if (!frameUpdate)
+	//	while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2) {
+	//		int tx = -side, ty = -side;
+
+	//		for (; tx <= side; ++tx) {
+	//			if (frameUpdate)
+	//				break;
+	//			unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
+	//			if (ChunkAt(chx, 1, chy) &&
+	//				ChunkAt(chx, 1, chy)->IsDirty()) {
+	//				updateThList[threads++] =
+	//					std::async(std::launch::async,
+	//						[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+	//							chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
+	//				if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
+	//			}
+	//		}
+	//		for (; ty <= side; ++ty) {
+	//			if (frameUpdate)
+	//				break;
+	//			unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
+	//			if (ChunkAt(chx, 1, chy) &&
+	//				ChunkAt(chx, 1, chy)->IsDirty()) {
+	//				updateThList[threads++] =
+	//					std::async(std::launch::async,
+	//						[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+	//							chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
+	//				if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
+	//			}
+	//		}
+	//		for (; tx >= -side; --tx) {
+	//			if (frameUpdate)
+	//				break;
+	//			unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
+	//			if (ChunkAt(chx, 1, chy) &&
+	//				ChunkAt(chx, 1, chy)->IsDirty()) {
+	//				updateThList[threads++] =
+	//					std::async(std::launch::async,
+	//						[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+	//							chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
+	//				if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
+	//			}
+	//		}
+	//		for (; ty >= -side; --ty) {
+	//			if (frameUpdate)
+	//				break;
+	//			unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
+	//			if (ChunkAt(chx, 1, chy) &&
+	//				ChunkAt(chx, 1, chy)->IsDirty()) {
+	//				updateThList[threads++] =
+	//					std::async(std::launch::async,
+	//						[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+	//							chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
+	//				if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
+	//			}
+	//		}
+	//		if (frameUpdate)
+	//			break;
+	//		++side;
+	//	}
+
+	//if (threads > 0) {
+	//	for (int i = 0; i < threads; ++i) {
+	//		updateThList[i].wait();
+	//		Chunk* chunk = updateThList[i].get();
+	//		chunk->FlushMeshToVBO();
+	//	}
+	//}
+
+	threads = 0;
+
+	//int del = THREADS_DELETE_CHUNKS;
+	//while (!m_tbDeleted.empty() && del--) { // Moins rapide que le bout en dessous, mais -beaucoup- plus stable.
+	//	m_tbDeleted.back()->FlushVBO();
+	//	m_tbDeleted.back()->~Chunk();
+	//	m_tbDeleted.pop_back();
+	//}
+
+	/*while (!m_tbDeleted.empty() && !frameDelete) {
+		if (m_tbDeleted.back()) {
+			m_tbDeleted.back()->FlushVBO();
+			delThList[threads] =
+				std::async(std::launch::async,
+					[](Chunk* chunk) { delete chunk; }, m_tbDeleted.back());
+			m_tbDeleted.pop_back();
+			if (++threads > THREADS_DELETE_CHUNKS) frameDelete = FRAMES_DELETE_CHUNKS;
+		}
+		else m_tbDeleted.pop_back();
+	}*/
+
+	/*for (int x = 0; x < threads; ++x) {
+		delThList[x].wait();
+		delThList[x].get();
+	}*/
 }
 
 int World::GettbDeleted() const { return m_tbDeleted.size(); }

SQCSim-srv/SQCSim-srv.vcxproj

@@ -48,7 +48,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>ClangCL</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>

SQCSim-srv/connection.cpp

@@ -59,9 +59,7 @@ void Connection::getPacks(SOCKET sock) {
 		switch (netprot::getType(pck, 1)) {
 			using enum netprot::PACKET_TYPE;
 		case INPUT:
-			if (player->AmIDead())
+			if (Deserialize(&in, pck, &bsize)) {
-				break;
-			else if (Deserialize(&in, pck, &bsize)) {
 				m_input_manifest[in.timestamp] = in;
 				m_input_vector.push_back(in);
 			}
@@ -79,23 +77,8 @@ void Connection::getPacks(SOCKET sock) {
 void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer) {
 	static int outs = 0;
 	static Timestamp last = 0;
-	static uint32_t lasttimer = timer;
-
-	if (m_output_vector.empty() && player->AmIDead()) {
-		if (timer != lasttimer) {
-			lasttimer = timer;
-			Sync sync;
-			sync.timestamp = sync.sid = m_loginfo.sid;
-			sync.hp = 0;
-			sync.ammo = -1;
-			sync.timer = timer;
-			sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
-		}
-	}
-
 	while (!m_output_vector.empty()) {
 		Output out = m_output_vector.front();
-		
 		for (auto& [key, conn] : conns) {
 			if (m_playinfo.id == conn->GetHash(false))
 				continue;
@@ -108,23 +91,16 @@ void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*
 
 		outs += out.timestamp + last;
 
-		static bool syncdead = false;
+		if (outs >= 1000) {
-		bool dead = player->AmIDead();
+			outs -= 1000;
-
-		if (outs >= SYNC_ACC || (!syncdead && dead)) {
 			Sync sync;
-			outs -= SYNC_ACC;
+			sync.hp = player->GetHP();
 			sync.timestamp = out.timestamp;
 			sync.position = out.position;
 			sync.sid = m_loginfo.sid;
 			sync.timer = timer;
 			sync.timestamp = out.timestamp;
 			sync.ammo = -1;
-			sync.hp = player->GetHP();
-			if (dead) {
-				sync.timestamp = m_loginfo.sid;
-				syncdead = true;
-			}
 			sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
 		}
 
@@ -132,47 +108,38 @@ void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*
 	}
 }
 
-Timestamp Connection::Run(World* world, std::unordered_map<uint64_t, Booster*> boosters) {
+Timestamp Connection::Run(World* world) {
 	Input in, last;
 	Output out;
 	Timestamp tstamp = 0;
 	float el;
 
-	bool dead = player->AmIDead();
+	if (m_input_manifest.size() < 2)
-
-	if (m_input_manifest.size() < 2 && !dead)
 		return tstamp;
 
-	while (m_last_in < m_input_vector.size() - 1 || dead) {
+	if (player->AmIDead()) {
-		if (!dead) {
+		m_input_manifest.clear();
-			in = m_input_vector.at(m_last_in + 1);
+		return tstamp;
-			last = m_input_vector.at(m_last_in);
+	}
-			if (in.timestamp <= m_tstamp) {
+
-				++m_last_in;
+	while (m_last_in < m_input_vector.size() - 1) {
-				continue;
+		in = m_input_vector.at(m_last_in + 1);
-			}
+		last = m_input_vector.at(m_last_in);
-			el = (double)(in.timestamp - last.timestamp) / 1000.;
+
-			if (m_shoot_acc > 0.) {
+		el = (double)(in.timestamp - last.timestamp) / 1000.;
-				m_shoot_acc -= el;
+
-				if (m_shoot_acc < 0.)
+		if (m_shoot_acc > 0.) {
-					m_shoot_acc = 0.;
+			m_shoot_acc -= el;
-			}
+			if (m_shoot_acc < 0.)
-			player->SetDirection(in.direction);
+				m_shoot_acc = 0;
 		}
-		else {
+
-			el = 1. / 60.;
+		player->SetDirection(in.direction);
-			in = Input();
-			
-		}
-		
 		player->ApplyPhysics(player->GetInput(in.keys.forward,
 			in.keys.backward,
 			in.keys.left,
 			in.keys.right,
-			in.keys.jump, false, el), 
+			in.keys.jump, false, el), world, el);
-			world, el);
-
-		player->TakeBooster(boosters, el);
 
 		if (player->GetPosition().y < -20.) {
 			player->InflictDamage(9000.);
@@ -180,10 +147,7 @@ Timestamp Connection::Run(World* world, std::unordered_map<uint64_t, Booster*> b
 		}
 
 		out.states.jumping = player->GetIsAirborne();
-
+		out.states.running = player->GetVelocity().Length() > .5f;
-		Vector3f horSpeed = player->GetVelocity();
-		horSpeed.y = 0;
-		out.states.running = horSpeed.Length() > .2f;
 		out.states.still = !out.states.running && !out.states.jumping;
 		out.states.hit = player->m_hit;
 		player->m_hit = false;
@@ -216,7 +180,7 @@ Timestamp Connection::Run(World* world, std::unordered_map<uint64_t, Booster*> b
 		else out.states.jumpshot = false;
 
 		if (in.keys.shoot && m_shoot_acc <= 0.) {
-			Bullets.emplace_back(new Bullet(player->GetPOV() + player->GetDirection(), player->GetDirection(), GetHash(true)));
+			Bullets.push_back(std::move(new Bullet(player->GetPOV() + player->GetDirection(), player->GetDirection(), GetHash(true))));
 			m_shoot_acc = BULLET_TIME;
 		}
 
@@ -226,12 +190,9 @@ Timestamp Connection::Run(World* world, std::unordered_map<uint64_t, Booster*> b
 		out.id = m_playinfo.id;
 		m_output_manifest[out.timestamp] = out;
 		m_output_vector.push_back(out);
-		m_tstamp = tstamp = out.timestamp;
+		tstamp = out.timestamp;
 
-		if (!dead)
+		++m_last_in;
-			++m_last_in;
-
-		dead = false;
 	}
 
 	return tstamp;

SQCSim-srv/connection.h

@@ -36,7 +36,7 @@ public:
 	void getPacks(SOCKET sock);
 	void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer);
 
-	Timestamp Run(World* world, std::unordered_map<uint64_t, Booster*> boosters);
+	Timestamp Run(World* world);
 
 	void CleanInputManifest(Timestamp time);
 	

SQCSim-srv/define.h

@@ -21,7 +21,6 @@ const std::vector<std::string> DEATHMESSAGES = { "@ has gone to meet their maker
 												 "So long, @, and thanks for all the lols!", 
 												 "@ has a bad case of being dead.",
 												 "@ has finally seen the light!",
-												 "$ sees dead people; in this case they see a dead @.",
 												 "Thought @ was hot; guess what? He's not. He is dead, dead, dead.",
 												 "@ did not want to live forever.",
 												 "$ made @ die for their country.",

SQCSim-srv/server.cpp

@@ -83,18 +83,18 @@ int Server::Ready() {
 			m_game.countdown = 0;
 		}
 	} while (m_game.countdown < 1);
-	// m_game.seed = 9370707;
+	m_game.seed = 9370707;
-	do {
+	/*do {
 		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);
+			std::stoi(m_buf.ptr);
 		}
 		catch (const std::exception& e) {
 			Log(e.what(), true, false);
 			m_game.seed = 0;
 		}
-	} while (m_game.seed < 1);
+	} while (m_game.seed < 1);*/
 	do {
 		Log("Entrez le nombre de joueurs: ", false, false);
 		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
@@ -108,17 +108,7 @@ int Server::Ready() {
 		if (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS)
 			Log("Nombre de joueurs invalide.", true, false);
 	} while (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS);
-	do {
+
-		Log("Entrez le nombre de boosters: ", false, false);
-		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
-		try {
-			m_boostcount = std::stoi(m_buf.ptr);
-		}
-		catch (const std::exception& e) {
-			Log(e.what(), true, false);
-			m_boostcount = -1;
-		}
-	} while (m_boostcount < 0);
 	m_game.gameType = 1;
 
 	if (listen(m_sock_tcp, MAX_CONNECTIONS) < 0) {
@@ -212,8 +202,8 @@ void Server::Run() {
 			m_conns.erase(key);
 			continue;
 		}
-		int x = (rand() % (CHUNK_SIZE_X * WORLD_SIZE_X - 1) - (CHUNK_SIZE_X * WORLD_SIZE_X / 2)) / 4,
+		int x = (rand() % (CHUNK_SIZE_X * WORLD_SIZE_X - 1) - (CHUNK_SIZE_X * WORLD_SIZE_X / 2)) / 8,
-			y = (rand() % (CHUNK_SIZE_Z * WORLD_SIZE_Y - 1) - (CHUNK_SIZE_Z * WORLD_SIZE_Y / 2)) / 4;
+			y = (rand() % (CHUNK_SIZE_Y * WORLD_SIZE_Y - 1) - (CHUNK_SIZE_Y * WORLD_SIZE_Y / 2)) / 8;
 		conn->player = new Player(Vector3f(x + .5f, CHUNK_SIZE_Y + 1.8f, y + .5f));
 		conn->player->m_username = conn->GetName();
 		m_players[key] = conn->player;
@@ -227,7 +217,7 @@ void Server::Run() {
 		sendPackTo<Sync>(m_sock_udp, &sync, &m_buf, conn->getAddr());
 	}
 	
-	int timer = m_game.countdown, timer_acc = 0, deadplayers = 0;
+	int timer = m_game.countdown, sync_acc = 0, deadplayers = 0;
 	std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
 	Timestamp last = 0;
 	std::vector<Chat*> chatlog;
@@ -235,41 +225,27 @@ void Server::Run() {
 	std::vector<Bullet*> bullets;
 	std::vector<std::vector<Bullet*>::iterator> bullit;
 	std::vector<BulletAdd*> netbull;
-	std::vector<PickupMod*> netboosters;
 	std::vector<char*> lsPck;
 
-	int max = 0;
-	for (int64_t x = 0; x < m_boostcount; ++x) {
-		Vector3f pos = Vector3f(rand() % (WORLD_SIZE_X * CHUNK_SIZE_X) + .5f, rand() % CHUNK_SIZE_Y + .5f, rand() % (WORLD_SIZE_Y * CHUNK_SIZE_Z) + .5f);
-		if (m_world->BlockAt(pos) == BTYPE_AIR && m_world->BlockAt(Vector3f(pos.x, pos.y - 2, pos.z)) != BTYPE_AIR) {
-			Booster* boost = new Booster(pos, (BOOST_TYPE)(rand() % BTYPE_BOOST_LAST), getUniqueId());
-			m_boosters[boost->GetId()] = boost;
-		}
-		else --x;
-		if (++max > 100000)
-			break;
-	}
-
 	Chat* startchat = new Chat();
 	startchat->src_id = 0;
 	char startmess[] = "How would -YOU- like to die today, motherf-words?";
-	float endtime = 0.;
+
 	strcpy(startchat->mess, 140, startmess);
 
 	chatlog.emplace_back(startchat);
 		
-	while (!endgame && endtime < 1.) {
+	while (!endgame) {
 		using namespace std::chrono;
 		Timestamp tstamp = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();
 
 		if (last == 0)
 			last = tstamp;
-		timer_acc += tstamp - last;
+		sync_acc += tstamp - last;
-		if (timer_acc >= 1000) {
+		if (sync_acc >= 1000) {
-			while (timer_acc >= 1000)
+			while (sync_acc >= 1000)
-				timer_acc -= 1000;
+				sync_acc -= 1000;
-			if (!endgame)
+			--timer;
-				--timer;
 			std::string str = "Timer: ";
 			Log(str.append(std::to_string(timer)), false, false);
 		}
@@ -299,42 +275,34 @@ void Server::Run() {
 				default: break;
 				}
 			}
-			if (!lsPck.empty())
+			lsPck.clear();
-				lsPck.clear();
 
 			/* Process */
 
 			if (conn->m_nsync) {
-				Timestamp tstamp = conn->Run(m_world, m_boosters);
+				Timestamp tstamp = conn->Run(m_world);
 
-				if (conn->player->AmIDead() && !conn->player->Eulogy) {
+				if (conn->player->AmIDead()) {
 					Chat* chat = new Chat();
-					chat->dest_id = chat->dest_team_id = chat->src_id = 0;
+					chat->dest_id = chat->dest_team_id =  chat->src_id = 0;
 
-					Player* murderer = m_conns.at(conn->player->Killer)->player;
+					std::string killer = m_conns.at(conn->player->Killer)->player->GetUsername();
-
-					if (murderer != conn->player)
-						murderer->addPoint();
-
-					std::string killer = murderer->GetUsername();
 					
 					std::string mess = getDeathMessage(conn->player->GetUsername(), killer);
 					
 					strcpy(chat->mess, 140, mess.c_str());
 					chatlog.emplace_back(chat);
 					++deadplayers;
-
-					conn->player->Eulogy = true;
 					conn->m_nsync = false;
 				}
 				else {
 					for (auto& chmo : conn->ChunkDiffs)
 						chunkdiffs.emplace_back(std::move(chmo));
-					if (!conn->ChunkDiffs.empty())
+					conn->ChunkDiffs.clear();
-						conn->ChunkDiffs.clear();
 
 					for (auto& bull : conn->Bullets) {
 						bullets.emplace_back(bull);
+						//Log("POW!", false, false);
 						BulletAdd* nbul = new BulletAdd();
 						nbul->pos = bull->getPos();
 						nbul->dir = bull->getVel();
@@ -343,126 +311,53 @@ void Server::Run() {
 
 						netbull.emplace_back(std::move(nbul));
 					}
-					if (!conn->Bullets.empty())
+					conn->Bullets.clear();
-						conn->Bullets.clear();
 				}
+
+				/* Out */
+
+				conn->sendPacks(m_sock_udp, m_conns, timer);
 			}
-			/* Out */
+			if ((deadplayers == players - 1 && deadplayers != 0) || timer <= 0)
-			conn->sendPacks(m_sock_udp, m_conns, timer);
-
-			if ((deadplayers == players - 1 && deadplayers != 0) || timer < 0) {
-				if (!endgame) {
-					Chat* gameover = new Chat();
-					gameover->dest_id = gameover->dest_team_id = gameover->src_id = 0;
-					std::string winner, winmess;
-					int score = 0; 
-					bool plural = false;
-					for (auto& [key, conn] : m_conns) {
-						if (conn->player->getScore() > score) {
-							winner = conn->player->GetUsername();
-							score = conn->player->getScore();
-							plural = false;
-						}
-						else if (conn->player->getScore() == score) {
-							winner = winner.append(" and ").append(conn->player->GetUsername());
-							plural = true;
-						}
-					}
-
-					winmess = "And the winner";
-					if (!plural)
-						winmess = winmess.append(" is ");
-					else winmess = winmess.append("s are ");
-				
-					winmess = winmess.append(winner).append(" with ").append(std::to_string(score)).append(" point");
-
-					if (score > 1)
-						winmess = winmess.append("s.");
-					else winmess = winmess.append(".");
-
-					strcpy(gameover->mess, 140, winmess.c_str());
-					
-					chatlog.emplace_back(gameover);
-				}
 				endgame = true;
-				endtime += .001;
-			}
 		}
-
+		
-		int max = 0;
-		for (auto& [key, booster] : m_boosters) {
-			if (booster->modified) {
-				PickupMod pmod;
-				pmod.available = booster->GetAvailability();
-				pmod.id = booster->GetId();
-				pmod.pos = booster->GetPosition();
-
-				Boosts boost;
-				switch (booster->GetType()) {
-				case BTYPE_DAMAGE:
-					boost.damage = true;
-					break;
-				case BTYPE_HEAL:
-					boost.hp = true;
-					break;
-				case BTYPE_INVINCIBLE:
-					boost.invincible = true;
-					break;
-				default: continue;
-				}
-				pmod.boost = boost;
-				booster->modified = false;
-				for (auto& [key, conn] : m_conns)
-					sendPackTo<PickupMod>(m_sock_udp, &pmod, &m_buf, conn->getAddr());
-				max++;
-				if (max > 5)
-					break;
-			}
-		}
-
 		for (auto& bull : netbull) {
 			for (auto& [key, conn] : m_conns)
 				if (bull->id != conn->GetHash(false)) // Pour pas repitcher au joueur sa propre balle.
 					sendPackTo<BulletAdd>(m_sock_udp, bull, &m_buf, conn->getAddr());
 			delete bull;
 		}
-		if (!netbull.empty())
+		netbull.clear();
-			netbull.clear();
+		
-
 		for (auto bull = bullets.begin(); bull != bullets.end(); ++bull) {
 			ChunkMod* cmod = nullptr;
 			Bullet* bullet = *bull;
-			if (bullet->Update(m_world, (1. / 60.), 50, m_players, &cmod)) {
+			if (bullet->Update(m_world, (1. / 60.), 20, m_players, &cmod)) {
 				if (cmod)
 					chunkdiffs.emplace_back(cmod);
 				bullit.push_back(bull);
+				delete bullet;
 			}
 		}
-
+		for (auto& bull: bullit)
-		for (auto& bull : bullit) {
-			delete* bull;
 			bullets.erase(bull);
-		}
+		bullit.clear();
-
-		if (!bullit.empty())
-			bullit.clear();
 
 		for (auto& chat : chatlog) {
-			Log(chat->mess, false, false);
+				Log(chat->mess, false, false);
 			for (auto& [key, conn] : m_conns) 
 				sendPackTo<Chat>(m_sock_udp, chat, &m_buf, conn->getAddr());
 			delete chat;
 		}
-		if (!chatlog.empty())
+		chatlog.clear();
-			chatlog.clear();
 
 		for (auto& chmo : chunkdiffs) {
 			for (auto& [key, conn] : m_conns)
 				sendPackTo<ChunkMod>(m_sock_udp, chmo, &m_buf, conn->getAddr());
 			delete chmo;
 		}
-		if (!chunkdiffs.empty())
+		chunkdiffs.clear();
-			chunkdiffs.clear();
 	}
 
 	Chat end;
@@ -472,7 +367,8 @@ void Server::Run() {
 
 	for (auto& [key, conn] : m_conns) {
 		std::string str = conn->player->GetUsername();
-		Log(str.append(" ").append(std::to_string(conn->player->getScore())), false, false);
+		Log(str.append(" ").append(std::to_string(conn->player->GetHP())), false, false);
+		
 	}
 
 	for (auto& [key, conn] : m_conns)

SQCSim-srv/server.h

@@ -43,15 +43,12 @@ private:
 	std::unordered_map<uint64_t, Player*> m_players;
 	std::unordered_map<uint64_t, Connection*> m_conns;
 	std::unordered_map<Timestamp, Chat> m_chatlog;
-	std::unordered_map<uint64_t, Booster*> m_boosters;
 	std::vector<uint64_t> m_ids;
 	GameInfo m_game;
 
 	World* m_world = nullptr;
 	bool m_exit = true;
 
-	int64_t m_boostcount = -1;
-
 	std::string LogTimestamp();
 	void Log(std::string str, bool is_error, bool is_fatal);
 	void buildIdList(size_t size);

SQCSim2021/SQCSim2021.vcxproj

@@ -20,6 +20,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="audio.h" />
+    <ClInclude Include="booster.h" />
     <ClInclude Include="connector.h" />
     <ClInclude Include="define.h" />
     <ClInclude Include="engine.h" />
@@ -37,6 +38,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="audio.cpp" />
+    <ClCompile Include="booster.cpp" />
     <ClCompile Include="connector.cpp" />
     <ClCompile Include="engine.cpp" />
     <ClCompile Include="main.cpp" />
@@ -89,7 +91,7 @@
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>ClangCL</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -194,7 +196,7 @@
       <FloatingPointModel>Fast</FloatingPointModel>
     </ClCompile>
     <Link>
-      <SubSystem>Windows</SubSystem>
+      <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>

SQCSim2021/SQCSim2021.vcxproj.filters

@@ -53,6 +53,9 @@
     <ClInclude Include="remoteplayer.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
+    <ClInclude Include="booster.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
     <ClInclude Include="settings.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
@@ -100,6 +103,9 @@
     <ClCompile Include="remoteplayer.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
+    <ClCompile Include="booster.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
     <ClCompile Include="settings.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>

SQCSim2021/audio.cpp

@@ -2,40 +2,26 @@
 
 Audio::Audio() {
 	m_engine = irrklang::createIrrKlangDevice();
-	m_engine->setDopplerEffectParameters(1);
+	m_engine->setDopplerEffectParameters(10);
-	m_engine->setRolloffFactor(1);
+	m_engine->setRolloffFactor(2);
-	m_engine->setDefault3DSoundMinDistance(1);
+	m_engine->setDefault3DSoundMinDistance(.1);
 	m_engine->setDefault3DSoundMaxDistance(1000);
 }
 
-Audio::Audio(const char * music, const char* menumusic) {
+Audio::Audio(const char * music) {
 	m_engine = irrklang::createIrrKlangDevice();
 	m_engine->setDopplerEffectParameters(1);
-	m_engine->setRolloffFactor(1);
+	m_engine->setRolloffFactor(2);
-	m_engine->setDefault3DSoundMinDistance(1);
+	m_engine->setDefault3DSoundMinDistance(.1);
-	m_engine->setDefault3DSoundMaxDistance(100);
+	m_engine->setDefault3DSoundMaxDistance(1000);
 	m_music = m_engine->play2D(music, true, true, true, irrklang::ESM_STREAMING);
-	m_menumusic = m_engine->play2D(menumusic, true, true, true, irrklang::ESM_STREAMING);
-	m_music->setVolume(.5);
-	m_menumusic->setVolume(.5);
-	m_mainvolume = 0.5f;
-	m_engine->setSoundVolume(m_mainvolume);
-	m_sfxvolume = 0.5f;
 }
 
 Audio::~Audio() { 
 	if (m_music) m_music->drop();
-	if (m_menumusic) m_menumusic->drop();
 	if (m_engine) m_engine->drop();
 }
 
-void Audio::playSound(const char* name, float volume = 1.) {
-	irrklang::ISound* sfx = m_engine->play2D(name, false, true);
-	sfx->setVolume(volume);
-	sfx->setIsPaused(false);
-	m_sfxes.push_back(sfx);
-}
-
 void Audio::Update3DAudio(Vector3f pos, Vector3f dir, Vector3f vel) {
 	m_engine->setListenerPosition(irrklang::vec3df(pos.x, pos.y, pos.z),
 								  irrklang::vec3df(dir.x, dir.y, dir.z),
@@ -43,10 +29,9 @@ void Audio::Update3DAudio(Vector3f pos, Vector3f dir, Vector3f vel) {
 }
 
 irrklang::ISound* Audio::Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped = false, float volume = 1) {
-	sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), is_looped, true, true, is_looped? irrklang::ESM_STREAMING: irrklang::ESM_NO_STREAMING, true);
+	sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), is_looped, false, true, is_looped? irrklang::ESM_STREAMING: irrklang::ESM_NO_STREAMING, true);
 	sound->setVelocity(irrklang::vec3df(vel.x, vel.y, vel.z));
 	sound->setVolume(volume);
-	sound->setIsPaused(false);
 	return sound;
 }
 
@@ -60,76 +45,10 @@ void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& v
 //	m_music = m_engine->play2D(music, false, false, false, irrklang::ESM_STREAMING);
 //}
 
-void Audio::CleanupSFX() {
+void Audio::ToggleMusicState() { m_music->setIsPaused(!m_music->getIsPaused()); }
-	while (!m_sfxes.empty()) {
-		irrklang::ISound* sfx = m_sfxes.back();
-		if (sfx->isFinished()) {
-			sfx->drop(); // drop() fait deja la job du delete sfx.
-		}
-		else break;
-		m_sfxes.pop_back();
-	}
-}
-
-void Audio::ToggleMusicState(GameState state) {
-	if (m_music_on) {
-		switch (state) {
-		case PLAY:
-			m_music->setIsPaused(false);
-			m_menumusic->setIsPaused(true);
-			break;
-		case PAUSE:
-			m_music->setIsPaused(true);
-			m_menumusic->setIsPaused(true);
-			break;
-		default:
-			m_music->setIsPaused(true);
-			m_menumusic->setIsPaused(false);
-			break;
-		}
-	}
-	else {
-		m_music->setIsPaused(true);
-		m_menumusic->setIsPaused(true);
-	}
-}
-
-void Audio::SetMusic(bool ison, GameState state) {
-	m_music_on = state;
-	if (!state) {
-		m_music->setIsPaused(true);
-		m_menumusic->setIsPaused(true);
-	}
-	else ToggleMusicState(state);
-}
-
-bool Audio::GetMusic() {
-	return m_music_on;
-}
 
 void Audio::PauseEngine() { m_engine->setAllSoundsPaused(); }
 
 float Audio::GetMusicVolume() const {
 	return m_music->getVolume();
 }
-
-void Audio::SetMusicVolume(float volume) {
-	m_music->setVolume(volume);
-	m_menumusic->setVolume(volume);
-}
-
-float Audio::GetMainVolume() const {
-	return m_engine->getSoundVolume();
-}
-
-void Audio::SetMainVolume(float volume) {
-	m_engine->setSoundVolume(volume);
-}
-
-float Audio::GetSfxVolume() const {
-	return m_sfxvolume;
-}
-
-void Audio::SetSfxVolume(float volume) {
-	m_sfxvolume = volume;
-}

SQCSim2021/audio.h

@@ -15,46 +15,26 @@
 class Audio {
 private:
 	irrklang::ISound* m_music;
-	irrklang::ISound* m_menumusic;
-	float m_mainvolume;
-	float m_sfxvolume;
-	bool m_music_on = true;
-	std::vector<irrklang::ISound*> m_sfxes;
 
 public:
 	Audio();
-	Audio(const char* music, const char* menumusic);
+	Audio(const char* music);
 	~Audio();
 	irrklang::ISoundEngine* m_engine;
 
 	void Update3DAudio(Vector3f pos, Vector3f dir, Vector3f speed);
 
-
 	irrklang::ISound* Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped, float volume);
 
 	void Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume);
 
 	//void PlaySong(const char* music);
 
-	void CleanupSFX();
+	void ToggleMusicState();
-
-	void ToggleMusicState(GameState state);
-
-	void playSound(const char* sound, float volume);
-
-	void SetMusic(bool ison, GameState state);
-	bool GetMusic();
 
 	void PauseEngine();
 
-	float GetMainVolume() const;
-	void SetMainVolume(float volume);
-
 	float GetMusicVolume() const;
-	void SetMusicVolume(float volume);
-
-	float GetSfxVolume() const;
-	void SetSfxVolume(float volume);
 };
 
 #endif // AUDIO_H__

SQCSim2021/booster.cpp

@@ -0,0 +1,46 @@
+#include "booster.h"
+
+void Booster::RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas,  Shader& shader, Transformation tran)
+{
+	//
+	//Vector3f playerToQuad = m_player.GetPosition() - m_position;
+	//playerToQuad.Normalize();
+	//Vector3f targetPosition = m_player.GetPosition() + playerToQuad * 10.0f;
+	//Matrix4f rotationMatrix;
+	//rotationMatrix.SetLookAt(m_position, targetPosition, Vector3f(0, 1, 0));
+	//glMultMatrixf(rotationMatrix.GetInternalValues());
+	float x = pos.x;
+	float y = pos.y;
+	float z = pos.z;
+	float width = 1.0f;
+	float height = 1.0f;
+	//Pt override les collisions.. a ce point la je sais pas quoi faire
+
+	//Matrix4 mat4 = tran.GetMatrix();
+	//mat4 VP = pMatrix * vMatrix;
+	//Vector3f CameraRight = Vector3f(mat4.Get11(), mat4.Get21(), mat4.Get31());
+	//Vector3f CameraUp = Vector3f(mat4.Get12(), mat4.Get22(), mat4.Get32());
+
+	//Vector3f v1 = (m_position + CameraRight * 0.5 * width + CameraUp * -0.5 * width);
+	//Vector3f v2 = (m_position + CameraRight * 0.5 * width + CameraUp * 0.5 * width);
+	//Vector3f v4 = (m_position + CameraRight * -0.5 * width + CameraUp * -0.5 * width);
+	//Vector3f v3 = (m_position + CameraRight * -0.5 * width + CameraUp * 0.5 * width);
+
+	//tran.ApplyTranslation(m_position);
+	float u, v, w, h;
+	//glDisable(GL_DEPTH_TEST);
+	shader.Use();
+	textureAtlas.Bind();
+	textureAtlas.TextureIndexToCoord(8, u, v, w, h);
+	//glLoadIdentity();
+	glLoadMatrixf(tran.GetMatrix().GetInternalValues());
+	glBegin(GL_QUADS);
+	glTexCoord2f(u, v); glVertex3f(x - width / 2., y - height, z); //glVertex3f(v4.x, v4.y, v4.z);//glVertex3f(0, 50, 0);
+	glTexCoord2f(u + w, v); glVertex3f(x + width / 2., y - height, z); //glVertex3f(v3.x, v3.y, v3.z); //glVertex3f(50,50, 0);
+	glTexCoord2f(u + w, v + h); glVertex3f(x + width / 2., y, z); //glVertex3f(v2.x, v2.y, v2.z); //glVertex3f(50, 0, 0);
+	glTexCoord2f(u, v + h); glVertex3f(x - width / 2., y, z); //glVertex3f(v1.x, v1.y, v1.z);// glVertex3f(0, 0, 0);
+	glEnd();
+	shader.Disable();
+	//tran.ApplyTranslation(-m_position);
+	//glEnable(GL_DEPTH_TEST);
+}

SQCSim2021/booster.h

@@ -0,0 +1,14 @@
+#ifndef BOOSTER_H__
+#define BOOSTER_H__
+#include "define.h"
+#include "textureatlas.h"
+#include "shader.h"
+#include "../SQCSim-common/vector3.h"
+#include "../SQCSim-common/transformation.h"
+
+
+class Booster {
+public:
+	void RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas,  Shader& shader, Transformation tran);
+};
+#endif

SQCSim2021/define.h

@@ -25,8 +25,8 @@
 
 #define BULLET_UPDATES_PER_FRAME 20
 
-#define BASE_WIDTH 1280
+#define BASE_WIDTH 640
-#define BASE_HEIGHT 720
+#define BASE_HEIGHT 480
 
 
 #define ANIME_PATH_JUMP		"./media/textures/AssetOtherPlayer/FinalPNGJumping/"
@@ -50,6 +50,7 @@ enum GameState {
 	SPLASH,
 	LOBBY,
 	OPTIONS,
+	QUIT,
 	PLAY, 
 	PAUSE
 };
@@ -58,7 +59,7 @@ enum Resolution {
 	HD = 0,		// 1280x720	 (High Definition)
 	FHD,		// 1920x1080 (Full HD)
 	QHD,		// 2560x1440 (Quad HD)
-	UHD,		// 3840x2160 (Ultra HD)
+	UHD			// 3840x2160 (Ultra HD)
 };
 
 #endif // DEFINE_H__

SQCSim2021/docs/analyse_serveur.md

@@ -0,0 +1 @@
+

SQCSim2021/engine.h

@@ -14,7 +14,6 @@
 #include "../SQCSim-common/world.h"
 #include "../SQCSim-common/transformation.h"
 #include "../SQCSim-common/player.h"
-#include "../SQCSim-common/booster.h"
 #include "define.h"
 #include "openglcontext.h"
 #include "texture.h"
@@ -25,15 +24,13 @@
 #include "connector.h"
 #include "renderer.h"
 #include "remoteplayer.h"
+#include "booster.h"
 #include "settings.h"
 
 class Engine : public OpenglContext {
 public:
     Engine();
     virtual ~Engine();
-
-
-
     virtual void Init();
     virtual void DeInit();
     virtual void LoadResource();
@@ -42,8 +39,8 @@ public:
     virtual void KeyPressEvent(unsigned char key);
     virtual void KeyReleaseEvent(unsigned char key);
     virtual void MouseMoveEvent(int x, int y);
-    virtual void MousePressEvent(const MOUSE_BUTTON& button, int x, int y);
+    virtual void MousePressEvent(const MOUSE_BUTTON &button, int x, int y);
-    virtual void MouseReleaseEvent(const MOUSE_BUTTON& button, int x, int y);
+    virtual void MouseReleaseEvent(const MOUSE_BUTTON &button, int x, int y);
 
 private:
     int GetFps(float elapsedTime) const;
@@ -52,14 +49,12 @@ private:
     bool StartMultiplayerGame();
 
     bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps = true, bool stopOnError = true);
-    void ChangeResolution(Resolution resolution);
 
     void InstantDamage();
     void SystemNotification(std::string systemLog);
     void KillNotification(Player killer, Player killed);
 
     void DisplayNotification(std::string message);
-
     void DisplayCrosshair();
     void DisplayPovGun();
     void DisplayCurrentItem();
@@ -78,8 +73,6 @@ private:
     void SetPlayerUsername(float elapsedTime);
     void SetServerAddress(float elapsedTime);
 
-    void DisplayPauseMenu(float elapsedTime);
-
     void DisplayOptionsMenu();
     void DisplayAudioMenu(float centerX, float centerY);
     void DisplayGraphicsMenu(float centerX, float centerY);
@@ -93,7 +86,8 @@ private:
     char SimulateKeyboard(unsigned char key);
     void HandlePlayerInput(float elapsedTime);
 
-    Audio m_audio = Audio(AUDIO_PATH "music01.wav", AUDIO_PATH "menumusic01.wav");
+    //udio m_menuaudio = Audio(AUDIO_PATH "menumusic.wav");
+    Audio m_audio = Audio(AUDIO_PATH "music01.wav");
     irrklang::ISound* m_powpow, * m_scream;
     irrklang::ISound* m_whoosh[MAX_BULLETS];
 
@@ -107,8 +101,10 @@ private:
 
     Renderer m_renderer = Renderer();
 
+    Booster m_booster = Booster();
     BlockInfo* m_blockinfo[BTYPE_LAST];
     BoostInfo* m_boostinfo[BTYPE_BOOST_LAST];
+
     GameState m_gamestate = GameState::SPLASH;
 
     Shader m_shader01;
@@ -142,9 +138,6 @@ private:
     Texture m_textureCheck;
     Texture m_textureChecked;
 
-    Texture m_texturePauseResume;
-    Texture m_texturePauseMainMenu;
-
     Texture m_textureOptAudio;
     Texture m_textureOptBack;
     Texture m_textureOptGameplay;
@@ -171,27 +164,24 @@ private:
     float m_splashTime = 2.0f;
     float m_scale;
     float m_time = 0;
-
     float m_titleX = 0;
     float m_titleY = 0;
 
-
-
     int m_renderCount = 0;
     int m_countdown = COUNTDOWN;
     int m_nbReductionChunk = 4;
     int m_timerReductionChunk = 30;
 
-    float m_mainvolume;
+    float m_volPrincipal = 0.0f;
-    float m_musicvolume;
+    float m_volMusique = 0.0f;
-    float m_sfxvolume;
+    float m_volEffets = 0.0f;
-    float m_sensitivity;
+    float m_volSensible = 0.0f;
 
     int m_selectedOption = 0;
 
     bool m_selectedOptAudioMainBar = false;
     bool m_selectedOptAudioMusicBar = false;
-    bool m_selectedOptAudioSfxBar = false;
+	bool m_selectedOptAudioSfxBar = false;
     bool m_selectedGameplaySensitivityBar = false;
 
     bool m_damage = false;
@@ -214,21 +204,15 @@ private:
     std::string m_currentInputString;
     std::string m_username;
     std::string m_serverAddr;
-
     char m_inputChar = 0;
     bool m_invalidChar = false;
     bool m_charChanged = false;
     bool m_settingUsername = false;
     bool m_settingServer = false;
-    bool m_selectedSinglePlayer = false;
-    bool m_selectedMultiPlayer = false;
-    bool m_singleReady = false;
     bool m_multiReady = false;
-
+    
-
     bool m_key1 = false;
     bool m_key2 = false;
-
     bool m_keyK = false;
     bool m_keyL = false;
     bool m_keyW = false;
@@ -250,19 +234,16 @@ private:
     float m_mousemy = 0;
 
     bool m_networkgame = false;
-
+    
     Connector m_conn;
     std::deque<netprot::ChunkMod*> m_chunkmod_manifest;
     std::chrono::high_resolution_clock::time_point m_startTime;
     std::unordered_map<uint64_t, Player*> m_players;
-    std::set<uint64_t> m_deadplayers;
     netprot::Buffer m_buf, m_bufout;
     netprot::ChunkMod* m_chunkmod = nullptr;
-    std::unordered_map<uint64_t, Booster*> m_boosters;
-    std::set<uint64_t> m_boost_manifest;
 
     std::unordered_map<uint64_t, netprot::Sync> m_syncs;
     std::string m_messageNotification = "";
 };
 
-#endif // ENGINE_H__
+#endif // ENGINE_H__

SQCSim2021/openglcontext.h

@@ -53,9 +53,9 @@ protected:
     void ShowCrossCursor() const;
 
     bool m_istarted = false;
-    void InitWindow(int width, int height);
 
 private:
+    void InitWindow(int width, int height);
     MOUSE_BUTTON ConvertMouseButton(sf::Mouse::Button button) const;
 
 private:

SQCSim2021/remoteplayer.cpp

@@ -8,11 +8,11 @@
 
 
 
-RemotePlayer::RemotePlayer(netprot::PlayerInfo* pinfo) : m_pinfo(*pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(Vector3f(0, 0, 0)) {
+RemotePlayer::RemotePlayer(netprot::PlayerInfo pinfo) : m_pinfo(pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(Vector3f(0, 0, 0)){
 
 }
 
-RemotePlayer::RemotePlayer(netprot::PlayerInfo* pinfo, const Vector3f& pos) : m_pinfo(*pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(pos) {
+RemotePlayer::RemotePlayer(netprot::PlayerInfo pinfo, const Vector3f& pos) : m_pinfo(pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(pos) {
 
 }
 
@@ -24,16 +24,61 @@ RemotePlayer::~RemotePlayer()
 
 void RemotePlayer::Init()
 {
-
+	
 }
 
 void RemotePlayer::Feed(const netprot::Output out) {
 
 	m_position = Vector3f(out.position);
 	m_direction = Vector3f(out.direction);
-	current.states = out.states;
-	
 
+	current.states = out.states;
+
+	//current.position = out.position;
+	//current.direction = out.direction;
+	//current.states = out.states;
+	//current.id = out.id;
+
+	//if (current.position != previous.position)
+	//{
+	//	Vector3f positionDelta = current.position - previous.position;
+	//	m_position = current.position + positionDelta;
+	//	m_direction = current.direction;		
+
+	//}
+
+	//if(current.direction != previous.direction)
+	//{
+	//	m_direction = current.direction;
+	//	current.direction = current.direction;
+	//}
+
+	//if (current.states.shooting) {
+	//	m_animstate = Anim::SHOOTING;
+	//}
+	//else if (current.states.jumping) {
+	//	m_animstate = Anim::JUMPING;
+	//}
+	//else if (current.states.dead) {
+	//	m_animstate = Anim::DEAD;
+	//}
+	//else if(current.states.powerup){
+	//	m_animstate = Anim::POWERUP;
+	//}
+	//else if (current.states.still) {
+	//	m_animstate = Anim::STILL;
+	//}
+	//else if (current.states.running) {
+	//	m_animstate = Anim::RUNNING;
+	//}
+
+	//previous.direction = current.direction;
+	//previous.position = current.position;
+	//previous.states = current.states;
+	//previous.id = current.id;
+
+	//m_direction = current.direction;
+	//m_position = current.position;
 }
 
 
@@ -63,7 +108,7 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 
 	Vector3f angleRemote = GetDirection();
 	Vector3f angleCam = (v1 - v2).Cross(v3 - v2);
-
+	
 	angleCam.y = 0;
 	angleRemote.y = 0;
 	angleCam.Normalize();
@@ -73,25 +118,26 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 	int index = 0;
 	angle = -angle;
 	Vector3f side = angleRemote.Cross(angleCam);
-	side = -side;
 
 	static float time = 0.f;
 	static bool Shooting = false;
 	bool isLeft = side.y > 0;
 
 	time += elapsedTime;
-	if (time >= 0.05)
+	if (time >= 200)
 	{
-		time -= 0.05;
+			time -= 200;
-
+		if (!current.states.shooting)
-		Shooting = !Shooting;
+			Shooting = false;
+		else 
+			Shooting = !Shooting;
 	}
-	
+
-	//std::cout << "shooting : " << current.states.shooting << " jumping : " << current.states.jumping <<  " jumpshot : " << current.states.jumpshot << " running : " << current.states.running << " still : " << current.states.still << " dead : " << current.states.dead << " hit : " << current.states.hit << std::endl;
+
 
 	if (angle >= 0.75) //Face - side positif
 	{
-		if (current.states.shooting) {
+		if(current.states.shooting){
 			if (Shooting)
 				index = 17;
 			else
@@ -105,7 +151,7 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 		}
 		else if (current.states.jumping)
 			index = 25;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 0;
 
 	}
@@ -116,7 +162,6 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 				index = 18;
 			else
 				index = 10;
-
 		}
 		else if (current.states.jumpshot) {
 			if (Shooting)
@@ -124,12 +169,11 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 			else
 				index = 34;
 		}
-		else if (current.states.jumping)
+		else if (current.states.jumping )
 			index = 26;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 1;
-
+		
-
 	}
 	else if (angle >= -0.25 && isLeft) //ProfileLeft
 	{
@@ -138,20 +182,18 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 				index = 20;
 			else
 				index = 12;
-
 		}
-		else if (current.states.jumpshot) {
+		else if (current.states.jumpshot ) {
 			if (Shooting)
 				index = 44;
 			else
 				index = 36;
 		}
-		else if (current.states.jumping)
+		else if (current.states.jumping )
 			index = 28;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 3;
-
+		
-
 	}
 	else if (angle >= -0.75 && isLeft) //BackLeft
 	{
@@ -160,7 +202,6 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 				index = 22;
 			else
 				index = 14;
-
 		}
 		else if (current.states.jumpshot) {
 			if (Shooting)
@@ -170,10 +211,8 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 		}
 		else if (current.states.jumping)
 			index = 30;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 5;
-
-
 	}
 	else if (angle < -0.75) //Dos - side négatif
 	{
@@ -182,7 +221,6 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 				index = 24;
 			else
 				index = 16;
-
 		}
 		else if (current.states.jumpshot) {
 			if (Shooting)
@@ -190,14 +228,13 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 			else
 				index = 40;
 		}
-		else if (current.states.jumping)
+		else if (current.states.jumping )
 			index = 32;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 7;
-
+		
-
 	}
-	else if (angle >= 0.25 && !isLeft) //FrontRight //REVOIR L'ANIME DE SHOOTING EST PAS DRETTE
+	else if (angle >= 0.25 && !isLeft) //FrontRight
 	{
 		if (current.states.shooting) {
 			if (Shooting)
@@ -213,10 +250,9 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 		}
 		else if (current.states.jumping)
 			index = 27;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 2;
 
-
 	}
 	else if (angle >= -0.25 && !isLeft) //ProfileRight
 	{
@@ -234,10 +270,9 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 		}
 		else if (current.states.jumping)
 			index = 29;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 4;
 
-
 	}
 	else if (angle >= -0.75 && !isLeft) //BackRight
 	{
@@ -246,7 +281,6 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 				index = 23;
 			else
 				index = 15;
-
 		}
 		else if (current.states.jumpshot) {
 			if (Shooting)
@@ -256,12 +290,11 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 		}
 		else if (current.states.jumping)
 			index = 31;
-		else if (!current.states.jumping && !current.states.shooting && !current.states.jumpshot)
+		else if (current.states.running && current.states.still)
 			index = 6;
 
-
 	}
-
+		
 
 
 	float u, v, w, h;
@@ -271,25 +304,10 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
 	atlas.TextureIndexToCoord(index, u, v, w, h);
 
 	glEnable(GL_BLEND);
-
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-	if (current.states.hit)
-	{
-		glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
-		glBlendColor(1.f, 0.f, 0.f, 1.f);
-
-	}
-	else {
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	}
-
 	glBlendEquation(GL_FUNC_ADD);
 
-
-
-
 	glLoadMatrixf(tran.GetMatrix().GetInternalValues());
-	glDepthFunc(GL_LEQUAL);
 	glBegin(GL_QUADS);
 	glTexCoord2f(u, v); glVertex3f(v1.x, v1.y, v1.z);
 	glTexCoord2f(u + w, v); glVertex3f(v2.x, v2.y, v2.z);

SQCSim2021/remoteplayer.h

@@ -14,8 +14,8 @@ class RemotePlayer : public Player {
 public:
 	enum Anim: uint8_t { STILL = 1, RUNNING = 2, JUMPING = 4, SHOOTING = 8, POWERUP = 16,  DEAD = 32 }; // A REVOIR VOIR DEFINE.H POUR LES ANIMES
 	
-	RemotePlayer(netprot::PlayerInfo* pinfo);
+	RemotePlayer(netprot::PlayerInfo pinfo);
-	RemotePlayer(netprot::PlayerInfo* pinfo, const Vector3f& pos);
+	RemotePlayer(netprot::PlayerInfo pinfo, const Vector3f& pos);
 	~RemotePlayer();
 
 

SQCSim2021/renderer.cpp

@@ -120,7 +120,7 @@ void Renderer::RenderWorld(World* origin, int& rendercount, const Vector3f& play
 	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
 	unsigned int sx, sy, cx, cy;
-	origin->GetScope(sx, sy);
+	origin->GetScope(sx,sy);
 
 	for (int index = 0; index < rendercount; ++index) {
 		int chx = (renderManifest[index].x - sx) * CHUNK_SIZE_X, chy = (renderManifest[index].z - sy) * CHUNK_SIZE_Z;
@@ -129,9 +129,9 @@ void Renderer::RenderWorld(World* origin, int& rendercount, const Vector3f& play
 		glLoadMatrixf(world.GetMatrix().GetInternalValues());
 		float blcolor = renderManifest[index].y / (VIEW_DISTANCE / 50.f);
 		glBlendColor(blcolor, blcolor, blcolor, 1.f);
-		origin->ChunkAt(chx, 1, chy)->GetPosition(cx, cy);
+		origin->ChunkAt(chx, 1, chy)->GetPosition(cx,cy);
 		if (m_meshes.Get(cx - sx, cy - sy))
-			m_meshes.Get(cx - sx, cy - sy)->Render();
+			m_meshes.Get(cx - sx, cy -sy)->Render();
 		world.ApplyTranslation(-chx, 0, -chy);
 	}
 	shader.Disable();
@@ -147,7 +147,7 @@ void Renderer::UpdateMesh(World* origin, const Vector3f& player, BlockInfo* bloc
 	int threads = 0;
 	std::future<Mesh*> updateThList[THREADS_UPDATE_CHUNKS];
 
-	unsigned int mx = 0, my = 0, sx, sy;
+	unsigned int mx = 0 , my = 0, sx, sy;
 
 	origin->GetScope(sx, sy);
 
@@ -244,73 +244,31 @@ void Renderer::UpdateMesh(World* origin, const Vector3f& player, BlockInfo* bloc
 	}
 }
 
-void Renderer::RenderBooster(TextureAtlas& textureAtlas, Shader& shader, Transformation tran, Player player, Booster* booster) {
+void Renderer::RenderBillboard(const Vector3f pos, TextureAtlas textureAtlas, TextureAtlas::TextureIndex idx, Shader& shader, Transformation tran)
-		float width = 1.f;
+{
-		float height = 1.f;
+	//float x = pos.x;
+	//float y = pos.y;
+	//float z = pos.z;
+	//float width = 1.0f;
+	//float height = 1.0f;
 
-		Vector3f DiffCam = booster->GetPosition() - player.GetPosition();
+	//float u, v, w, h;
-		Vector3f UpCam = Vector3f(0.f, 1.f, 0.f);
+	//shader.Use();
+	//textureAtlas.Bind();
+	//textureAtlas.TextureIndexToCoord(idx, u, v, w, h);
 
-		Vector3f CrossA = DiffCam.Cross(UpCam);
+	//glLoadMatrixf(tran.GetMatrix().GetInternalValues());
-		Vector3f CrossB = DiffCam.Cross(CrossA);
+	//glBegin(GL_QUADS);
-
+	//glTexCoord2f(u, v); glVertex3f(x - width / 2., y - height, z); //glVertex3f(v4.x, v4.y, v4.z);//glVertex3f(0, 50, 0);
-		CrossA.Normalize();
+	//glTexCoord2f(u + w, v); glVertex3f(x + width / 2., y - height, z); //glVertex3f(v3.x, v3.y, v3.z); //glVertex3f(50,50, 0);
-		CrossB.Normalize();
+	//glTexCoord2f(u + w, v + h); glVertex3f(x + width / 2., y, z); //glVertex3f(v2.x, v2.y, v2.z); //glVertex3f(50, 0, 0);
-
+	//glTexCoord2f(u, v + h); glVertex3f(x - width / 2., y, z); //glVertex3f(v1.x, v1.y, v1.z);// glVertex3f(0, 0, 0);
-		Vector3f playerPosition = booster->GetPosition() + Vector3f(0.f, -.75f, 0.f);
+	//glEnd();
-
+	//shader.Disable();
-		Vector3f v2 = (playerPosition + CrossA * 0.5 * width + CrossB * 0.5 * height);
-		Vector3f v1 = (playerPosition - CrossA * 0.5 * width + CrossB * 0.5 * height);
-		Vector3f v3 = (playerPosition + CrossA * 0.5 * width - CrossB * 0.5 * height);
-		Vector3f v4 = (playerPosition - CrossA * 0.5 * width - CrossB * 0.5 * height);
-
-		int index;
-		BOOST_TYPE type = booster->GetType();
-
-		switch (type)
-		{
-		case BTYPE_HEAL:
-			index = 5;
-			break;
-		case BTYPE_DAMAGE:
-			index = 6;
-			break;
-		case BTYPE_SPEED:
-			index = 7;
-			break;
-		case BTYPE_INVINCIBLE:
-			index = 8;
-			break;
-		default:
-			index = 1;
-			break;
-		}
-		float u, v, w, h;
-
-		shader.Use();
-		textureAtlas.Bind();
-		textureAtlas.TextureIndexToCoord(index, u, v, w, h);
-
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		glBlendEquation(GL_FUNC_ADD);
-
-		glLoadMatrixf(tran.GetMatrix().GetInternalValues());
-		glBegin(GL_QUADS);
-		glTexCoord2f(u, v); glVertex3f(v1.x, v1.y, v1.z);
-		glTexCoord2f(u + w, v); glVertex3f(v2.x, v2.y, v2.z);
-		glTexCoord2f(u + w, v + h); glVertex3f(v3.x, v3.y, v3.z);
-		glTexCoord2f(u, v + h); glVertex3f(v4.x, v4.y, v4.z);
-
-		glEnd();
-
-		glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
-		glBlendEquation(GL_FUNC_SUBTRACT);
-		glDisable(GL_BLEND);
-
-		shader.Disable();
 }
 
+
+
 void Renderer::RenderPlayer(Player* player, Transformation tran) const {
 }
 

SQCSim2021/renderer.h

@@ -29,7 +29,7 @@ public:
 
 	void UpdateMesh(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]);
 
-	void RenderBooster(TextureAtlas& textureAtlas, Shader& shader, Transformation tran, Player player, Booster* booster);
+	void RenderBillboard(const Vector3f pos, TextureAtlas textureAtlas, TextureAtlas::TextureIndex idx, Shader& shader, Transformation tran);
 
 	void RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation world, Shader& shader, TextureAtlas& atlas) const;
 	void RenderPlayer(Player* player, Transformation tran) const;

SQCSim2021/settings.cpp

@@ -9,7 +9,7 @@ Settings::Settings(Audio& audio)
     m_fullscreen(false),
     m_brightness(0.5f),
     m_contrast(0.5f),
-    m_mouseSensitivity(0.0f) {
+    m_mouseSensitivity(0.5f) {
     ApplyResolution(m_resolution);
 }