client linux fonctionnel

Sqc 51 fin - Vérifié

.gitignore

@@ -373,3 +373,8 @@ FodyWeavers.xsd
 /x64/Release/SQCSim2023.exe
 /x64/Debug/SQCSim2023.exe
 /x64/Debug/SQCSim2021.pdb
+/SQCSim-srv/cmake/*
+!/SQCSim-srv/cmake/CMakeLists.txt
+/SQCSim2021/cmake/*
+!/SQCSim2021/cmake/CMakeLists.txt
+/SQCSim2021/SQCSim-client

SQCSim-common/SQCSim-common.vcxproj

@@ -137,6 +137,8 @@
     <ClInclude Include="matrix4.h" />
     <ClInclude Include="opensimplex.h" />
     <ClInclude Include="player.h" />
+    <ClInclude Include="netprotocol.h" />
+    <ClInclude Include="transformation.h" />
     <ClInclude Include="vector3.h" />
     <ClInclude Include="world.h" />
   </ItemGroup>
@@ -144,8 +146,10 @@
     <ClCompile Include="blockinfo.cpp" />
     <ClCompile Include="bullet.cpp" />
     <ClCompile Include="chunk.cpp" />
+    <ClCompile Include="netprotocol.cpp" />
     <ClCompile Include="opensimplex.cpp" />
     <ClCompile Include="player.cpp" />
+    <ClCompile Include="transformation.cpp" />
     <ClCompile Include="world.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

SQCSim-common/SQCSim-common.vcxproj.filters

@@ -48,6 +48,12 @@
     <ClInclude Include="vector3.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
+    <ClInclude Include="netprotocol.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
+    <ClInclude Include="transformation.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="world.cpp">
@@ -68,5 +74,11 @@
     <ClCompile Include="player.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
+    <ClCompile Include="netprotocol.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
+    <ClCompile Include="transformation.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SQCSim-common/bullet.cpp

@@ -1,10 +1,9 @@
 #include "bullet.h"
 #include "world.h"
 
-Bullet::Bullet(Player& player) {
+Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
-	m_startpos = m_currentpos = player.GetPOV() + player.GetDirection();
+
-	m_velocity = player.GetDirection();
+Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t tid): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_tid(tid) {}
-}
 
 Bullet::~Bullet() {}
 
@@ -30,3 +29,11 @@ void Bullet::Transpose(int& x, int& z) {
 	m_startpos.x -= x * CHUNK_SIZE_X;
 	m_startpos.z -= z * CHUNK_SIZE_Z;
 }
+
+Vector3f Bullet::getPos() {
+	return m_currentpos;
+}
+
+uint64_t Bullet::getTeamID(){
+	return m_tid;
+}

SQCSim-common/bullet.h

@@ -1,22 +1,27 @@
 #ifndef BULLET_H__
 #define BULLET_H__
 
-#include "player.h"
+#include "define.h"
+#include "vector3.h"
 
 class World;
 
 class Bullet {
 public:
-	Bullet(Player& player);
+	Bullet(Vector3f pos, Vector3f dir);
+	Bullet(Vector3f pos, Vector3f dir, uint64_t tid);
 	~Bullet();
 
 	bool Update(World* world, float elapsedtime);
 	void Transpose(int& x, int& z);
+	Vector3f getPos();
+	uint64_t getTeamID();
 
 private:
-	Vector3f m_startpos;
+	Vector3f m_startpos, 
-	Vector3f m_currentpos;
+			 m_currentpos, 
-	Vector3f m_velocity;
+			 m_velocity;
+	uint64_t m_tid = 0;
 };
 
 #endif // BULLET_H__

SQCSim-common/chunk.cpp

@@ -1,13 +1,13 @@
 #include "chunk.h"
 #include "world.h"
 
-Chunk::Chunk(unsigned int x, unsigned int y) : m_posX(x), m_posY(y) { 
+Chunk::Chunk(unsigned int x, unsigned int y, int64_t seed) : m_posX(x), m_posY(y) { 
     //std::ostringstream pos; // V<>rifie l'existence d'un fichier .chunk avec sa position.
     //pos << CHUNK_PATH << x << '_' << y << ".chunk";
     //std::ifstream input(pos.str(), std::fstream::binary);
 
     //if (input.fail()) {
-        OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(SEED);
+        OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(seed);
         m_blocks.Reset(BTYPE_AIR);
 
         for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Montagnes
@@ -98,14 +98,45 @@ Chunk::~Chunk() {
 
 void Chunk::RemoveBlock(int x, int y, int z, World* world) {
     m_blocks.Set(x, y, z, BTYPE_AIR);
+    CheckNeighbors(x, y, world);
+    m_isDirty = true;
 }
 
 void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
     m_blocks.Set(x, y, z, type);
+    if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas v<>rifier les chunks voisines.
+    m_isDirty = true;
 }
 
 BlockType Chunk::GetBlock(int x, int y, int z) { return m_blocks.Get(x, y, z); }
 
+void Chunk::CheckNeighbors(unsigned int x, unsigned int z, World* world) {
+    unsigned int cx, cy;
+
+    world->GetScope(cx, cy);
+
+    if (x == 0 && m_posX - cx >= 0 &&
+        world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
+        world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
+    else if (x == CHUNK_SIZE_X - 1 && m_posX - cx < WORLD_SIZE_X && 
+        world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
+        world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
+
+    if (z == 0 && m_posY - cy >= 0 && 
+        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z))
+        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z)->MakeDirty();
+    else if (z == CHUNK_SIZE_X - 1 && m_posY - cy < WORLD_SIZE_Y &&
+        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z))
+        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z)->MakeDirty();
+}
+
 void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
 
+bool Chunk::IsDirty() const { return m_isDirty; }
+
+void Chunk::MakeDirty() { m_isDirty = true; }
+
+void Chunk::MakeClean() { m_isDirty = false; }
+
 void Chunk::MakeModified() { m_isModified = true; }
+

SQCSim-common/chunk.h

@@ -1,30 +1,36 @@
 #ifndef CHUNK_H__
 #define CHUNK_H__
+
 #include "define.h"
-#include "array3d.h"
 #include "array2d.h"
+#include "array3d.h"
 #include "blockinfo.h"
 #include "opensimplex.h"
 
 class World;
 
 class Chunk {
-    protected:
+    private:
         Array3d<BlockType> m_blocks = Array3d<BlockType>(CHUNK_SIZE_X, CHUNK_SIZE_Y, CHUNK_SIZE_Z);
+        bool m_isDirty = true;
         bool m_isModified = false;
 
         unsigned int m_posX; // Position du chunk dans l'array constituant le monde.
         unsigned int m_posY;
 
     public:
-        Chunk(unsigned int x, unsigned int y);
+        Chunk(unsigned int x, unsigned int y, int64_t seed);
         ~Chunk();
 
         void RemoveBlock(int x, int y, int z, World* world);
         void SetBlock(int x, int y, int z, BlockType type, World* world);
         BlockType GetBlock(int x, int y, int z);
+        void CheckNeighbors(unsigned int x, unsigned int z, World* world);
         void GetPosition(unsigned int& x, unsigned int& y) const;
 
+        bool IsDirty() const;
+        void MakeDirty();
+        void MakeClean();
         void MakeModified();
 };
 

SQCSim-common/define.h

@@ -2,51 +2,64 @@
 #define DEFINE_H__
 
 #include <iostream>
-
+#include <chrono>
-#define CHUNK_SIZE_X  16
-#define CHUNK_SIZE_Y  128
-#define CHUNK_SIZE_Z  16
-#define MAX_SELECTION_DISTANCE 5
-#define SEED 12345
 
 #define SRV_PORT 1025
 #define CLI_PORT 1026
 
-#ifdef _DEBUG
+#define CHUNK_SIZE_X  4
+#define CHUNK_SIZE_Y  64
+#define CHUNK_SIZE_Z  4
+#define MAX_SELECTION_DISTANCE 5
+#define SEED 0
+#define COUNTDOWN 300
+
 #define WORLD_SIZE_X 64
 #define WORLD_SIZE_Y 64
 
-#define FRAMES_RENDER_CHUNKS 4
-#define FRAMES_UPDATE_CHUNKS 4
-#define FRAMES_DELETE_CHUNKS 4
-
-#define THREADS_GENERATE_CHUNKS 1
-#define THREADS_UPDATE_CHUNKS 1
-#define THREADS_DELETE_CHUNKS 1
-
-#define VIEW_DISTANCE 256
-#define TEXTURE_SIZE 128
-#define MAX_BULLETS 64
-#endif
-
-#ifdef NDEBUG
-#define WORLD_SIZE_X 16
-#define WORLD_SIZE_Y 16
-
 #define FRAMES_RENDER_CHUNKS 1
 #define FRAMES_UPDATE_CHUNKS 1
 #define FRAMES_DELETE_CHUNKS 1
 
-#define THREADS_GENERATE_CHUNKS 12
+#define THREADS_GENERATE_CHUNKS 8
-#define THREADS_UPDATE_CHUNKS 5
+#define THREADS_UPDATE_CHUNKS 3
-#define THREADS_DELETE_CHUNKS 2
+#define THREADS_DELETE_CHUNKS 3
 
-#define VIEW_DISTANCE 1024
+#define VIEW_DISTANCE 512 // Si les chunks arr<72>tent de s'afficher pendant une game et qu'il y a un access violation quand tu quitte, il faut augmenter ce chiffre.
 #define TEXTURE_SIZE 512
 #define MAX_BULLETS 512
-#endif
 
 typedef uint8_t BlockType;
 enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_LAST };
+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>
+#include <ctime>
+
+#define popen _popen
+#define pclose _pclose
+
+#else // Pas _WIN32
+
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <cstring>
+
+#define SOCKET int
+#define INVALID_SOCKET -1
+#define closesocket close
+
+#endif // _WIN32
+
 
 #endif // DEFINE_H__

SQCSim-common/netprotocol.cpp

@@ -0,0 +1,506 @@
+#include "netprotocol.h"
+
+void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::INPUT;
+
+	uint64_t time = in->timestamp;
+	uint8_t time8[sizeof(uint64_t)] = {(time >> 56) & 0xFF,
+									   (time >> 48) & 0xFF,
+									   (time >> 40) & 0xFF,
+									   (time >> 32) & 0xFF,
+									   (time >> 24) & 0xFF,
+									   (time >> 16) & 0xFF,
+									   (time >> 8 ) & 0xFF,
+									    time		& 0xFF};
+
+	memcpy(*buf + 1, time8, sizeof(uint64_t));
+
+	uint64_t sid = in->sid;
+	uint8_t sid8[sizeof(uint64_t)] = {(sid >> 56) & 0xFF,
+									  (sid >> 48) & 0xFF,
+									  (sid >> 40) & 0xFF,
+									  (sid >> 32) & 0xFF,
+									  (sid >> 24) & 0xFF,
+									  (sid >> 16) & 0xFF,
+									  (sid >> 8 ) & 0xFF,
+									   sid		  & 0xFF};
+
+	memcpy(*buf + sizeof(uint64_t) + 1, sid8, sizeof(uint64_t));
+
+	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 ;
+
+	memcpy(*buf + sizeof(uint64_t) + 2, &keys8, sizeof(uint8_t));
+
+	uint32_t vec[3];
+	memcpy(vec, &in->direction, sizeof(Vector3f)); // Pour d<>naturer les floats.
+
+	uint8_t vec8[3 * sizeof(uint32_t)] = {
+							(vec[0] >> 24) & 0xFF,
+							(vec[0] >> 16) & 0xFF,
+							(vec[0] >> 8) & 0xFF,
+							 vec[0] & 0xFF,
+						(vec[1] >> 24) & 0xFF,
+						(vec[1] >> 16) & 0xFF,
+						(vec[1] >> 8) & 0xFF,
+						 vec[1] & 0xFF,
+					(vec[2] >> 24) & 0xFF,
+					(vec[2] >> 16) & 0xFF,
+					(vec[2] >> 8) & 0xFF,
+					 vec[2] & 0xFF};
+
+	memcpy(*buf + sizeof(uint64_t) + 3, vec8, sizeof(uint32_t) * 3);
+
+	*buflen = sizeof(uint64_t) + 3 + sizeof(uint32_t) * 3;
+}
+
+void netprot::Serialize(Output* out, char* buf[], uint32_t* buflen) {
+
+}
+
+void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) {
+	
+}
+
+void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::TEAMINF;
+
+	size_t namesize = std::strlen(tinfo->name) + 1;
+
+	memcpy(*buf + 1, &tinfo->name, namesize);
+	uint64_t tid = tinfo->id;
+	uint8_t tid8[sizeof(uint64_t)] = {
+									   (tid >> 56) & 0xFF,
+									   (tid >> 48) & 0xFF,
+									   (tid >> 40) & 0xFF,
+									   (tid >> 32) & 0xFF,
+									   (tid >> 24) & 0xFF,
+									   (tid >> 16) & 0xFF,
+									   (tid >> 8) & 0xFF,
+									   tid & 0xFF
+	};
+
+	memcpy(*buf + namesize + 2, tid8, sizeof(uint64_t));
+
+	*buflen = namesize + sizeof(uint64_t) + 2;
+}
+
+void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::LOGINF;
+
+	size_t namesize = std::strlen(linfo->name) + 1;
+	
+	memcpy(*buf + 1, &linfo->name, namesize);
+	uint64_t sid = linfo->sid;
+	uint8_t sid8[sizeof(uint64_t)] = { 
+									   (sid >> 56) & 0xFF,
+									   (sid >> 48) & 0xFF,
+									   (sid >> 40) & 0xFF,
+									   (sid >> 32) & 0xFF,
+									   (sid >> 24) & 0xFF,
+									   (sid >> 16) & 0xFF,
+									   (sid >> 8) & 0xFF,
+									   sid & 0xFF
+	};
+
+	memcpy(*buf + namesize + 2, sid8, sizeof(uint64_t));
+
+	uint64_t tid = linfo->tid;
+	uint8_t tid8[sizeof(uint64_t)] = {
+									   (tid >> 56) & 0xFF,
+									   (tid >> 48) & 0xFF,
+									   (tid >> 40) & 0xFF,
+									   (tid >> 32) & 0xFF,
+									   (tid >> 24) & 0xFF,
+									   (tid >> 16) & 0xFF,
+									   (tid >> 8) & 0xFF,
+									   tid & 0xFF
+	};
+
+	memcpy(*buf + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t));
+
+	*buflen = namesize + sizeof(uint64_t) * 2 + 2;
+}
+
+void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::PLAYINF;
+
+	size_t namesize = std::strlen(pinfo->name) + 1;
+
+	memcpy(*buf + 1, &pinfo->name, namesize);
+	uint64_t id = pinfo->id;
+	uint8_t id8[sizeof(uint64_t)] = {
+									   (id >> 56) & 0xFF,
+									   (id >> 48) & 0xFF,
+									   (id >> 40) & 0xFF,
+									   (id >> 32) & 0xFF,
+									   (id >> 24) & 0xFF,
+									   (id >> 16) & 0xFF,
+									   (id >> 8) & 0xFF,
+									   id & 0xFF
+	};
+
+	memcpy(*buf + namesize + 2, id8, sizeof(uint64_t));
+
+	uint64_t tid = pinfo->tid;
+	uint8_t tid8[sizeof(uint64_t)] = {
+									   (tid >> 56) & 0xFF,
+									   (tid >> 48) & 0xFF,
+									   (tid >> 40) & 0xFF,
+									   (tid >> 32) & 0xFF,
+									   (tid >> 24) & 0xFF,
+									   (tid >> 16) & 0xFF,
+									   (tid >> 8) & 0xFF,
+									   tid & 0xFF 
+	};
+
+	memcpy(*buf + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t));
+
+	*buflen = namesize + sizeof(uint64_t) * 2 + 2;
+}
+
+void netprot::Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::GAMEINFO;
+
+	uint64_t game = ginfo->seed;
+	uint8_t seed8[sizeof(uint64_t)] = {
+									   (game >> 56) & 0xFF,
+									   (game >> 48) & 0xFF,
+									   (game >> 40) & 0xFF,
+									   (game >> 32) & 0xFF,
+									   (game >> 24) & 0xFF,
+									   (game >> 16) & 0xFF,
+									   (game >> 8) & 0xFF,
+									   game & 0xFF
+	};
+
+	memcpy(*buf + 1, seed8, sizeof(uint64_t));
+
+	game = ginfo->countdown;
+	uint8_t count8[sizeof(uint64_t)] = {
+									   (game >> 56) & 0xFF,
+									   (game >> 48) & 0xFF,
+									   (game >> 40) & 0xFF,
+									   (game >> 32) & 0xFF,
+									   (game >> 24) & 0xFF,
+									   (game >> 16) & 0xFF,
+									   (game >> 8) & 0xFF,
+									   game & 0xFF
+	};
+
+	memcpy(*buf + sizeof(uint64_t) + 1, count8, sizeof(uint64_t));
+
+	game = ginfo->countdown;
+	uint8_t gtype8[sizeof(uint64_t)] = {
+									   (game >> 56) & 0xFF,
+									   (game >> 48) & 0xFF,
+									   (game >> 40) & 0xFF,
+									   (game >> 32) & 0xFF,
+									   (game >> 24) & 0xFF,
+									   (game >> 16) & 0xFF,
+									   (game >> 8) & 0xFF,
+									   game & 0xFF
+	};
+
+	memcpy(*buf + sizeof(uint64_t) + 1, gtype8, sizeof(uint64_t));
+
+	*buflen = sizeof(uint64_t) * 3 + 1;
+}
+
+void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::CHAT;
+
+	uint64_t src = chat->src_id;
+	uint8_t src8[sizeof(uint64_t)] = {
+									   (src >> 56) & 0xFF,
+									   (src >> 48) & 0xFF,
+									   (src >> 40) & 0xFF,
+									   (src >> 32) & 0xFF,
+									   (src >> 24) & 0xFF,
+									   (src >> 16) & 0xFF,
+									   (src >> 8) & 0xFF,
+									   src & 0xFF
+	};
+
+	memcpy(*buf + 1, src8, sizeof(uint64_t));
+
+	uint64_t dst = chat->dest_id;
+	uint8_t dst8[sizeof(uint64_t)] = {
+									   (dst >> 56) & 0xFF,
+									   (dst >> 48) & 0xFF,
+									   (dst >> 40) & 0xFF,
+									   (dst >> 32) & 0xFF,
+									   (dst >> 24) & 0xFF,
+									   (dst >> 16) & 0xFF,
+									   (dst >> 8) & 0xFF,
+									   dst & 0xFF
+	};
+
+	memcpy(*buf + 1 + sizeof(uint64_t), dst8, sizeof(uint64_t));
+
+	uint64_t dstteam = chat->dest_id;
+	uint8_t dstt8[sizeof(uint64_t)] = {
+									   (dstteam >> 56) & 0xFF,
+									   (dstteam >> 48) & 0xFF,
+									   (dstteam >> 40) & 0xFF,
+									   (dstteam >> 32) & 0xFF,
+									   (dstteam >> 24) & 0xFF,
+									   (dstteam >> 16) & 0xFF,
+									   (dstteam >> 8) & 0xFF,
+									   dstteam & 0xFF
+	};
+	
+	memcpy(*buf + 1 + sizeof(uint64_t) * 2, dstt8, sizeof(uint64_t));
+
+	size_t messize = std::strlen(chat->mess) + 1;
+
+	memcpy(*buf + 1 + sizeof(uint64_t) * 3, &chat->mess, messize);
+
+	*buflen = messize + sizeof(uint64_t) * 3 + 2;
+}
+
+void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
+	*buf[0] = netprot::PACKET_TYPE::ERRLOG;
+
+	size_t messize = std::strlen(errlog->mess) + 1;
+
+	memcpy(*buf + 1, &errlog->mess, messize);
+
+	memcpy(*buf + 1 + messize, &errlog->is_fatal, sizeof(bool));
+
+	*buflen = messize + sizeof(bool) + 1;
+}
+
+
+
+bool netprot::Deserialize(Input* in, char* buf, const uint32_t buflen) {
+	return false;
+}
+
+bool netprot::Deserialize(Output* out, char* buf, const uint32_t buflen) {
+	return false;
+}
+
+bool netprot::Deserialize(Sync* sync, char* buf, const uint32_t buflen) {
+	return false;
+}
+
+bool netprot::Deserialize(TeamInfo* tinfo, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(LoginInfo))
+		return false;
+
+	size_t namesize = std::strlen(buf) + 1;
+
+	if (namesize > 32)
+		return false;
+
+	memcpy(&tinfo->name, &buf[1], namesize);
+
+	uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
+	tinfo->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];
+
+	return true;
+}
+
+bool netprot::Deserialize(LoginInfo* linfo, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(LoginInfo))
+		return false;
+
+	size_t namesize = std::strlen(buf) + 1;
+
+	if (namesize > 32)
+		return false;
+
+	memcpy(&linfo->name, &buf[1], namesize);
+
+	uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
+	linfo->sid =
+		(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];
+
+	memcpy(diff, &buf[namesize + sizeof(uint64_t) + 1], sizeof(uint64_t));
+	linfo->tid =
+		(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];
+
+	return true;
+}
+
+bool netprot::Deserialize(PlayerInfo* pinfo, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(PlayerInfo))
+		return false;
+
+	size_t namesize = std::strlen(buf) + 1;
+
+	if (namesize > 32)
+		return false;
+
+	memcpy(&pinfo->name, &buf[1], namesize);
+
+	uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
+	pinfo->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];
+
+	memcpy(diff, &buf[namesize + sizeof(uint64_t) + 1], sizeof(uint64_t));
+	pinfo->tid =
+		(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];
+
+	return true;
+}
+
+bool netprot::Deserialize(GameInfo* ginfo, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(GameInfo))
+		return false;
+
+	uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(diff, &buf[1], sizeof(uint64_t));
+	ginfo->seed =
+		(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];
+
+	memcpy(diff, &buf[sizeof(uint64_t) + 1], sizeof(uint64_t));
+	ginfo->countdown =
+		(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];
+
+	memcpy(diff, &buf[sizeof(uint64_t) * 2 + 1], sizeof(uint64_t));
+	ginfo->gameType =
+		(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];
+
+	return true;
+}
+
+bool netprot::Deserialize(Chat* chat, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(Chat))
+		return false;
+
+	uint8_t src[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(src, &buf[1], sizeof(uint64_t));
+	chat->src_id =
+		(uint64_t)src[0] << 56 |
+		(uint64_t)src[1] << 48 |
+		(uint64_t)src[2] << 40 |
+		(uint64_t)src[3] << 32 |
+		(uint64_t)src[4] << 24 |
+		(uint64_t)src[5] << 16 |
+		(uint64_t)src[6] << 8 |
+		(uint64_t)src[7];
+
+	uint8_t dst[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(dst, &buf[1 + sizeof(uint64_t)], sizeof(uint64_t));
+	chat->dest_id =
+		(uint64_t)dst[0] << 56 |
+		(uint64_t)dst[1] << 48 |
+		(uint64_t)dst[2] << 40 |
+		(uint64_t)dst[3] << 32 |
+		(uint64_t)dst[4] << 24 |
+		(uint64_t)dst[5] << 16 |
+		(uint64_t)dst[6] << 8 |
+		(uint64_t)dst[7];
+
+	uint8_t dstt[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
+	memcpy(dstt, &buf[1 + sizeof(uint64_t) * 2], sizeof(uint64_t));
+	chat->dest_team_id =
+		(uint64_t)dstt[0] << 56 |
+		(uint64_t)dstt[1] << 48 |
+		(uint64_t)dstt[2] << 40 |
+		(uint64_t)dstt[3] << 32 |
+		(uint64_t)dstt[4] << 24 |
+		(uint64_t)dstt[5] << 16 |
+		(uint64_t)dstt[6] << 8 |
+		(uint64_t)dstt[7];
+
+	size_t messsize = std::strlen(buf + sizeof(uint64_t) * 3) + 1;
+
+	if (messsize > 140)
+		return false;
+
+	memcpy(&chat->mess, &buf[1 + sizeof(uint64_t) * 3], messsize);
+	return true;
+}
+
+bool netprot::Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen) {
+	if (buflen <= sizeof(ErrorLog))
+		return false;
+
+	size_t messsize = std::strlen(buf) + 1;
+
+	if (messsize > 140)
+		return false;
+
+	memcpy(&errlog->mess, &buf[1], messsize);
+	memcpy(&errlog->is_fatal, &buf[1 + messsize], sizeof(bool));
+
+	return true;
+}
+
+netprot::PacketType netprot::getType(char* buf, const uint32_t buflen) {
+	if (buflen < 1 || 
+		buf[0] >= netprot::PACKET_TYPE::LAST_PACK || 
+		buf[0] <= netprot::PACKET_TYPE::ERR)
+		return netprot::PACKET_TYPE::ERR;
+	return buf[0];
+}

SQCSim-common/netprotocol.h

@@ -0,0 +1,120 @@
+#ifndef NETPROTOCOL_H__
+#define NETPROTOCOL_H__
+
+#include "define.h"
+#include <string>
+#include "vector3.h"
+
+/* Protocole Particulier de Partie <20> Plusieurs Personnes (PPPPP) */
+
+// Packet: packet[0] = PacketType, packet[1..n-1] = {packet}
+
+namespace netprot {
+	typedef uint8_t PacketType;
+	enum PACKET_TYPE {
+				ERR, INPUT, OUTPUT, SYNC,
+				TEAMINF, SELFINF, PLAYINF, LOGINF,
+				CHUNKMOD, PLAYERMOD, PICKUPMOD,
+				GAMEINFO, ENDINFO , CHAT, ERRLOG,
+				LAST_PACK
+			};
+
+	struct Keys {
+		bool forward, 
+			 backward, 
+			 left, 
+			 right, 
+			 jump, 
+			 shoot,
+			 block;
+	};
+
+	struct States {
+		bool jumping, 
+			 shooting, 
+			 hit, 
+			 powerup;
+	};
+
+	struct Input {										// cli -> srv			UDP			~frame
+		Timestamp timestamp;
+		uint64_t sid = 0;
+		Keys keys; // 0bFBLRJS__ bit-packing de bool.
+		Vector3f direction;
+	};
+
+	struct Output {										// srv -> cli			UDP			~frame
+		Timestamp timestamp;
+		uint64_t id = 0;
+		Vector3f position,
+			     direction;
+		States states; // 0bJSH_____ bit-packing de bool.
+	};
+
+	struct Sync {										// srv -> cli			TCP			~second
+		Timestamp timestamp;
+		uint64_t sid = 0;
+		uint32_t timer = 0;
+		uint16_t ammo = 0;
+		uint8_t hp = 0;
+		Vector3f position;
+	};
+
+	struct TeamInfo {									// cli <-> srv			TCP			once
+		char name[32];
+		uint64_t id = 0;
+	};
+
+	struct LoginInfo {									// cli <-> srv			TCP			once
+		char name[32];
+		uint64_t sid = 0, 
+			     tid = 0;
+	};
+
+	struct PlayerInfo {									// cli <-> srv			TCP			once
+		char name[32];
+		uint64_t id = 0,
+				 tid = 0;
+	};
+
+	struct GameInfo {									// cli <-> srv			TCP			event (before game start)/ once
+		uint64_t seed;
+		uint32_t countdown;
+		uint8_t gameType; // TOOD: enum.
+	};
+
+	struct Chat {										// cli <-> srv			TCP			event
+		uint64_t src_id = 0,
+			dest_id = 0,
+			dest_team_id = 0;
+		char mess[140]; // Good 'nough for twitr, good 'nough for me.
+	};
+
+	struct ErrorLog {									// srv -> cli			TCP			event
+		char mess[140];
+		bool is_fatal;
+	};
+
+	void Serialize(Input* in, char* buf[], uint32_t* buflen); // cli
+	void Serialize(Output* out, char* buf[], uint32_t* buflen); // srv
+	void Serialize(Sync* sync, char* buf[], uint32_t* buflen); // srv
+	void Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen); // cli/srv
+	void Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen); // cli/srv
+	void Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen); // srv
+	void Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen); // cli/srv
+	void Serialize(Chat* chat, char* buf[], uint32_t* buflen); // cli/srv
+	void Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen); // srv
+
+	bool Deserialize(Input* in, char* buf, const uint32_t buflen); // srv
+	bool Deserialize(Output* out, char* buf, const uint32_t buflen); // cli
+	bool Deserialize(Sync* sync, char* buf, const uint32_t buflen); // cli
+	bool Deserialize(TeamInfo* tinfo, char* buf, const uint32_t buflen); // cli/srv
+	bool Deserialize(LoginInfo* linfo, char* buf, const uint32_t buflen); // cli/srv
+	bool Deserialize(PlayerInfo* pinfo, char* buf, const uint32_t buflen); // cli
+	bool Deserialize(GameInfo* ginfo, char* buf, const uint32_t buflen); // cli
+	bool Deserialize(Chat* chat, char* buf, const uint32_t buflen); // srv/cli
+	bool Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen); // srv
+
+	PacketType getType(char* buf, uint32_t buflen); // srv/cli
+} 
+#endif

SQCSim-common/player.cpp

@@ -4,6 +4,8 @@
 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 = 0.75f; //TODO: Remettre <20> 1.0f
+	m_username = "Zelda Bee-Bop";
 }
 
 void Player::TurnLeftRight(float value) {
@@ -64,7 +66,8 @@ Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jum
 	return delta;
 }
 
-void Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
+Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
+	Player::Sound snd = Player::Sound::NOSOUND;
 	static float timing = 0.f;
 	/* Gestion de collisions */
 	BlockType bt1, bt2, bt3;
@@ -85,6 +88,7 @@ void Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
 		if (bt3 != BTYPE_AIR) {
 			m_velocity.y = 0;
 			if (timing == 0.f) {
+				if (m_airborne) snd = Player::Sound::FALL;
 				timing = .3f;
 			}
 			m_airborne = false;
@@ -160,6 +164,30 @@ void Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
 	m_velocity.y = vy;
 
 	m_position += m_velocity;
+
+	static float bobbingtime = 0; // Gestion de la cam<61>ra
+	static bool leftright = false;
+	static bool isStep = false;
+	if (bobbingtime <= 360.f)
+		bobbingtime += elapsedTime * 20.f; else bobbingtime = 0;
+
+	if ((sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) < -.2f && !m_airborne) {
+		if (!isStep) {
+			snd = Player::Sound::STEP;
+		}
+		isStep = true;
+	}
+	else isStep = false;
+	m_POV = m_position.y;
+	m_POV += m_airborne ? 0 : (sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) * .2f;
+
+	return snd;
+}
+
+void Player::ApplyTransformation(Transformation& transformation, bool rel) const {
+	transformation.ApplyRotation(-m_rotX, 1, 0, 0);
+	transformation.ApplyRotation(-m_rotY, 0, 1, 0);
+	if (rel) transformation.ApplyTranslation(-GetPOV());
 }
 
 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); }
@@ -170,6 +198,10 @@ Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPos
 
 Vector3f Player::GetDirection() const { return m_direction; }
 
+std::string Player::GetUsername() const { return m_username; }
+
+float Player::GetHP() const { return m_hp; }
+
 void Player::Teleport(int& x, int& z) {
 	m_position.x -= x * CHUNK_SIZE_X;
 	m_position.z -= z * CHUNK_SIZE_Z;

SQCSim-common/player.h

@@ -1,33 +1,44 @@
-#ifndef _PLAYER_H__
+#ifndef PLAYER_H__
-#define _PLAYER_H__
+#define PLAYER_H__
-#include "vector3.h"
+
 #include <cmath>
+#include "transformation.h"
+#include "vector3.h"
 
 class World; 
 
 class Player {
 public:
+	enum Sound { NOSOUND, STEP, FALL };
+
 	Player(const Vector3f& position, float rotX = 0, float rotY = 0);
 	void TurnLeftRight(float value);
 	void TurnTopBottom(float value);
 	Vector3f GetInput(bool front, bool back, bool left, bool right, bool jump, bool dash, float elapsedTime);
-	void ApplyPhysics(Vector3f input, World* world, float elapsedTime);
+	Sound ApplyPhysics(Vector3f input, World* world, float elapsedTime);
+	void ApplyTransformation(Transformation& transformation, bool rel = true) const;
 
 	Vector3f GetPosition() const;
 	Vector3f GetDirection() const;
 	Vector3f GetVelocity() const;
 	Vector3f GetPOV() const;
+	std::string GetUsername() const;
+	float GetHP() const;
 	void Teleport(int& x, int& z);
 
-protected:
+private:
 	Vector3f m_position;
 	Vector3f m_velocity;
 	Vector3f m_direction;
 
+	std::string m_username;
+
 	float m_rotX = 0; 
 	float m_rotY = 0;
 	float m_POV;
 
+	float m_hp;
+
 	bool m_airborne;
 };
 #endif //_PLAYER_H__

SQCSim-common/transformation.cpp

@@ -51,10 +51,10 @@ void Transformation::ApplyScale(const Vector3f& v)
     ApplyScale(v.x, v.y, v.z);
 }
 
-void Transformation::Use() const
+//void Transformation::Use() const
-{
+//{
-    glLoadMatrixf(m_stack.top().GetInternalValues());
+//    glLoadMatrixf(m_stack.top().GetInternalValues());
-}
+//}
 
 const Matrix4f& Transformation::GetMatrix() const
 {

SQCSim-common/transformation.h

@@ -1,9 +1,10 @@
 #ifndef TRANSFORMATION_H__
 #define TRANSFORMATION_H__
 
+#include <stack>
+#include "define.h"
 #include "matrix4.h"
 #include "vector3.h"
-#include <stack>
 
 class Transformation
 {
@@ -24,7 +25,7 @@ class Transformation
         void ApplyScale(float x, float y, float z);
         void ApplyScale(const Vector3f& v);
 
-        void Use() const;
+        //void Use() const;
 
         const Matrix4f& GetMatrix() const;
 

SQCSim-common/world.cpp

@@ -6,6 +6,10 @@ World::~World() {}
 
 Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
 
+void World::SetSeed(uint64_t seed) {
+	m_seed = seed;
+}
+
 Chunk* World::ChunkAt(float x, float y, float z) const {
 	int cx = (int)x / CHUNK_SIZE_X;
 	int cz = (int)z / CHUNK_SIZE_Z;
@@ -38,23 +42,112 @@ BlockType World::BlockAt(const Vector3f& pos, BlockType defaultBlockType) const
 	return BlockAt(pos.x, pos.y, pos.z, defaultBlockType);
 }
 
+void World::TransposeWorld(Vector3f& player, Bullet* bullets[MAX_BULLETS]) {
+	int x = 0, y = 0;
+
+	if (player.x > (WORLD_SIZE_X * CHUNK_SIZE_X) * .6f) ++x;
+	else if (player.x < (WORLD_SIZE_X * CHUNK_SIZE_X) * .4f) --x;
+	if (player.z > (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .6f) ++y;
+	else if (player.z < (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .4f) --y;
+
+	if (!x && !y) return;
+
+	if (x > 0) {
+		for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
+			for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
+				if (ax - x >= 0) {
+					m_chunks.Set(ax - x, ay,
+						m_chunks.Remove(ax, ay));
+					if (ax == WORLD_SIZE_X - 1 && m_chunks.Get(ax - x, ay))
+						m_chunks.Get(ax - x, ay)->MakeDirty();
+				}
+				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
+	}
+	else if (x < 0) {
+		for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
+			for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
+				if (ax - x < WORLD_SIZE_X) {
+					m_chunks.Set(ax - x, ay,
+						m_chunks.Remove(ax, ay));
+					if (ax == 0 && m_chunks.Get(ax - x, ay))
+						m_chunks.Get(ax - x, ay)->MakeDirty();
+				}
+				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
+	}
+
+	if (y > 0) {
+		for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
+			for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
+				if (ay - y >= 0) {
+					m_chunks.Set(ax, ay - y,
+						m_chunks.Remove(ax, ay));
+					if (ay == WORLD_SIZE_Y - 1 && m_chunks.Get(ax, ay - y))
+						m_chunks.Get(ax, ay - y)->MakeDirty();
+				}
+				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
+	}
+	else if (y < 0) {
+		for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
+			for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
+				if (ay - y < WORLD_SIZE_Y) {
+					m_chunks.Set(ax, ay - y,
+						m_chunks.Remove(ax, ay));
+					if (ay == 0 && m_chunks.Get(ax, ay - y))
+						m_chunks.Get(ax, ay - y)->MakeDirty();
+				}
+				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
+	}
+
+	m_center[0] += x; m_center[1] += y;
+	player.x -= x * CHUNK_SIZE_X;
+	player.z -= y * CHUNK_SIZE_Z;
+
+	for (int index = 0; index < MAX_BULLETS; ++index)
+		if (bullets[index]) bullets[index]->Transpose(x, y);
+}
+
+void World::CleanUpWorld(int& deleteframes, bool clear = false) {
+	if (clear) {
+		while (m_tbDeleted.size() > 0) {
+			delete m_tbDeleted.back();
+			m_tbDeleted.pop_back();
+		}
+	}
+	if (!m_tbDeleted.empty() && !deleteframes) {
+		int deleted = 0;
+		while (deleted < THREADS_DELETE_CHUNKS) {
+
+
+		}
+		delete m_tbDeleted.back();
+		m_tbDeleted.pop_back();
+		deleteframes = FRAMES_DELETE_CHUNKS;
+	}
+}
+
 void World::GetScope(unsigned int& x, unsigned int& y) {
 	x = m_center[0];
 	y = m_center[1];
 }
 
-void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
+void World::Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]) {
-	int bx = (int)pos.x % CHUNK_SIZE_X;
+	UpdateWorld(player_pos, blockinfo);
-	int by = (int)pos.y % CHUNK_SIZE_Y;
+	//TransposeWorld(player_pos, bullets);
-	int bz = (int)pos.z % CHUNK_SIZE_Z;
-
-	ChunkAt(pos)->SetBlock(bx, by, bz, blockType, this);
 }
+//
+//void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
+//	if (updates == 0 && ChunkAt(chx, 1, chy) &&
+//		ChunkAt(chx, 1, chy)->IsDirty()) {
+//		ChunkAt(chx, 1, chy)->Update(blockinfo, this);
+//		updates = FRAMES_UPDATE_CHUNKS;
+//	}
+//
+//}
 
-void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block) {
+void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block) {
-	Vector3f currentPos = player.GetPosition();
+	Vector3f currentPos = player_pos;
 	Vector3f currentBlock = currentPos;
-	Vector3f ray = player.GetDirection();
+	Vector3f ray = player_dir;
 	bool found = false;
 
 	if (block) return;
@@ -76,7 +169,7 @@ void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block
 
 				BlockType bt = BlockAt(currentBlock);
 
-				if (bt == BTYPE_AIR) { // V?rification pour ?tre s?r que le bloc ? changer n'est pas dans le joueur.
+				if (bt == BTYPE_AIR) { // V<EFBFBD>rification pour <EFBFBD>tre s<EFBFBD>r que le bloc <EFBFBD> changer n'est pas dans le joueur.
 					int Bx = (int)currentBlock.x;
 					int By = (int)currentBlock.y;
 					int Bz = (int)currentBlock.z;
@@ -107,3 +200,211 @@ void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block
 		block = true;
 	}
 }
+
+void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
+	int bx = (int)pos.x % CHUNK_SIZE_X;
+	int by = (int)pos.y % CHUNK_SIZE_Y;
+	int bz = (int)pos.z % CHUNK_SIZE_Z;
+
+	ChunkAt(pos)->SetBlock(bx, by, bz, blockType, this);
+	ChunkAt(pos)->MakeModified();
+}
+
+void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]) {
+	int cx = player.x;
+	int cy = player.z;
+	static int frameGenerate = 1;
+	static int frameUpdate = 2;
+	static int frameDelete = 3;
+	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;
+	if (frameDelete > 0) --frameDelete;
+	
+	if (!frameGenerate)
+		while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2 + CHUNK_SIZE_X) {
+			int tx = -side, ty = -side;
+			int chx = 0;
+			int chy = 0;
+
+			for (; tx <= side; ++tx) {
+				if (frameGenerate)
+					break;
+				chx = cx + tx * CHUNK_SIZE_X;
+				chy = cy + ty * CHUNK_SIZE_Z;
+				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
+					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
+					genThList[threads++] = std::async(std::launch::async, 
+						[](unsigned int x, unsigned int y, uint64_t seed) { 
+							return new Chunk(x, y, seed); }, 
+							chx / CHUNK_SIZE_X + m_center[0], 
+							chy / CHUNK_SIZE_Z + m_center[1], 
+							m_seed);
+				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
+			}
+			for (; ty <= side; ++ty) {
+				if (frameGenerate)
+					break;
+				chx = cx + tx * CHUNK_SIZE_X;
+				chy = cy + ty * CHUNK_SIZE_Z;
+				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
+					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
+					genThList[threads++] = std::async(std::launch::async, 
+						[](unsigned int x, unsigned int y, uint64_t seed) { 
+							return new Chunk(x, y, seed); }, 
+							chx / CHUNK_SIZE_X + m_center[0], 
+							chy / CHUNK_SIZE_Z + m_center[1], 
+							m_seed);
+				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
+			}
+			for (; tx >= -side; --tx) {
+				if (frameGenerate)
+					break;
+				chx = cx + tx * CHUNK_SIZE_X;
+				chy = cy + ty * CHUNK_SIZE_Z;
+				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
+					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
+					genThList[threads++] = std::async(std::launch::async, 
+						[](unsigned int x, unsigned int y, uint64_t seed) { 
+							return new Chunk(x, y, seed); }, 
+							chx / CHUNK_SIZE_X + m_center[0], 
+							chy / CHUNK_SIZE_Z + m_center[1], 
+							m_seed);
+				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
+			}
+			for (; ty >= -side; --ty) {
+				if (frameGenerate)
+					break;
+				chx = cx + tx * CHUNK_SIZE_X;
+				chy = cy + ty * CHUNK_SIZE_Z;
+				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
+					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
+					genThList[threads++] = std::async(std::launch::async, 
+						[](unsigned int x, unsigned int y, uint64_t seed) { 
+							return new Chunk(x, y, seed); }, 
+							chx / CHUNK_SIZE_X + m_center[0], 
+							chy / CHUNK_SIZE_Z + m_center[1],
+							m_seed);
+				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
+			}
+			if (frameGenerate)
+				break;
+			++side;
+		}
+
+	if (threads > 0) {
+		for (int i = 0; i < threads; ++i)
+			genThList[i].wait();
+
+		for (int i = 0; i < threads; ++i) {
+			unsigned int x, y;
+			Chunk* chunk = genThList[i].get();
+			chunk->GetPosition(x, y);
+			m_chunks.Set(x - m_center[0], y - m_center[1], chunk);
+		}
+	}
+
+	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-common/world.h

@@ -1,19 +1,18 @@
 #ifndef WORLD_H__
 #define WORLD_H__
+
 #include <fstream>
 #include <string>
 #include <vector>
 #include <future>
 #include <thread>
 #include "define.h"
-#include "chunk.h"
-#include "array2d.h"
 #include "vector3.h"
-#include "player.h"
+#include "array2d.h"
 #include "bullet.h"
+#include "chunk.h"
 
 class Chunk;
-class Player;
 class Bullet;
 
 class World {
@@ -23,23 +22,33 @@ public:
 
 	Array2d<Chunk*>& GetChunks();
 
+	void SetSeed(uint64_t seed);
+
 	Chunk* ChunkAt(float x, float y, float z) const;
 	Chunk* ChunkAt(const Vector3f& pos) const;
 
 	BlockType BlockAt(float x, float y, float z, BlockType defaultBlockType = BTYPE_AIR) const;
 	BlockType BlockAt(const Vector3f& pos, BlockType defaultBlockType = BTYPE_AIR) const;
 
+	void Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]);
+
 	void GetScope(unsigned int& x, unsigned int& y);
 
-	void ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block);
+	void ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block);
 	void ChangeBlockAtPosition(BlockType blockType, Vector3f pos);
-
+	void CleanUpWorld(int& deleteframes, bool clear);
+	int GettbDeleted() const;
 private:
 	Array2d<Chunk*> m_chunks = Array2d<Chunk*>(WORLD_SIZE_X, WORLD_SIZE_Y);
 	std::vector<Chunk*> m_tbDeleted;
+	uint64_t m_seed = 0;
 
 	unsigned int m_center[2] = { UINT16_MAX / 2 - WORLD_SIZE_X, UINT16_MAX / 2 - WORLD_SIZE_Y };
 
+	void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]);
+	void UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]);
+	void TransposeWorld(Vector3f& player, Bullet* bullets[MAX_BULLETS]);
+
 };
 #endif // WORLD_H__
 

SQCSim-srv/cmake/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.18.4)
+
+project(SQCSim-Server VERSION 0.1)
+
+add_compile_options("-Wno-narrowing")
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_STANDARD_REQUIRED True)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "../out")
+
+set(SQCSIM_COMMON_DIR "../../SQCSim-common/")
+
+add_library(SQCSim-common
+			"${SQCSIM_COMMON_DIR}blockinfo.cpp"
+			"${SQCSIM_COMMON_DIR}bullet.cpp"
+			"${SQCSIM_COMMON_DIR}chunk.cpp"
+			"${SQCSIM_COMMON_DIR}netprotocol.cpp"
+			"${SQCSIM_COMMON_DIR}opensimplex.cpp"
+			"${SQCSIM_COMMON_DIR}player.cpp"
+			"${SQCSIM_COMMON_DIR}transformation.cpp"
+			"${SQCSIM_COMMON_DIR}world.cpp"
+)
+
+add_executable(SQCSim-server
+			"../connection.cpp"
+			"../server.cpp"
+			"../main.cpp"
+			)
+
+target_link_libraries(SQCSim-server PUBLIC SQCSim-common)

SQCSim-srv/connection.cpp

@@ -1,48 +1,46 @@
 #include "connection.h"
 
-Connection::Connection(in_addr addr, 
+
-					   std::string name, 
+
-					   UINT64 id, 
+Connection::Connection(SOCKET sock, 
-					   UINT64 self_id,
+					   sockaddr_in sockaddr, 
-				       UINT64 team_id): 
+					   netprot::LoginInfo log, 
-	m_addr(addr), 
+					   netprot::PlayerInfo play):
-	m_id(id), 
+	m_sock(sock), 
-	m_sid(self_id),
+	m_addr(sockaddr), 
-	m_tid(team_id), 
+	m_loginfo(log), 
-	m_name(name) {
+	m_playinfo(play) {
 
 }
 
 Connection::~Connection() {
-
+	closesocket(m_sock);
 }
 
-in_addr Connection::GetAddr() const { return m_addr; }
+uint64_t Connection::GetHash(bool self) const { return self? m_loginfo.sid: m_playinfo.id; }
 
-UINT64 Connection::GetHash(bool self) const { return self? m_sid: m_id; }
+uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
 
-UINT64 Connection::GetTeamHash() const { return m_tid; }
+std::string Connection::GetName() const { return m_loginfo.name; }
 
-std::string Connection::GetName() const { return m_name; }
+void Connection::AddInput(netprot::Input in) {
-
+	m_input_manifest.insert({ in.timestamp, in });
-void Connection::AddInput(Input in) {
-	m_input_manifest.insert({in.timestamp, in});
 }
 
-Output* Connection::getOutput(Timestamp time) {
+netprot::Output* Connection::getOutput(Timestamp time) {
 	auto out = m_output_manifest.find(time);
 	if (out != m_output_manifest.end())
 		return &out->second;
 	return nullptr;
 }
 
-Sync Connection::getSync(Timestamp time) {
+netprot::Sync Connection::getSync(Timestamp time) {
-	Sync sync;
+	netprot::Sync sync;
 	auto out = m_output_manifest.find(time);
 	if (out != m_output_manifest.end()) {
 		sync.timestamp = out->second.timestamp;
 		sync.position = out->second.position;
-		sync.sid = m_sid;
+		sync.sid = m_loginfo.sid;
 	}
 	return sync;
 }

SQCSim-srv/connection.h

@@ -1,60 +1,42 @@
 #ifndef CONNECTION_H__
 #define CONNECTION_H__
+
 #include <deque>
 #include <map>
 #include "../SQCSim-common/player.h"
 #include "../SQCSim-common/vector3.h"
+#include "../SQCSim-common/netprotocol.h"
 #include "define.h"
 
-struct Input {
-	Timestamp timestamp;
-	UINT8 keys; // 0bFBLRJS__
-	Vector3f direction;
-};
-
-struct Output {
-	Timestamp timestamp;
-	UINT64 id = 0;
-	Vector3f position, direction;
-	bool is_shooting, is_jumping;
-};
-
-struct Sync {
-	Timestamp timestamp;
-	UINT64 sid = 0;
-	Vector3f position;
-};
-
 class Connection {
 public:
 	Connection(
-		in_addr addr, 
+		SOCKET sock,
-		std::string name, 
+		sockaddr_in sockaddr,
-		UINT64 hash, 
+		netprot::LoginInfo log,
-		UINT64 self_hash, 
+		netprot::PlayerInfo play);
-		UINT64 team_hash);
 	~Connection();
 
 	Player* player = nullptr;
 
-	in_addr GetAddr() const;
+	uint64_t GetHash(bool self = true) const;
-	UINT64 GetHash(bool self = true) const;
+	uint64_t GetTeamHash() const;
-	UINT64 GetTeamHash() const;
 	std::string GetName() const;
 
-	void AddInput(Input in);
+	void AddInput(netprot::Input in);
-	Output* getOutput(Timestamp time);
+	netprot::Output* getOutput(Timestamp time);
-	Sync getSync(Timestamp time);
+	netprot::Sync getSync(Timestamp time);
 
 	void CleanInputManifest(Timestamp time);
 private:
-	std::map<Timestamp, Input> m_input_manifest;
+	std::map<Timestamp, netprot::Input> m_input_manifest;
-	std::map<Timestamp, Output> m_output_manifest;
+	std::map<Timestamp, netprot::Output> m_output_manifest;
-	in_addr m_addr;
+	std::map<Timestamp, netprot::Chat> m_chatlog;
-	UINT64 m_id,
+
-		   m_sid,
+	SOCKET m_sock;
-		   m_tid;
+	sockaddr_in m_addr;
-	std::string m_name;
+	netprot::LoginInfo m_loginfo;
+	netprot::PlayerInfo m_playinfo;
 
 };
 #endif

SQCSim-srv/define.h

@@ -6,38 +6,12 @@
 #include <sstream>
 #include <cctype>
 #include <string>
-#include <chrono>
 
 #define MAX_CONNECTIONS 16
+#define ID_LIST_SIZE 127
+#define BUFFER_LENGTH 150
+
 typedef unsigned char LogDest;
 enum LOG_DEST { CONSOLE, LOGFILE, LOG_LAST };
-typedef std::chrono::system_clock::time_point Timestamp;
-
-
-#ifdef _WIN32
-
-#pragma comment(lib,"wsock32.lib") // Pour pouvoir faire fonctionner le linker sans le vcxproject
-
-#include <Windows.h>
-#include <cstdio>
-#include <ctime>
-
-#define popen _popen
-#define pclose _pclose
-
-#else // Pas _WIN32
-
-#include <unistd.h>
-#include <time.h>
-#include <stdio.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-
-#define SOCKET int
-#define INVALID_SOCKET -1
-#define closesocket close
-
-#endif // _WIN32
 
 #endif

SQCSim-srv/main.cpp

@@ -1,4 +1,3 @@
-#include "define.h"
 #include "server.h"
 
 int main() {

SQCSim-srv/server.cpp

@@ -61,9 +61,6 @@ int Server::Init() {
 		return 5;
 	}
 
-	for (auto& conn : m_conn)
-		conn = nullptr;
-
 	return 0;
 }
 
@@ -73,24 +70,77 @@ int Server::Ready() {
 		return 1;
 	}
 
-	char buffer[2048];
+	char* buf = new char[150];
+	uint32_t buflen = 150;
 	bool readystart = false;
+	srand(time(NULL));
 
 	Log("<EFBFBD> l'<27>coute sur le port: " + std::to_string(SRV_PORT), false, false);
 
-	while (!readystart) {
+	buildIdList(ID_LIST_SIZE);
 
-		Log("trololo", false, false);
+	m_game.countdown = 360;
-		readystart = true;
+	m_game.gameType = 1;
+	m_game.seed = 9370707;
+
+	while (!readystart) {
+		sockaddr_in sockad;
+		unsigned int addrlen = sizeof(sockad);
+		SOCKET sock = accept(m_sock_tcp, (sockaddr*)&sockad, &addrlen);
+
+		if (sock < 0)
+			Log("Erreur de connexion", true, false);
+		else if (sock > 0) {
+			std::string str = "Nouvelle connection provenant de: ";
+			char* strbuf = new char[BUFFER_LENGTH];
+			uint32_t strbuflen = BUFFER_LENGTH;
+
+			str.append(inet_ntop(AF_INET, &sockad.sin_addr, strbuf, strbuflen)).append(": ").append(std::to_string(sockad.sin_port));
+
+			if (recv(sock, buf, buflen, 0) > 0) {
+				netprot::LoginInfo log;
+				netprot::PlayerInfo play;
+				if (netprot::Deserialize(&log, buf, buflen)) {
+					log.sid = getUniqueId();
+
+					log.tid = 0;
+
+					str.append(" Nom: ").append(log.name); 
+					Log(str, false, false);
+					str = "";
+					
+					str.append(log.name).append(" SID: [").append(std::to_string(log.sid).append("]"));
+					Log(str, false, false);
+
+					//netprot::Serialize(&log, &buf, &buflen);
+					//send(sock, buf, buflen, 0);
+					//buflen = 150;
+					sendPack<netprot::LoginInfo>(sock, &log, &buf, &buflen);
+
+					play.id = getUniqueId();
+					memcpy(play.name, log.name, std::strlen(log.name) + 1);
+					play.tid = log.tid;
+
+					//netprot::Serialize(&m_game, &buf, &buflen);
+					//send(sock, buf, buflen, 0);
+					sendPack<netprot::GameInfo>(sock, &m_game, &buf, &buflen);
+					Connection* conn = new Connection(sock, sockad, log, play);
+
+					m_players[log.sid] = conn;
+					readystart = true;
+				}
+			}
+		}
 	}
 	return 0;
 }
 
 void Server::Run() {
+
 	Log("Partie en cours...", false, false);
 }
 
-inline std::string Server::Timestamp() {
+inline std::string Server::LogTimestamp() {
 	time_t rawtime;
 	struct tm timeinfo;
 	char buffer[80];
@@ -112,11 +162,11 @@ inline std::string Server::Timestamp() {
 void Server::Log(std::string str, bool is_error = false, bool is_fatal = false) {
 	switch (m_log) {
 	case LOG_DEST::LOGFILE:
-		m_logfile << Timestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
+		m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
 		break;
 	case LOG_DEST::CONSOLE:
 	default:
-		std::cout << Timestamp() << (is_fatal? "FATAL ": "") << (is_error ? "ERROR ": "") << str << std::endl;
+		std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
 		break;
 	}
 
@@ -131,6 +181,41 @@ void Server::Log(std::string str, bool is_error = false, bool is_fatal = false)
 	}
 }
 
+void Server::buildIdList(size_t size) {
+	std::set<uint64_t> lst;
+
+	do lst.insert(((uint64_t)rand() << 25) % 8675309); // EIGHT SIX SEVENFIVE THREE AUGHT NIIIIIIiIIiiIiINE!
+	while (lst.size() < size);
+	
+	m_ids = std::vector<uint64_t>(lst.begin(), lst.end());
+}
+
+uint64_t Server::getUniqueId() {
+	uint64_t id = m_ids.back();
+	m_ids.pop_back();
+	return id;
+}
+
+// Test serialize/deserialize:
+/*
+	netprot::LoginInfo log, log2;
+	std::cout << "Nom? ";
+	std::cin.getline(log.name, 32); // NO! STD::CIN >> VARIABLE;! EVEEEEEERRRR!!!
+	log.sid = 12345;
+	char* buf = new char[150];
+	uint32_t buflen = 150;
+
+	netprot::Serialize(&log, &buf, &buflen);
+
+	bool is_work = netprot::Deserialize(&log2, buf, buflen);
+
+	std::string str;
+	str.append(is_work ? "Y " : "N ").append(log2.name).append(": ").append(std::to_string(log2.sid));
+
+	Log(str, false, false);
+*/
+
+
 ///* Recevoir paquet */
 //while (true) {
 //	char buffer[2048];

SQCSim-srv/server.h

@@ -3,8 +3,10 @@
 
 #include <fstream>
 #include <vector>
+#include <set>
 #include <string>
 #include "../SQCSim-common/world.h"
+#include "../SQCSim-common/netprotocol.h"
 #include "define.h"
 #include "connection.h"
 
@@ -26,10 +28,27 @@ private:
 	LogDest m_log;
 	std::ofstream m_logfile;
 
-	Connection* m_conn[MAX_CONNECTIONS];
+	std::map<uint64_t, Connection*> m_players;
+	std::map <Timestamp, netprot::Chat> m_chatlog;
+	std::vector<uint64_t> m_ids;
+	netprot::GameInfo m_game;
+
 	World* m_world = nullptr;
 
-	std::string Timestamp();
+	std::string LogTimestamp();
 	void Log(std::string str, bool is_error, bool is_fatal);
+	void buildIdList(size_t size);
+
+	uint64_t getUniqueId(); 
+	template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
+
 };
+
+template <class T>
+void Server::sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
+	netprot::Serialize(pack, buf, buflen);
+	send(sock, *buf, *buflen, 0);
+	*buflen = BUFFER_LENGTH;
+}
+
 #endif

SQCSim2021/SQCSim2021.vcxproj

@@ -19,46 +19,39 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="array2d.h" />
-    <ClInclude Include="array3d.h" />
     <ClInclude Include="audio.h" />
-    <ClInclude Include="blockinfo.h" />
+    <ClInclude Include="connector.h" />
-    <ClInclude Include="bullet.h" />
-    <ClInclude Include="chunk.h" />
     <ClInclude Include="define.h" />
     <ClInclude Include="engine.h" />
-    <ClInclude Include="matrix4.h" />
+    <ClInclude Include="mesh.h" />
     <ClInclude Include="openglcontext.h" />
-    <ClInclude Include="opensimplex.h" />
-    <ClInclude Include="player.h" />
     <ClInclude Include="shader.h" />
     <ClInclude Include="skybox.h" />
     <ClInclude Include="texture.h" />
     <ClInclude Include="textureatlas.h" />
     <ClInclude Include="tool.h" />
-    <ClInclude Include="transformation.h" />
-    <ClInclude Include="vector3.h" />
     <ClInclude Include="vertexbuffer.h" />
-    <ClInclude Include="world.h" />
+    <ClInclude Include="worldrenderer.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="audio.cpp" />
-    <ClCompile Include="blockinfo.cpp" />
+    <ClCompile Include="connector.cpp" />
-    <ClCompile Include="bullet.cpp" />
-    <ClCompile Include="chunk.cpp" />
     <ClCompile Include="engine.cpp" />
     <ClCompile Include="main.cpp" />
+    <ClCompile Include="mesh.cpp" />
     <ClCompile Include="openglcontext.cpp" />
-    <ClCompile Include="opensimplex.cpp" />
-    <ClCompile Include="player.cpp" />
     <ClCompile Include="shader.cpp" />
     <ClCompile Include="skybox.cpp" />
     <ClCompile Include="texture.cpp" />
     <ClCompile Include="textureatlas.cpp" />
     <ClCompile Include="tool.cpp" />
-    <ClCompile Include="transformation.cpp" />
     <ClCompile Include="vertexbuffer.cpp" />
-    <ClCompile Include="world.cpp" />
+    <ClCompile Include="worldrenderer.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SQCSim-common\SQCSim-common.vcxproj">
+      <Project>{ee91ab12-4225-4a4d-931d-69d72f6d91fb}</Project>
+    </ProjectReference>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{A21FD938-1FEA-4687-AB86-0EABAC30877B}</ProjectGuid>
@@ -175,8 +168,8 @@
       <FloatingPointModel>Fast</FloatingPointModel>
     </ClCompile>
     <Link>
-      <SubSystem>Console</SubSystem>
+      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalDependencies>irrKlang.lib;sfml-main.lib;sfml-system.lib;sfml-window.lib;sfml-graphics.lib;GlU32.Lib;OpenGL32.Lib;DevIL.lib;ILU.lib;ILUT.lib;glew32.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -197,8 +190,8 @@
       <FloatingPointModel>Fast</FloatingPointModel>
     </ClCompile>
     <Link>
-      <SubSystem>Console</SubSystem>
+      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalDependencies>irrKlang.lib;sfml-main.lib;sfml-system.lib;sfml-window.lib;sfml-graphics.lib;GlU32.Lib;OpenGL32.Lib;DevIL.lib;ILU.lib;ILUT.lib;glew32.lib;%(AdditionalDependencies)</AdditionalDependencies>

SQCSim2021/SQCSim2021.vcxproj.filters

@@ -11,51 +11,21 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="array3d.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="blockinfo.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="chunk.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="define.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
     <ClInclude Include="engine.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="matrix4.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="openglcontext.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="texture.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="transformation.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="vector3.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="player.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="shader.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="tool.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="vertexbuffer.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="array2d.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="skybox.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
@@ -65,23 +35,23 @@
     <ClInclude Include="textureatlas.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="world.h">
+    <ClInclude Include="connector.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="bullet.h">
+    <ClInclude Include="openglcontext.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="opensimplex.h">
+    <ClInclude Include="tool.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
+    <ClInclude Include="mesh.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
+    <ClInclude Include="worldrenderer.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="blockinfo.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="chunk.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="engine.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
@@ -94,18 +64,9 @@
     <ClCompile Include="texture.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="transformation.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="player.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="shader.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="tool.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="vertexbuffer.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
@@ -118,13 +79,16 @@
     <ClCompile Include="textureatlas.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="world.cpp">
+    <ClCompile Include="connector.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="bullet.cpp">
+    <ClCompile Include="tool.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="opensimplex.cpp">
+    <ClCompile Include="mesh.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
+    <ClCompile Include="worldrenderer.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
   </ItemGroup>

SQCSim2021/array2d.h

@@ -1,61 +0,0 @@
-#ifndef ARRAY2D_H__
-#define ARRAY2D_H__
-
-#include "define.h"
-
-template <class T>
-class Array2d {
-    public:
-        Array2d(int x, int y);
-        ~Array2d();
-        Array2d(const Array2d& array);
-
-        void Set(int x, int y, T type);
-        T Get(int x, int y) const;
-        T Remove(int x, int y);
-
-        void Reset(T type);
-
-    private:
-        int m_x, m_y;
-        T* m_array;
-
-        int To1dIndex(int x, int y) const;
-};
-
-template <class T>
-Array2d<T>::Array2d(int x, int y) : m_x(x), m_y(y) { m_array = new T[m_x * m_y]; }
-
-template <class T>
-Array2d<T>::~Array2d() { delete[] m_array; }
-
-template <class T>
-Array2d<T>::Array2d(const Array2d<T>& array) : m_x(array.m_x), m_y(array.m_y) {
-    m_array = new T[m_x * m_y];
-    for (int i = 0; i < m_x * m_y; ++i)
-        m_array[i] = array.m_array[i];
-}
-
-template <class T>
-void Array2d<T>::Set(int x, int y, T type) { m_array[To1dIndex(x, y)] = type; }
-
-template <class T>
-T Array2d<T>::Get(int x, int y) const { return m_array[To1dIndex(x, y)]; }
-
-template <class T>
-T Array2d<T>::Remove(int x, int y) { 
-    T thing = std::move(m_array[To1dIndex(x, y)]);
-    m_array[To1dIndex(x, y)] = nullptr;
-    return thing;
-}
-
-template <class T>
-void Array2d<T>::Reset(T type) {
-    for (int i = 0; i < m_x * m_y; ++i)
-        m_array[i] = type;
-}
-
-template <class T>
-int Array2d<T>::To1dIndex(int x, int y) const { return x + (y * m_x); }
-
-#endif // ARRAY2D_H__

SQCSim2021/array3d.h

@@ -1,55 +0,0 @@
-#ifndef ARRAY3D_H__
-#define ARRAY3D_H__
-
-#include "define.h"
-
-template <class T>
-class Array3d {
-    public:
-        Array3d(int x, int y, int z);
-        ~Array3d();
-        Array3d(const Array3d& array);
-
-        void Set(int x, int y, int z, T type);
-        T Get(int x, int y, int z) const;
-
-        void Reset(T type);
-
-    private:
-        int m_x, m_y, m_z;
-        T* m_array;
-
-        int To1dIndex(int x, int y, int z) const;
-};
-
-template <class T>
-Array3d<T>::Array3d(int x, int y, int z) : m_x(x), m_y(y), m_z(z) { m_array = new T[m_x * m_y * m_z]; }
-
-template <class T>
-Array3d<T>::~Array3d() { delete[] m_array; }
-
-template <class T>
-Array3d<T>::Array3d(const Array3d<T>& array) : m_x(array.m_x), m_y(array.m_y), m_z(array.m_z) {
-    m_array = new T[m_x * m_y * m_z];
-    for (int i = 0; i < m_x * m_y * m_z; ++i)
-        m_array[i] = array.m_array[i];
-}
-
-template <class T>
-void Array3d<T>::Set(int x, int y, int z, T type) { 
-    m_array[To1dIndex(x, y, z)] = type; 
-}
-
-template <class T>
-T Array3d<T>::Get(int x, int y, int z) const { return m_array[To1dIndex(x, y, z)]; }
-       
-template <class T>
-void Array3d<T>::Reset(T type) {
-    for (int i = 0; i < m_x * m_y * m_z; ++i)
-        m_array[i] = type;
-}
-
-template <class T>
-int Array3d<T>::To1dIndex(int x, int y, int z) const { return x + (z * m_x) + (y * m_z * m_x); }
-
-#endif // ARRAY3D_H__

SQCSim2021/audio.h

@@ -1,10 +1,16 @@
 #ifndef AUDIO_H__
 #define AUDIO_H__
 
+#ifdef _WIN32
 #include <irrKlang.h>
 #include <ik_ISoundSource.h>
+#else
+#include "./external/irrKlang-64bit-1.6.0/include/irrKlang.h"
+#include "./external/irrKlang-64bit-1.6.0/include/ik_ISoundSource.h"
+#endif
+
+#include "../SQCSim-common/vector3.h"
 #include "define.h"
-#include "vector3.h"
 
 class Audio {
 private:

SQCSim2021/blockinfo.cpp

@@ -1,42 +0,0 @@
-#include "blockinfo.h"
-#include <iostream>
-
-BlockInfo::BlockInfo(BlockType type, const std::string& name, float u, float v, float s, int dur) : m_type(type), m_name(name), m_u(u), m_v(v), m_s(s), m_durability(dur)
-{
-}
-
-BlockInfo::~BlockInfo()
-{
-}
-
-BlockType BlockInfo::GetType() const
-{
-    return m_type;
-}
-
-void BlockInfo::SetDurability(int durability)
-{
-    m_durability = durability;
-}
-
-int BlockInfo::GetDurability() const
-{
-    return m_durability;
-}
-
-void BlockInfo::GetTexture(float& u, float& v, float& s)
-{
-    u = m_u;
-    v = m_v;
-    s = m_s;
-}
-
-void BlockInfo::Show() const
-{
-    std::cout << "Type: " << m_type << std::endl;
-    std::cout << "Nom: " << m_name << std::endl;
-    std::cout << "Durabilite: " << m_durability << std::endl;
-    std::cout << "Coordonnees Texture: " << m_u << ", " << m_v << ", " << m_s << std::endl;
-}
-
-

SQCSim2021/blockinfo.h

@@ -1,32 +0,0 @@
-#ifndef BLOCKINFO_H__
-#define BLOCKINFO_H__
-
-#include <string>
-#include "define.h"
-
-class BlockInfo
-{
-    public:
-    BlockInfo(BlockType type, const std::string& name, float u, float v, float s, int dur);
-    ~BlockInfo();
-
-    BlockType GetType() const;
-
-    void SetDurability(int durability);
-    int GetDurability() const;
-
-    void GetTexture(float& u, float& v, float& s);
-
-    void Show() const;
-
-    private:
-    BlockType m_type;
-    float m_u;
-    float m_v;
-    float m_s;
-    std::string m_name;
-    int m_durability;
-
-};
-
-#endif // BLOCKINFO_H__

SQCSim2021/bullet.cpp

@@ -1,32 +0,0 @@
-#include "bullet.h"
-#include "world.h"
-
-Bullet::Bullet(Player& player) {
-	m_startpos = m_currentpos = player.GetPOV() + player.GetDirection();
-	m_velocity = player.GetDirection();
-}
-
-Bullet::~Bullet() {}
-
-bool Bullet::Update(World* world, Transformation& tran, float elapsedtime) {
-	for (int x = 0; x < 1000; ++x) {
-		m_currentpos += m_velocity * elapsedtime;
-
-		if (!world->ChunkAt(m_currentpos))
-			return true;
-		else if (world->BlockAt(m_currentpos) != BTYPE_AIR) {
-			world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
-			return true;
-		}
-		else if ((m_currentpos - m_startpos).Length() > VIEW_DISTANCE) return true;
-	}
-
-	return false;
-}
-
-void Bullet::Transpose(int& x, int& z) {
-	m_currentpos.x -= x * CHUNK_SIZE_X;
-	m_currentpos.z -= z * CHUNK_SIZE_Z;
-	m_startpos.x -= x * CHUNK_SIZE_X;
-	m_startpos.z -= z * CHUNK_SIZE_Z;
-}

SQCSim2021/bullet.h

@@ -1,27 +0,0 @@
-#ifndef BULLET_H__
-#define BULLET_H__
-
-#include "audio.h"
-#include "player.h"
-#include "vertexbuffer.h"
-#include "texture.h"
-
-class World;
-
-class Bullet {
-public:
-	Bullet(Player& player);
-	~Bullet();
-
-	bool Update(World* world, Transformation& tran, float elapsedtime);
-	void Transpose(int& x, int& z);
-
-private:
-	Vector3f m_startpos;
-	Vector3f m_currentpos;
-	Vector3f m_velocity;
-
-};
-
-#endif // BULLET_H__
-

SQCSim2021/chunk.cpp

@@ -1,234 +0,0 @@
-#include "chunk.h"
-#include "world.h"
-
-Chunk::Chunk(unsigned int x, unsigned int y) : m_posX(x), m_posY(y) { 
-    //std::ostringstream pos; // V<>rifie l'existence d'un fichier .chunk avec sa position.
-    //pos << CHUNK_PATH << x << '_' << y << ".chunk";
-    //std::ifstream input(pos.str(), std::fstream::binary);
-
-    //if (input.fail()) {
-        OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(SEED);
-        m_blocks.Reset(BTYPE_AIR);
-
-        for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Montagnes
-            for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
-                float xnoiz, ynoiz;
-                xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4096.;
-                ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4096.;
-                double height = 0;
-                for (int x = 0; x < 39; ++x) {
-                    height += simplex.eval(xnoiz, ynoiz);
-                    height *= .79;
-                    xnoiz *= 1.139;
-                    ynoiz *= 1.139;
-                }
-                height = height * 2000. * simplex.eval((double)(ix + x * CHUNK_SIZE_X) / 512., (double)(iz + y * CHUNK_SIZE_Z) / 512.);
-                height /= (CHUNK_SIZE_Y / 1.9);
-                height += 15.;
-                for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy)
-                    SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
-            }
-        for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Collines
-            for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
-                float xnoiz, ynoiz;
-                xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 512.;
-                ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 512.;
-                float height = simplex.eval(xnoiz, ynoiz) * 50.f;// +1.f;
-                for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy) {
-                    if (GetBlock(ix, iy, iz) == BTYPE_AIR)
-                        SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr);
-                }
-            }
-        for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Lacs"
-            for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
-                for (int iy = 0; iy < 13; ++iy) {
-                    if (GetBlock(ix, iy, iz) == BTYPE_AIR)
-                        SetBlock(ix, iy, iz, BTYPE_ICE, nullptr);
-                }
-            }
-        //for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Arbres"
-        //    for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
-        //        float xnoiz, ynoiz;
-        //        xnoiz = (double)(iz * CHUNK_SIZE_Y + x * CHUNK_SIZE_X) / 256.;
-        //        ynoiz = (double)(ix * CHUNK_SIZE_Y + y * CHUNK_SIZE_Z) / 256.;
-        //        bool tree = (int)(abs(simplex.eval(xnoiz, ynoiz)) * 17933.f) % CHUNK_SIZE_Y > 126 ? true : false;
-        //        for (int iy = 0; iy < CHUNK_SIZE_Y - 10; ++iy)
-        //            if (GetBlock(ix, iy, iz) == BTYPE_AIR)
-        //                if (GetBlock(ix, iy - 1, iz) == BTYPE_GRASS)
-        //                    if (tree) {
-        //                        for (int i = 0; i < (int)(abs(simplex.eval(xnoiz, ynoiz) * 4)) % 42 + 1; ++i)
-        //                            SetBlock(ix, iy + i, iz, BTYPE_DIRT, nullptr);
-        //                        break;
-        //                    }
-        //    }
-    /* }
-    else {
-        input.seekg(0, std::ios_base::end);
-        int size = input.tellg();
-        input.seekg(0, std::ios_base::beg);
-
-        char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
-        input.read(data, size);
-        input.close();
-
-        for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
-            for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz)
-                for (int iy = 0; iy < CHUNK_SIZE_Y; ++iy)
-                    m_blocks.Set(ix, iy, iz, data[ix + (iz * CHUNK_SIZE_X) + (iy * CHUNK_SIZE_Z * CHUNK_SIZE_X)]);
-    }*/
-}
-
-Chunk::~Chunk() {
-    /*if (m_isModified) {
-        char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
-
-        for (int x = 0; x < CHUNK_SIZE_X; ++x)
-            for (int z = 0; z < CHUNK_SIZE_Z; ++z)
-                for (int y = 0; y < CHUNK_SIZE_Y; ++y)
-                    data[x + (z * CHUNK_SIZE_X) + (y * CHUNK_SIZE_Z * CHUNK_SIZE_X)] = (char)GetBlock(x, y, z);
-
-        std::ostringstream pos;
-        pos << CHUNK_PATH << m_posX << '_' << m_posY << ".chunk";
-
-        std::ofstream output(pos.str(), std::fstream::binary);
-        output.write(data, sizeof(data));
-        output.close();
-    }*/
-}
-
-void Chunk::RemoveBlock(int x, int y, int z, World* world) {
-    m_blocks.Set(x, y, z, BTYPE_AIR);
-    CheckNeighbors(x, y, world);
-    m_isDirty = true;
-}
-
-void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
-    m_blocks.Set(x, y, z, type);
-    if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas v<>rifier les chunks voisines.
-    m_isDirty = true;
-}
-
-BlockType Chunk::GetBlock(int x, int y, int z) { return m_blocks.Get(x, y, z); }
-
-void Chunk::CheckNeighbors(unsigned int x, unsigned int z, World* world) {
-    unsigned int cx, cy;
-
-    world->GetScope(cx, cy);
-
-    if (x == 0 && m_posX - cx >= 0 &&
-        world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
-        world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
-    else if (x == CHUNK_SIZE_X - 1 && m_posX - cx < WORLD_SIZE_X && 
-        world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
-        world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
-
-    if (z == 0 && m_posY - cy >= 0 && 
-        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z))
-        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z)->MakeDirty();
-    else if (z == CHUNK_SIZE_X - 1 && m_posY - cy < WORLD_SIZE_Y &&
-        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z))
-        world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z)->MakeDirty();
-}
-
-void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
-
-void Chunk::FlushMeshToVBO() {
-    m_vertexBuffer.SetMeshData(m_vd, m_vcount);
-    m_vcount = 0;
-    delete[] m_vd;
-}
-
-void Chunk::FlushVBO() {
-    m_vertexBuffer.Flush();
-}
-
-void Chunk::Update(BlockInfo* blockinfo[BTYPE_LAST], World* world) {
-    float u, v, s;
-    // Update mesh
-    if (m_isDirty) {
-        int maxVertexCount = (CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z) * (6 * 4);
-        m_vd = new VertexBuffer::VertexData[maxVertexCount];
-        m_vcount = 0;
-        for (int x = 0; x < CHUNK_SIZE_X; ++x) {
-            for (int z = 0; z < CHUNK_SIZE_Z; ++z) {
-                for (int y = 0; y < CHUNK_SIZE_Y; ++y) {
-                    if (m_vcount > USHRT_MAX)
-                        break;
-
-                    BlockType bt = GetBlock(x, y, z);
-
-                    if (bt != BTYPE_AIR) {
-                        blockinfo[bt]->GetTexture(u, v, s);
-                        AddBlockToMesh(m_vd, m_vcount, bt, x, y, z, u, v, s, world);
-                    }
-                }
-            }
-        }
-        if (m_vcount > USHRT_MAX) {
-            m_vcount = USHRT_MAX;
-            std::cout << "[ Chunk :: Update ] Chunk data truncaned , too much vertices to have a 16 bit index " << std::endl;
-        }
-    }
-    m_isDirty = false;
-}
-
-void Chunk::AddBlockToMesh(VertexBuffer::VertexData* vd, int& count, BlockType bt, 
-                           int x, int y, int z, float u, float v, float s, World* world) {
-    
-    unsigned int cex, cey;
-
-    world->GetScope(cex, cey);
-
-    int cx = x + (m_posX - cex) * CHUNK_SIZE_X, cy = z + (m_posY - cey) * CHUNK_SIZE_Z;
-
-    if (y == CHUNK_SIZE_Y - 1 || GetBlock(x, y + 1, z) == BTYPE_AIR) {                      //  y
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, .8f, .8f, .8f, u, v);
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .8f, .8f, .8f, u, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .8f, .8f, .8f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, .8f, .8f, .8f, u + s, v);
-    }
-
-    if (y == 0 || GetBlock(x, y - 1, z) == BTYPE_AIR) {                                     // -y
-        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .2f, .2f, .2f, u, v);
-        vd[count++] = VertexBuffer::VertexData(x, y, z, .2f, .2f, .2f, u, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z, .2f, .2f, .2f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .2f, .2f, .2f, u + s, v);
-    }
-
-    if (world->BlockAt(cx + 1, y, cy) == BTYPE_AIR) {                      //  x
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z, .9f, .9f, .9f, u, v);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, .9f, .9f, .9f, u, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .9f, .9f, .9f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .9f, .9f, .9f, u + s, v);
-    }
-
-    if (world->BlockAt(cx - 1, y, cy) == BTYPE_AIR) {                                     // -x
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .5f, .5f, .5f, u, v + s);
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, .5f, .5f, .5f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x, y, z, .5f, .5f, .5f, u + s, v);
-        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .5f, .5f, .5f, u, v);
-    }
-
-    if (world->BlockAt(cx, y, cy + 1) == BTYPE_AIR) {                      //  z
-        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .4f, .4f, .4f, u, v);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .4f, .4f, .4f, u + s, v);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .4f, .4f, .4f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .4f, .4f, .4f, u, v + s);
-    }
-
-    if (world->BlockAt(cx, y, cy - 1) == BTYPE_AIR) {                                     // -z
-        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, 1.f, 1.f, 1.f, u, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, 1.f, 1.f, 1.f, u + s, v + s);
-        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z , 1.f, 1.f, 1.f, u + s, v);
-        vd[count++] = VertexBuffer::VertexData(x, y, z , 1.f, 1.f, 1.f, u, v);
-    }
-}
-
-void Chunk::Render() const { m_vertexBuffer.Render(); }
-
-bool Chunk::IsDirty() const { return m_isDirty; }
-
-void Chunk::MakeDirty() { m_isDirty = true; }
-
-void Chunk::MakeModified() { m_isModified = true; }
-

SQCSim2021/chunk.h

@@ -1,49 +0,0 @@
-#ifndef CHUNK_H__
-#define CHUNK_H__
-#include "define.h"
-#include "array3d.h"
-#include "array2d.h"
-#include "vertexbuffer.h"
-#include "blockinfo.h"
-#include "opensimplex.h"
-
-class World;
-
-class Chunk {
-    private:
-        Array3d<BlockType> m_blocks = Array3d<BlockType>(CHUNK_SIZE_X, CHUNK_SIZE_Y, CHUNK_SIZE_Z);
-        VertexBuffer m_vertexBuffer;
-        bool m_isDirty = true;
-        bool m_isModified = false;
-
-        unsigned int m_posX; // Position du chunk dans l'array constituant le monde.
-        unsigned int m_posY;
-
-        VertexBuffer::VertexData* m_vd;
-        int m_vcount;
-
-        void AddBlockToMesh(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s, World* world);
-
-    public:
-        Chunk(unsigned int x, unsigned int y);
-        ~Chunk();
-
-        void RemoveBlock(int x, int y, int z, World* world);
-        void SetBlock(int x, int y, int z, BlockType type, World* world);
-        BlockType GetBlock(int x, int y, int z);
-        void CheckNeighbors(unsigned int x, unsigned int z, World* world);
-        void GetPosition(unsigned int& x, unsigned int& y) const;
-
-
-        void Update(BlockInfo* blockinfo[BTYPE_LAST], World* world);
-        void FlushMeshToVBO();
-
-        void FlushVBO();
-        
-        void Render() const;
-        bool IsDirty() const;
-        void MakeDirty();
-        void MakeModified();
-};
-
-#endif // CHUNK_H__

SQCSim2021/cmake/CMakeLists.txt

@@ -0,0 +1,68 @@
+cmake_minimum_required(VERSION 3.18.4)
+
+project(SQCSim-Client VERSION 0.8)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_STANDARD_REQUIRED True)
+
+set(CMAKE_BUILD_DIRECTORY "./build")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "../")
+
+set(SQCSIM_COMMON_DIR "../../SQCSim-common/")
+set(SQCSIM_EXTERN_DIR "../external/")
+
+find_package(SFML COMPONENTS system window graphics REQUIRED)
+find_package(DevIL REQUIRED)
+find_package(OpenGL REQUIRED)
+find_package(GLEW REQUIRED)
+
+find_library(IRRKLANG_LIBRARY
+	NAMES libIrrKlang.so
+	PATHS "${SQCSIM_EXTERN_DIR}/irrKlang-64bit-1.6.0/lib/linux-gcc-64/")
+
+include_directories(
+	${SQCSIM_EXTERN_DIR}/irrKlang-64bit-1.6.0/include/
+			${SFML_INCLUDE_DIRS}
+			${IL_INCLUDE_DIR}
+			)
+
+
+add_library(SQCSim-common
+			"${SQCSIM_COMMON_DIR}blockinfo.cpp"
+			"${SQCSIM_COMMON_DIR}bullet.cpp"
+			"${SQCSIM_COMMON_DIR}chunk.cpp"
+			"${SQCSIM_COMMON_DIR}netprotocol.cpp"
+			"${SQCSIM_COMMON_DIR}opensimplex.cpp"
+			"${SQCSIM_COMMON_DIR}player.cpp"
+			"${SQCSIM_COMMON_DIR}transformation.cpp"
+			"${SQCSIM_COMMON_DIR}world.cpp"
+)
+
+add_executable(SQCSim-client
+			"../audio.cpp"
+			"../connector.cpp"
+			"../engine.cpp"
+			"../mesh.cpp"
+			"../openglcontext.cpp"
+			"../shader.cpp"
+			"../skybox.cpp"
+			"../texture.cpp"
+			"../textureatlas.cpp"
+			"../tool.cpp"
+			"../vertexbuffer.cpp"
+			"../worldrenderer.cpp"
+			"../main.cpp"
+			)
+
+target_link_libraries(SQCSim-client PUBLIC SQCSim-common
+			${IRRKLANG_LIBRARY}
+			sfml-system
+			sfml-window
+			sfml-graphics
+			GL
+			GLU
+			GLEW
+			${IL_LIBRARIES}
+			${ILU_LIBRARIES}
+			)
+

SQCSim2021/connector.cpp

@@ -0,0 +1,101 @@
+#include "connector.h"
+
+Connector::Connector() {}
+
+Connector::~Connector() {}
+
+int Connector::Init() {
+#ifdef _WIN32
+	if (WSAStartup(MAKEWORD(2, 2), &m_wsaData) != 0) { /* Initialisation de l'environnement reseau (Windows only) */
+		std::cout << "Initialisation WinSock." << std::endl;
+		return 1;
+	}
+#endif
+
+	m_sock_udp = socket(AF_INET, SOCK_DGRAM, 0);
+	if (m_sock_udp == INVALID_SOCKET) { /* Creation du socket UDP */
+		std::cout << "Creation Socket UDP." << std::endl;
+		return 2;
+	}
+
+	m_sock_tcp = socket(AF_INET, SOCK_STREAM, 0);
+	if (m_sock_tcp == INVALID_SOCKET) { /* Creation du socket TCP */
+		std::cout << "Creation Socket TCP." << std::endl;
+		return 3;
+	}
+
+	/* Creation structure donnes descripteur du socket serveur */
+	sockaddr_in addr;
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(CLI_PORT);
+	addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	if (bind(m_sock_udp, (sockaddr*)&addr, sizeof(addr)) != 0) { /* Associer le socket UDP au port */
+		std::cout << "Association Socket UDP." << std::endl;
+		return 4;
+	}
+
+	if (bind(m_sock_tcp, (sockaddr*)&addr, sizeof(addr)) != 0) { /* Associer le socket TCP au port */
+		std::cout << "Association Socket TCP." << std::endl;
+		return 5;
+	}
+	return 0;
+}
+
+int Connector::Connect(char* srv_addr, std::string name) {
+	sockaddr_in add;
+	m_srvsockaddr.sin_family = AF_INET;
+	m_srvsockaddr.sin_port = htons(SRV_PORT);
+
+	if (inet_pton(AF_INET, srv_addr, &m_srvsockaddr.sin_addr) <= 0) {
+		std::cout << "Addresse serveur invalide." << std::endl;
+		return 1;
+	}
+
+	if (connect(m_sock_tcp, (sockaddr*)&m_srvsockaddr, sizeof(m_srvsockaddr)) < 0) {
+		std::cout << "<EFBFBD>chec de la connexion." << std::endl;
+	}
+
+	char* buf = new char[150];
+	uint32_t buflen = 150;
+	netprot::LoginInfo log;
+	memcpy(&log.name, name.c_str(), name.size() + 1);
+
+	netprot::Serialize(&log, &buf, &buflen);
+
+	int se = send(m_sock_tcp, buf, buflen, 0);
+
+	delete[] buf;
+	buf = new char[150] {0};
+	buflen = 150;
+	int rpack = 0;
+
+	while (rpack < 2) {
+		recv(m_sock_tcp, buf, buflen, 0);
+
+		switch (netprot::getType(buf, buflen)) {
+		case netprot::PACKET_TYPE::LOGINF:
+			if (!netprot::Deserialize(&m_loginfo, buf, buflen)) {
+				std::cout << "Packet LoginInfo invalide." << std::endl;
+				return 2;
+			}
+			++rpack;
+			break;
+		case netprot::PACKET_TYPE::GAMEINFO:
+			if (!netprot::Deserialize(&m_gameinfo, buf, buflen)) {
+				std::cout << "Packet GameInfo invalide." << std::endl;
+				return 3;
+			}
+			++rpack;
+			break;
+		default:
+			std::cout << "Packet invalide." << std::endl;
+			break;
+		}
+	}
+	return 0;
+}
+
+uint64_t Connector::getId() const { return m_loginfo.sid; }
+
+unsigned int Connector::getSeed() const { return m_gameinfo.seed; }

SQCSim2021/connector.h

@@ -0,0 +1,36 @@
+#ifndef CONNECTOR_H__
+#define CONNECTOR_H__
+
+#include <stdlib.h>
+#include "../SQCSim-common/netprotocol.h"
+#include "define.h"
+
+class Connector {
+public:
+	Connector();
+	~Connector();
+
+	int Init();
+	int Connect(char* srv_addr, std::string name);
+	uint64_t getId() const;
+	unsigned int getSeed() const;
+
+	//void SendInput();
+	//int Sync();
+private:
+#ifdef _WIN32
+	WSADATA m_wsaData;
+#endif
+	std::map<Timestamp, netprot::Input> m_inputmanifest;
+	std::map<uint64_t, netprot::PlayerInfo> m_players;
+	std::map<uint64_t, netprot::TeamInfo> m_teams;
+
+	netprot::LoginInfo m_loginfo;
+	netprot::GameInfo m_gameinfo;
+
+	sockaddr_in m_srvsockaddr;
+	SOCKET m_sock_udp = 0,
+		   m_sock_tcp = 0;
+
+};
+#endif

SQCSim2021/define.h

@@ -1,44 +1,29 @@
-#ifndef DEFINE_H__
+#ifndef CLI_DEFINE_H__
-#define DEFINE_H__
+#define CLI_DEFINE_H__
 
+#include <iostream>
+#include <chrono>
+#include <iomanip>
+#include <GL/glew.h>
 #include <SFML/Window.hpp>
 #include <SFML/Graphics.hpp>
-#include <iostream>
+#include "../SQCSim-common/define.h"
-#include <iomanip>
 
 #ifdef _WIN32
-#include <windows.h>
-#include <GL/glew.h>
 #include <gl/GL.h>
 #include <gl/GLU.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <climits>
 #endif
 
-#define CHUNK_SIZE_X  4
+#define NETWORK_TEST false
-#define CHUNK_SIZE_Y  64
+#define SRV_ADDR "127.0.0.1"
-#define CHUNK_SIZE_Z  4
+#define COUNTDOWN 300
-#define MAX_SELECTION_DISTANCE 5
+
 #define BASE_WIDTH 640
 #define BASE_HEIGHT 480
-#define SEED 12345
-
-#define WORLD_SIZE_X 64
-#define WORLD_SIZE_Y 64
-
-#define FRAMES_RENDER_CHUNKS 1
-#define FRAMES_UPDATE_CHUNKS 1
-#define FRAMES_DELETE_CHUNKS 1
-
-#define THREADS_GENERATE_CHUNKS 8
-#define THREADS_UPDATE_CHUNKS 3
-#define THREADS_DELETE_CHUNKS 3
-
-#define VIEW_DISTANCE 512
-#define TEXTURE_SIZE 512
-#define MAX_BULLETS 512
-
-
-typedef uint8_t BlockType;
-enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_LAST };
 
 #define TEXTURE_PATH        "./media/textures/"
 #define SHADER_PATH		    "./media/shaders/"

SQCSim2021/docs/analyse_serveur.md

@@ -0,0 +1 @@
+

SQCSim2021/engine.cpp

@@ -1,8 +1,4 @@
 #include "engine.h"
-#include <algorithm>
-#include <cmath>
-#include "transformation.h"
-#include "player.h"
 
 Engine::Engine() {}
 
@@ -21,11 +17,11 @@ void Engine::Init() {
 		abort();
 	}
 
-	//glDisable(GL_FRAMEBUFFER_SRGB);
+	glDisable(GL_FRAMEBUFFER_SRGB);
-	//glEnable(GL_DEPTH_TEST);
+	glEnable(GL_DEPTH_TEST);
-	//glEnable(GL_STENCIL_TEST);
+	glEnable(GL_STENCIL_TEST);
-	//glEnable(GL_POINT_SMOOTH);
+	glEnable(GL_POINT_SMOOTH);
-	//glEnable(GL_BLEND);
+	glEnable(GL_BLEND);
 	glEnable(GL_CULL_FACE);
 	glEnable(GL_TEXTURE_2D);
 
@@ -35,21 +31,38 @@ void Engine::Init() {
 	gluPerspective(45.0f, (float)Width() / (float)Height(), 0.1f, VIEW_DISTANCE);
 	glShadeModel(GL_SMOOTH);
 
-	//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-	//glDisable(GL_BLEND);
+	glDisable(GL_BLEND);
-	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	//glBlendEquation(GL_FUNC_SUBTRACT);
+	glBlendEquation(GL_FUNC_SUBTRACT);
 	// 
 	// Objet de skybox avec sa propre texture et son propre shader!
 	m_skybox.Init(0.2f);
 
 	// Objet de musique!
-	m_audio.ToggleMusicState();
+	//m_audio.ToggleMusicState();
 
 	// Array pour les balles.
 	for (int x = 0; x < MAX_BULLETS; ++x)
 		m_bullets[x] = nullptr;
 
+	uint64_t seed = SEED;
+	std::string playname = "La Chienne <20> Jacques";
+	if (NETWORK_TEST) { // Test connexion r<>seau.
+		if (!m_conn.Init()) {
+			if (!m_conn.Connect(SRV_ADDR, playname)) {
+				// setup jeu en r<>seau.
+				std::cout << "ID re<72>u du serveur: " << std::to_string(m_conn.getId()) << "!" << std::endl;
+				std::cout << "Seed re<72>u du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl;
+				seed = m_conn.getSeed();
+			}
+			else std::cout << "Erreur de connexion." << std::endl;
+		}
+		else std::cout << "Erreur de cr<63>ation de socket." << std::endl;
+	}
+
+	m_world.SetSeed(seed);
+
 	// Init Chunks
 	m_world.GetChunks().Reset(nullptr);
 
@@ -192,7 +205,6 @@ void Engine::DisplayHud(int timer) {
 	ss << "Time: " << (int)(timer / 60) << ":" << std::setw(2) << std::setfill('0') << timer % 60;
 	PrintText(Width() - Width() * 0.15, Height() - (Height() / 19.2), scale, ss.str());
 	
-
 }
 
 void Engine::DisplayInfo(float elapsedTime, BlockType bloc) {
@@ -318,6 +330,7 @@ int Engine::GetCountdown(float elapsedTime) {
 
 void Engine::Render(float elapsedTime) {
 	//static float gameTime = elapsedTime;
+	static irrklang::ISound* step; // Pour les sons de pas.
 	static float pollTime = 0;
 	static float bulletTime = 0;
 	static BlockType bloc = 1;
@@ -329,6 +342,7 @@ void Engine::Render(float elapsedTime) {
 
 	Transformation all;
 	Transformation skybox;
+	Vector3f vstep;
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
 	// Transformations initiales
@@ -338,8 +352,22 @@ void Engine::Render(float elapsedTime) {
 	if (bulletTime > 0.f) bulletTime -= elapsedTime;
 	if (bulletTime < 0.f) bulletTime = 0.f;
 
+	static bool leftright = false;
 	if (pollTime >= .005f) {
-		m_player.ApplyPhysics(m_player.GetInput(m_keyW, m_keyS, m_keyA, m_keyD, m_keySpace, (bloc == BTYPE_LAST && bulletTime <= 0.f && m_mouseL), elapsedTime), &m_world, elapsedTime, &m_audio);
+		Player::Sound snd = m_player.ApplyPhysics(m_player.GetInput(m_keyW, m_keyS, m_keyA, m_keyD, m_keySpace, (bloc == BTYPE_LAST && bulletTime <= 0.f && m_mouseL), elapsedTime), &m_world, elapsedTime);
+		switch (snd) {
+		case Player::Sound::STEP:
+			if (leftright)
+				vstep = Vector3f(m_player.GetPosition().x + m_player.GetDirection().z, m_player.GetPosition().y - 1.7f, m_player.GetPosition().z + m_player.GetDirection().x);
+			else vstep = Vector3f(m_player.GetPosition().x - m_player.GetDirection().z, m_player.GetPosition().y - 1.7f, m_player.GetPosition().z - m_player.GetDirection().x);
+			m_audio.Create3DAudioObj(step, AUDIO_PATH "step.wav", vstep, m_player.GetVelocity(), .8f);
+			leftright = !leftright;
+			break;
+		case Player::Sound::FALL:
+			m_audio.Create3DAudioObj(step, AUDIO_PATH "hit.wav", m_player.GetPosition(), m_player.GetVelocity(), 1.f);
+			break;
+		default: break;
+		}
 		m_audio.Update3DAudio(m_player.GetPOV(), m_player.GetDirection(), m_player.GetVelocity()); // Ajustement du positionnement 3D avec les coordonn<6E>es du joueur et
 		// son vecteur de v<>locit<69> (pour l'effet Doppler)
 		pollTime = 0;
@@ -358,16 +386,16 @@ void Engine::Render(float elapsedTime) {
 
 	if (m_mouseL) {
 		if (bloc != BTYPE_LAST)
-			m_world.ChangeBlockAtCursor(bloc, m_player, m_block);
+			m_world.ChangeBlockAtCursor(bloc, m_player.GetPosition(), m_player.GetDirection(), m_block);
 		else if (bulletTime <= 0.f) {
 			for (int x = 0; x < MAX_BULLETS; ++x)  // Ajouter une balle dans l'array (aussi connu sous le nom de "faire pow pow").
 				if (!m_bullets[x]) {
-					m_bullets[x] = new Bullet(m_player);
+					m_bullets[x] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection());
 					break;
 				}
 				else if (x == MAX_BULLETS - 1) { // S'il y a pas d'espace dans l'array, prendre la place de la premi<6D>re balle de l'array.
 					m_bullets[0]->~Bullet();
-					m_bullets[0] = new Bullet(m_player);
+					m_bullets[0] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection());
 				}
 			bulletTime = .1f;
 			m_audio.Create3DAudioObj(m_powpow, AUDIO_PATH "windowsaccount.wav", m_player.GetPOV(), m_player.GetDirection() * 10, .5f);
@@ -380,16 +408,18 @@ void Engine::Render(float elapsedTime) {
 		}
 	}
 	else if (m_mouseR)
-		m_world.ChangeBlockAtCursor(BTYPE_AIR, m_player, m_block);
+		m_world.ChangeBlockAtCursor(BTYPE_AIR, m_player.GetPosition(), m_player.GetDirection(), m_block);
 
 	for (int x = 0; x < MAX_BULLETS; ++x) // Array de bullets en jeu.
 		if (m_bullets[x])
-			if (m_bullets[x]->Update(&m_world, all, elapsedTime)) {
+			if (m_bullets[x]->Update(&m_world, elapsedTime)) {
 				m_bullets[x]->~Bullet();
 				m_bullets[x] = nullptr;
 			}
 
-	m_world.Update(m_renderCount, m_bullets, m_player, all, m_shader01, m_textureAtlas, m_blockinfo);
+	m_wrenderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas);
+	m_world.Update(m_bullets, m_player.GetPosition(), m_blockinfo);
+	m_wrenderer.UpdateWorld(&m_world, m_player.GetPosition(), m_blockinfo);
 
 	if (m_isSkybox) m_skybox.Render(skybox);
 

SQCSim2021/engine.h

@@ -1,20 +1,24 @@
 #ifndef ENGINE_H__
 #define ENGINE_H__
 
+#include <algorithm>
+#include <cmath>
+#include "../SQCSim-common/array2d.h"
+#include "../SQCSim-common/blockinfo.h"
+#include "../SQCSim-common/bullet.h"
+#include "../SQCSim-common/chunk.h"
+#include "../SQCSim-common/world.h"
+#include "../SQCSim-common/transformation.h"
+#include "../SQCSim-common/player.h"
 #include "define.h"
 #include "openglcontext.h"
 #include "texture.h"
-#include "transformation.h"
 #include "shader.h"
-#include "player.h"
-#include "chunk.h"
 #include "skybox.h"
 #include "audio.h"
 #include "textureatlas.h"
-#include "blockinfo.h"
+#include "connector.h"
-#include "array2d.h"
+#include "worldrenderer.h"
-#include "world.h"
-#include "bullet.h"
 
 class Engine : public OpenglContext {
 public:
@@ -46,11 +50,13 @@ private:
     void DrawHud(float elapsedTime, BlockType bloc);
     void PrintText(float x, float y, float scale, const std::string& t);
 
+    Connector m_conn;
     Shader m_shader01;
     BlockInfo* m_blockinfo[BTYPE_LAST];
     TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
 
     World m_world = World();
+    WorldRenderer m_wrenderer = WorldRenderer();
 
     Texture m_textureSkybox;
     Texture m_textureFont;

SQCSim2021/matrix4.h

@@ -1,571 +0,0 @@
-#ifndef MATRIX4_H__
-#define MATRIX4_H__
-
-#include <ostream>
-#include <sstream>
-#include <string>
-
-#include "define.h"
-#include "vector3.h"
-
-#ifndef M_PI
-#define M_PI 3.14159265f
-#endif
-
-#define DEGTORAD(x) ((x * M_PI) / 180.f)
-#define RADTODEG(x) ((180.f * x) / M_PI)
-
-template <class T>
-class Matrix4
-{
-    public:
-        typedef T Type;
-
-    public:
-        static const Matrix4<T> ZERO;
-        static const Matrix4<T> IDENTITY;
-
-    public:
-        Matrix4();
-        Matrix4(const T& v);
-        Matrix4(const Matrix4<T>& m);
-        Matrix4(const T& m_11, const T& m_12, const T& m_13, const T& m_14,
-                const T& m_21, const T& m_22, const T& m_23, const T& m_24,
-                const T& m_31, const T& m_32, const T& m_33, const T& m_34,
-                const T& m_41, const T& m_42, const T& m_43, const T& m_44);
-
-        const T& Get11() const;
-        const T& Get12() const;
-        const T& Get13() const;
-        const T& Get14() const;
-        const T& Get21() const;
-        const T& Get22() const;
-        const T& Get23() const;
-        const T& Get24() const;
-        const T& Get31() const;
-        const T& Get32() const;
-        const T& Get33() const;
-        const T& Get34() const;
-        const T& Get41() const;
-        const T& Get42() const;
-        const T& Get43() const;
-        const T& Get44() const;
-
-        Matrix4<T>& operator=(const Matrix4<T>& m);
-
-        Matrix4<T> operator+(const Matrix4<T>& m) const;
-        const Matrix4<T>& operator+=(const Matrix4<T>& m);
-
-        Matrix4<T> operator-(const Matrix4<T>& m) const;
-        Matrix4<T> operator-() const;
-        const Matrix4<T>& operator-=(const Matrix4<T>& m);
-
-        Matrix4<T> operator*(const Matrix4<T>& m) const;
-        Matrix4<T> operator*(const T& v) const;
-        const Matrix4<T>& operator*=(const Matrix4<T>& m);
-        const Matrix4<T>& operator*=(const T& v);
-
-        Matrix4<T> operator/(const T& v) const;
-        const Matrix4<T>& operator/=(const T& v);
-
-        bool operator==(const Matrix4<T>& m) const;
-        bool operator!=(const Matrix4<T>& m) const;
-
-        void SetZero();
-        void SetIdentity();
-        void SetPerspectiveProjection(const T& fov, const T& aspect, const T& nearPlane, const T& farPlane);
-        void SetOrthographicProjection(const T& left, const T& right, const T& bottom, const T& top, const T& nearPlane, const T& farPlane);
-
-        void SetLookAt(const Vector3<T>& eyePosition, const Vector3<T>& lookAtPosition, Vector3<T> upVector = Vector3<T>(T(0), T(1), T(0)));
-
-        bool IsZero() const;
-        bool IsIdentity() const;
-
-        void ApplyTranslation(const T& x, const T& y, const T& z);
-        void ApplyRotation(const T& angle, const T& x, const T& y, const T& z);
-        void ApplyScale(const T& x, const T& y, const T& z);
-
-        Vector3<T> GetTranslation() const;
-
-        const T* GetInternalValues() const;
-        T* GetInternalValues();
-        std::string ToString(const std::string& lineBegin = "|", const std::string& lineEnd = "|\n") const;
-
-    private:
-        union {
-            // column-major matrix
-            struct
-            {
-                T m_11, m_21, m_31, m_41, m_12, m_22, m_32, m_42, m_13, m_23, m_33, m_43, m_14, m_24, m_34, m_44;
-            };
-            T m_values[16];
-        };
-};
-
-typedef Matrix4<int> Matrix4i;
-typedef Matrix4<float> Matrix4f;
-typedef Matrix4<double> Matrix4d;
-
-template <class T>
-const Matrix4<T> Matrix4<T>::ZERO = Matrix4<T>(0);
-
-template <class T>
-const Matrix4<T> Matrix4<T>::IDENTITY = Matrix4<T>(
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 1, 0,
-        0, 0, 0, 1);
-
-    template <class T>
-std::ostream& operator<<(std::ostream& out, const Matrix4<T>& m)
-{
-    out << m.ToString();
-    return out;
-}
-
-    template <class T>
-Matrix4<T>::Matrix4()
-{
-    // Leave matrix uninitialized
-}
-
-    template <class T>
-Matrix4<T>::Matrix4(const T& v)
-{
-    for(int i = 0; i < 16; ++i)
-        m_values[i] = v;
-}
-
-    template <class T>
-Matrix4<T>::Matrix4(const Matrix4<T>& m)
-{
-    for(int i = 0; i < 16; ++i)
-        m_values[i] = m.m_values[i];
-}
-
-    template <class T>
-Matrix4<T>::Matrix4(const T& m_11, const T& m_12, const T& m_13, const T& m_14,
-        const T& m_21, const T& m_22, const T& m_23, const T& m_24,
-        const T& m_31, const T& m_32, const T& m_33, const T& m_34,
-        const T& m_41, const T& m_42, const T& m_43, const T& m_44)
-{
-    this->m_11 = m_11;
-    this->m_12 = m_12;
-    this->m_13 = m_13;
-    this->m_14 = m_14;
-    this->m_21 = m_21;
-    this->m_22 = m_22;
-    this->m_23 = m_23;
-    this->m_24 = m_24;
-    this->m_31 = m_31;
-    this->m_32 = m_32;
-    this->m_33 = m_33;
-    this->m_34 = m_34;
-    this->m_41 = m_41;
-    this->m_42 = m_42;
-    this->m_43 = m_43;
-    this->m_44 = m_44;
-}
-
-template <class T>
-const T& Matrix4<T>::Get11() const
-{
-    return m_11;
-}
-
-template <class T>
-const T& Matrix4<T>::Get12() const
-{
-    return m_12;
-}
-
-template <class T>
-const T& Matrix4<T>::Get13() const
-{
-    return m_13;
-}
-
-template <class T>
-const T& Matrix4<T>::Get14() const
-{
-    return m_14;
-}
-
-template <class T>
-const T& Matrix4<T>::Get21() const
-{
-    return m_21;
-}
-
-template <class T>
-const T& Matrix4<T>::Get22() const
-{
-    return m_22;
-}
-
-template <class T>
-const T& Matrix4<T>::Get23() const
-{
-    return m_23;
-}
-
-template <class T>
-const T& Matrix4<T>::Get24() const
-{
-    return m_24;
-}
-
-template <class T>
-const T& Matrix4<T>::Get31() const
-{
-    return m_31;
-}
-
-template <class T>
-const T& Matrix4<T>::Get32() const
-{
-    return m_32;
-}
-
-template <class T>
-const T& Matrix4<T>::Get33() const
-{
-    return m_33;
-}
-
-template <class T>
-const T& Matrix4<T>::Get34() const
-{
-    return m_34;
-}
-
-template <class T>
-const T& Matrix4<T>::Get41() const
-{
-    return m_41;
-}
-
-template <class T>
-const T& Matrix4<T>::Get42() const
-{
-    return m_42;
-}
-
-template <class T>
-const T& Matrix4<T>::Get43() const
-{
-    return m_43;
-}
-
-template <class T>
-const T& Matrix4<T>::Get44() const
-{
-    return m_44;
-}
-
-    template <class T>
-Matrix4<T>& Matrix4<T>::operator=(const Matrix4<T>& m)
-{
-    if(this != &m)
-    {
-        for(int i = 0; i < 16; ++i)
-            m_values[i] = m.m_values[i];
-    }
-
-    return *this;
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator+(const Matrix4<T>& m) const
-{
-    return Matrix4<T>(
-            m_11 + m.m_11, m_12 + m.m_12, m_13 + m.m_13, m_14 + m.m_14,
-            m_21 + m.m_21, m_22 + m.m_22, m_23 + m.m_23, m_24 + m.m_24,
-            m_31 + m.m_31, m_32 + m.m_32, m_33 + m.m_33, m_34 + m.m_34,
-            m_41 + m.m_41, m_42 + m.m_42, m_43 + m.m_43, m_44 + m.m_44);
-}
-
-    template <class T>
-const Matrix4<T>& Matrix4<T>::operator+=(const Matrix4<T>& m)
-{
-    *this = *this + m;
-    return *this;
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator-(const Matrix4<T>& m) const
-{
-    return Matrix4<T>(
-            m_11 - m.m_11, m_12 - m.m_12, m_13 - m.m_13, m_14 - m.m_14,
-            m_21 - m.m_21, m_22 - m.m_22, m_23 - m.m_23, m_24 - m.m_24,
-            m_31 - m.m_31, m_32 - m.m_32, m_33 - m.m_33, m_34 - m.m_34,
-            m_41 - m.m_41, m_42 - m.m_42, m_43 - m.m_43, m_44 - m.m_44);
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator-() const
-{
-    return Matrix4<T>(
-            -m_11, -m_12, -m_13, -m_14,
-            -m_21, -m_22, -m_23, -m_24,
-            -m_31, -m_32, -m_33, -m_34,
-            -m_41, -m_42, -m_43, -m_44);
-}
-
-    template <class T>
-const Matrix4<T>& Matrix4<T>::operator-=(const Matrix4<T>& m)
-{
-    *this = *this - m;
-    return *this;
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator*(const Matrix4<T>& m) const
-{
-    return Matrix4<T>(
-            m_11 * m.m_11 + m_12 * m.m_21 + m_13 * m.m_31 + m_14 * m.m_41,
-            m_11 * m.m_12 + m_12 * m.m_22 + m_13 * m.m_32 + m_14 * m.m_42,
-            m_11 * m.m_13 + m_12 * m.m_23 + m_13 * m.m_33 + m_14 * m.m_43,
-            m_11 * m.m_14 + m_12 * m.m_24 + m_13 * m.m_34 + m_14 * m.m_44,
-
-            m_21 * m.m_11 + m_22 * m.m_21 + m_23 * m.m_31 + m_24 * m.m_41,
-            m_21 * m.m_12 + m_22 * m.m_22 + m_23 * m.m_32 + m_24 * m.m_42,
-            m_21 * m.m_13 + m_22 * m.m_23 + m_23 * m.m_33 + m_24 * m.m_43,
-            m_21 * m.m_14 + m_22 * m.m_24 + m_23 * m.m_34 + m_24 * m.m_44,
-
-            m_31 * m.m_11 + m_32 * m.m_21 + m_33 * m.m_31 + m_34 * m.m_41,
-            m_31 * m.m_12 + m_32 * m.m_22 + m_33 * m.m_32 + m_34 * m.m_42,
-            m_31 * m.m_13 + m_32 * m.m_23 + m_33 * m.m_33 + m_34 * m.m_43,
-            m_31 * m.m_14 + m_32 * m.m_24 + m_33 * m.m_34 + m_34 * m.m_44,
-
-            m_41 * m.m_11 + m_42 * m.m_21 + m_43 * m.m_31 + m_44 * m.m_41,
-            m_41 * m.m_12 + m_42 * m.m_22 + m_43 * m.m_32 + m_44 * m.m_42,
-            m_41 * m.m_13 + m_42 * m.m_23 + m_43 * m.m_33 + m_44 * m.m_43,
-            m_41 * m.m_14 + m_42 * m.m_24 + m_43 * m.m_34 + m_44 * m.m_44);
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator*(const T& v) const
-{
-    return Matrix4<T>(
-            m_11 * v, m_12 * v, m_13 * v, m_14 * v,
-            m_21 * v, m_22 * v, m_23 * v, m_24 * v,
-            m_31 * v, m_32 * v, m_33 * v, m_34 * v,
-            m_41 * v, m_42 * v, m_43 * v, m_44 * v);
-}
-
-    template <class T>
-const Matrix4<T>& Matrix4<T>::operator*=(const Matrix4<T>& m)
-{
-    *this = *this * m;
-    return *this;
-}
-
-    template <class T>
-const Matrix4<T>& Matrix4<T>::operator*=(const T& v)
-{
-    *this = *this * v;
-    return *this;
-}
-
-template <class T>
-Matrix4<T> Matrix4<T>::operator/(const T& v) const
-{
-    return Matrix4<T>(
-            m_11 / v, m_12 / v, m_13 / v, m_14 / v,
-            m_21 / v, m_22 / v, m_23 / v, m_24 / v,
-            m_31 / v, m_32 / v, m_33 / v, m_34 / v,
-            m_41 / v, m_42 / v, m_43 / v, m_44 / v);
-}
-
-    template <class T>
-const Matrix4<T>& Matrix4<T>::operator/=(const T& v)
-{
-    *this = *this / v;
-    return *this;
-}
-
-template <class T>
-bool Matrix4<T>::operator==(const Matrix4<T>& m) const
-{
-    for(int i = 0; i < 16; ++i)
-        if(m_values[i] != m.m_values[i])
-            return false;
-
-    return true;
-}
-
-template <class T>
-bool Matrix4<T>::operator!=(const Matrix4<T>& m) const
-{
-    return !(*this == m);
-}
-
-    template <class T>
-void Matrix4<T>::SetZero()
-{
-    *this = ZERO;
-}
-
-    template <class T>
-void Matrix4<T>::SetIdentity()
-{
-    *this = IDENTITY;
-}
-
-    template <class T>
-void Matrix4<T>::SetPerspectiveProjection(const T& fov, const T& aspect, const T& nearPlane, const T& farPlane)
-{
-    const float h = T(1) / tan(fov * T(M_PI / 360.f));
-    T negDepth = nearPlane - farPlane;
-
-    SetZero();
-
-    m_11 = h / aspect;
-    m_22 = h;
-    m_33 = (farPlane + nearPlane) / negDepth;
-    m_34 = T(2) * (nearPlane * farPlane) / negDepth;
-    m_43 = -T(1);
-}
-
-    template <class T>
-void Matrix4<T>::SetOrthographicProjection(const T& left, const T& right, const T& bottom, const T& top, const T& nearPlane, const T& farPlane)
-{
-    m_11 = T(2) / (right - left);
-    m_12 = T(0);
-    m_13 = T(0);
-    m_14 = -(right + left) / (right - left);
-
-    m_21 = T(0);
-    m_22 = T(2) / (top - bottom);
-    m_23 = T(0);
-    m_24 = -(top + bottom) / (top - bottom);
-
-    m_31 = T(0);
-    m_32 = T(0);
-    m_33 = -T(2) / (farPlane - nearPlane);
-    m_34 = -(farPlane + nearPlane) / (farPlane - nearPlane);
-
-    m_41 = T(0);
-    m_42 = T(0);
-    m_43 = T(0);
-    m_44 = T(1);
-}
-
-    template <class T>
-void Matrix4<T>::SetLookAt(const Vector3<T>& eyePosition, const Vector3<T>& lookAtPosition, Vector3<T> upVector)
-{
-    Vector3f L = lookAtPosition - eyePosition;
-    L.Normalize();
-
-    upVector.Normalize();
-    Vector3f S = L.Cross(upVector);
-    S.Normalize();
-
-    Vector3f U = S.Cross(L);
-
-    Matrix4<T> M;
-    M.m_11 = S.x;
-    M.m_12 = S.y;
-    M.m_13 = S.z;
-    M.m_14 = 0;
-
-    M.m_21 = U.x;
-    M.m_22 = U.y;
-    M.m_23 = U.z;
-    M.m_24 = 0;
-
-    M.m_31 = -L.x;
-    M.m_32 = -L.y;
-    M.m_33 = -L.z;
-    M.m_34 = 0;
-
-    M.m_41 = 0;
-    M.m_42 = 0;
-    M.m_43 = 0;
-    M.m_44 = 1.f;
-
-    SetIdentity();
-    *this *= M;
-    ApplyTranslation(-eyePosition.x, -eyePosition.y, -eyePosition.z);
-}
-
-    template <class T>
-void Matrix4<T>::ApplyTranslation(const T& x, const T& y, const T& z)
-{
-    Matrix4<T> tmp(
-            1, 0, 0, x,
-            0, 1, 0, y,
-            0, 0, 1, z,
-            0, 0, 0, 1);
-
-    *this *= tmp;
-}
-
-    template <class T>
-void Matrix4<T>::ApplyRotation(const T& angle, const T& x, const T& y, const T& z)
-{
-    // TODO axis (x, y, z) must be normalized...
-
-    T s = sin(DEGTORAD(angle));
-    T c = cos(DEGTORAD(angle));
-    T ic = T(1) - c;
-
-    Matrix4<T> tmp(
-            x * x * ic + c, y * x * ic + (z * s), z * x * ic - (y * s), 0,
-            x * y * ic - (z * s), y * y * ic + c, z * y * ic + (x * s), 0,
-            x * z * ic + (y * s), y * z * ic - (x * s), z * z * ic + c, 0,
-            0, 0, 0, 1);
-
-    *this *= tmp;
-}
-
-    template <class T>
-void Matrix4<T>::ApplyScale(const T& x, const T& y, const T& z)
-{
-    Matrix4<T> tmp(
-            x, 0, 0, 0,
-            0, y, 0, 0,
-            0, 0, z, 0,
-            0, 0, 0, 1);
-
-    *this *= tmp;
-}
-
-template <class T>
-Vector3<T> Matrix4<T>::GetTranslation() const
-{
-    // NOTE: Works only if the matrix doesn't contains scale information (only rotation and translation)
-    // Reference: http://www.gamedev.net/topic/397751-how-to-get-camera-position/
-    T x = -(m_11 * m_14 + m_21 * m_24 + m_31 * m_34);
-    T y = -(m_12 * m_14 + m_22 * m_24 + m_32 * m_34);
-    T z = -(m_13 * m_14 + m_23 * m_24 + m_33 * m_34);
-
-    return Vector3<T>(x, y, z);
-}
-
-    template <class T>
-T* Matrix4<T>::GetInternalValues()
-{
-    return m_values;
-}
-
-template <class T>
-const T* Matrix4<T>::GetInternalValues() const
-{
-    return m_values;
-}
-
-template <class T>
-std::string Matrix4<T>::ToString(const std::string& lineBegin, const std::string& lineEnd) const
-{
-    std::ostringstream ss;
-    ss << lineBegin << m_11 << " " << m_12 << " " << m_13 << " " << m_14 << lineEnd;
-    ss << lineBegin << m_21 << " " << m_22 << " " << m_23 << " " << m_24 << lineEnd;
-    ss << lineBegin << m_31 << " " << m_32 << " " << m_33 << " " << m_34 << lineEnd;
-    ss << lineBegin << m_41 << " " << m_42 << " " << m_43 << " " << m_44 << lineEnd;
-
-    return ss.str();
-}
-
-#endif // MATRIX4_H__

SQCSim2021/media/shaders/shader01.frag

@@ -7,7 +7,7 @@ void main()
     texel = texture2D(tex,gl_TexCoord[0].st);
 
     texel *= light;
-   texel.a = 255;
+   texel.a = 255.;
     gl_FragColor = texel;
    
 }

SQCSim2021/mesh.cpp

@@ -0,0 +1,120 @@
+#include "mesh.h"
+
+Mesh::Mesh(Chunk* chunk): m_chunk(chunk) {}
+
+Mesh::~Mesh() {
+    FlushVBO();
+}
+
+void Mesh::FlushMeshToVBO() {
+    m_vertexBuffer.SetMeshData(m_vd, m_vcount);
+    m_vcount = 0;
+    delete[] m_vd;
+}
+
+void Mesh::FlushVBO() {
+    m_vertexBuffer.Flush();
+}
+
+void Mesh::Update(BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+    float u, v, s;
+    // Update mesh
+    if (m_chunk->IsDirty()) {
+        int maxVertexCount = (CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z) * (6 * 4);
+        m_vd = new VertexBuffer::VertexData[maxVertexCount];
+        m_vcount = 0;
+        for (int x = 0; x < CHUNK_SIZE_X; ++x) {
+            for (int z = 0; z < CHUNK_SIZE_Z; ++z) {
+                for (int y = 0; y < CHUNK_SIZE_Y; ++y) {
+                    if (m_vcount > USHRT_MAX)
+                        break;
+
+                    BlockType bt = m_chunk->GetBlock(x, y, z);
+
+                    if (bt != BTYPE_AIR) {
+                        blockinfo[bt]->GetTexture(u, v, s);
+                        AddBlockToMesh(m_vd, m_vcount, bt, x, y, z, u, v, s, world);
+                    }
+                }
+            }
+        }
+        if (m_vcount > USHRT_MAX) {
+            m_vcount = USHRT_MAX;
+            std::cout << "[ Chunk :: Update ] Chunk data truncaned , too much vertices to have a 16 bit index " << std::endl;
+        }
+    }
+    m_chunk->MakeClean();
+}
+
+void Mesh::AddBlockToMesh(VertexBuffer::VertexData* vd, int& count, BlockType bt,
+    int x, int y, int z, float u, float v, float s, World* world) {
+
+    unsigned int cex, cey, cpx, cpy;
+
+    m_chunk->GetPosition(cpx, cpy);
+
+    world->GetScope(cex, cey);
+
+    int cx = x + (cpx - cex) * CHUNK_SIZE_X, cy = z + (cpy - cey) * CHUNK_SIZE_Z;
+
+    if (y == CHUNK_SIZE_Y - 1 || m_chunk->GetBlock(x, y + 1, z) == BTYPE_AIR) {                      //  y
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, .8f, .8f, .8f, u, v);
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .8f, .8f, .8f, u, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .8f, .8f, .8f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, .8f, .8f, .8f, u + s, v);
+    }
+
+    if (y == 0 || m_chunk->GetBlock(x, y - 1, z) == BTYPE_AIR) {                                     // -y
+        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .2f, .2f, .2f, u, v);
+        vd[count++] = VertexBuffer::VertexData(x, y, z, .2f, .2f, .2f, u, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z, .2f, .2f, .2f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .2f, .2f, .2f, u + s, v);
+    }
+
+    if (world->BlockAt(cx + 1, y, cy) == BTYPE_AIR) {                      //  x
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z, .9f, .9f, .9f, u, v);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, .9f, .9f, .9f, u, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .9f, .9f, .9f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .9f, .9f, .9f, u + s, v);
+    }
+
+    if (world->BlockAt(cx - 1, y, cy) == BTYPE_AIR) {                                     // -x
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .5f, .5f, .5f, u, v + s);
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, .5f, .5f, .5f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x, y, z, .5f, .5f, .5f, u + s, v);
+        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .5f, .5f, .5f, u, v);
+    }
+
+    if (world->BlockAt(cx, y, cy + 1) == BTYPE_AIR) {                      //  z
+        vd[count++] = VertexBuffer::VertexData(x, y, z + 1.f, .4f, .4f, .4f, u, v);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z + 1.f, .4f, .4f, .4f, u + s, v);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z + 1.f, .4f, .4f, .4f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z + 1.f, .4f, .4f, .4f, u, v + s);
+    }
+
+    if (world->BlockAt(cx, y, cy - 1) == BTYPE_AIR) {                                     // -z
+        vd[count++] = VertexBuffer::VertexData(x, y + 1.f, z, 1.f, 1.f, 1.f, u, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y + 1.f, z, 1.f, 1.f, 1.f, u + s, v + s);
+        vd[count++] = VertexBuffer::VertexData(x + 1.f, y, z, 1.f, 1.f, 1.f, u + s, v);
+        vd[count++] = VertexBuffer::VertexData(x, y, z, 1.f, 1.f, 1.f, u, v);
+    }
+}
+
+void Mesh::Render() const { m_vertexBuffer.Render(); }
+
+bool Mesh::IsDirty() const { return m_chunk->IsDirty(); }
+
+bool Mesh::IsNew() {
+    bool bl = m_new;
+    if (m_new)
+        m_new = false;
+    return bl;
+}
+
+void Mesh::GetPosition(unsigned int& x, unsigned int& y, World* world) const {
+    unsigned int sx, sy;
+    world->GetScope(sx, sy);
+    m_chunk->GetPosition(x, y);
+    x -= sx;
+    y -= sy;
+}

SQCSim2021/mesh.h

@@ -0,0 +1,32 @@
+#ifndef MESH_H__
+#define MESH_H__
+
+#include "../SQCSim-common/chunk.h"
+#include "../SQCSim-common/world.h"
+#include "define.h"
+#include "vertexbuffer.h"
+
+class Mesh {
+private:
+    VertexBuffer m_vertexBuffer;
+    VertexBuffer::VertexData* m_vd = nullptr;
+    int m_vcount = 0;
+    bool m_new = true;
+    Chunk* m_chunk; // NE PAS D<>TRUIRE ICI.
+
+    void AddBlockToMesh(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s, World* world);
+
+public:
+    Mesh(Chunk* chunk);
+    ~Mesh();
+
+    void FlushMeshToVBO();
+    void FlushVBO();
+    void Update(BlockInfo* blockinfo[BTYPE_LAST], World* world);
+    void Render() const;
+
+    bool IsDirty() const;
+    bool IsNew();
+    void GetPosition(unsigned int& x, unsigned int& y, World* world) const;
+};
+#endif

SQCSim2021/openglcontext.h

@@ -1,10 +1,9 @@
 #ifndef OPENGLCONTEXT_H__
 #define OPENGLCONTEXT_H__
 
-#include "define.h"
-
 #include <string>
 #include <SFML/Window.hpp>
+#include "define.h"
 
 // Documentation de SFML: http://www.sfml-dev.org/documentation/index-fr.php
 class OpenglContext

SQCSim2021/opensimplex.h

@@ -1,51 +0,0 @@
-/**
-  Open Simple Noise for C++
-
-  Port to C++ from https://gist.github.com/KdotJPG/b1270127455a94ac5d19
-  by Rickard Lundberg, 2019.
-*/
-#ifndef _OPENSIMPLEX_H__
-#define _OPENSIMPLEX_H__
-
-#include <cstdint>
-#include <array>
-
-namespace OpenSimplexNoise
-{
-  class Noise
-  {
-  public:
-    Noise();
-    Noise(int64_t seed);
-    //2D Open Simplex Noise.
-    double eval(const double x, const double y) const;
-    //3D Open Simplex Noise.
-    double eval(double x, double y, double z) const;
-    //4D Open Simplex Noise.
-    double eval(double x, double y, double z, double w) const;
-  private:
-    const double m_stretch2d;
-    const double m_squish2d;
-    const double m_stretch3d;
-    const double m_squish3d;
-    const double m_stretch4d;
-    const double m_squish4d;
-
-    const double m_norm2d;
-    const double m_norm3d;
-    const double m_norm4d;
-
-    const long m_defaultSeed;
-
-    std::array<short, 256> m_perm;
-    std::array<short, 256> m_permGradIndex3d;
-    std::array<char, 16> m_gradients2d;
-    std::array<char, 72> m_gradients3d;
-    std::array<char, 256> m_gradients4d;
-    double extrapolate(int xsb, int ysb, double dx, double dy) const;
-    double extrapolate(int xsb, int ysb, int zsb, double dx, double dy, double dz) const;
-    double extrapolate(int xsb, int ysb, int zsb, int wsb, double dx, double dy, double dz, double dw) const;
-  };
-}
-
-#endif // _OPENSIMPLEX_H__

SQCSim2021/player.cpp

@@ -1,209 +0,0 @@
-#include "player.h"
-#include "world.h"
-
-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 = 0.75f; //TODO: Remettre <20> 1.0f
-	m_username = "Zelda Bee-Bop";
-}
-
-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);
-
-	m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
-						   -sin(xrotrad),
-						   cos(xrotrad) * -cos(yrotrad));
-
-	m_direction.Normalize();
-
-	if (front) {
-		delta.x += float(sin(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
-	}
-	else if (back) {
-		delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
-	}
-
-	if (left) {
-		delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
-	}
-	else if (right) {
-		delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
-		delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
-	}
-
-	delta.Normalize();
-	delta.x *= .6f;
-	delta.z *= .6f;
-
-	if ((jump || shoot ) && !m_airborne) {
-		delta.y += jump? .32f: shoot? .1f : 0.f;
-		m_airborne = true;
-	}
-
-	if (shoot) // Recoil!
-		TurnTopBottom(-1);
-
-	return delta;
-}
-
-void Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime, Audio* audio) {
-	static irrklang::ISound* step; // Pour les sons de pas.
-	static float timing = 0.f;
-	/* Gestion de collisions */
-	BlockType bt1, bt2, bt3;
-
-	bt1 = world->BlockAt(GetPosition().x, GetPosition().y + input.y, GetPosition().z);
-	bt2 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 0.9f, GetPosition().z);
-	bt3 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 1.7f, GetPosition().z);
-	if ((bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) && m_position.y < 129.7f) {
-		bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
-		if (bt1 == BTYPE_AIR) m_position.y = (int)m_position.y + .7f;
-		m_velocity.y = input.y = 0;
-		m_airborne = false;
-	}
-	else {
-		if (abs(m_velocity.y) < 1.1f) m_velocity.y += input.y - 1.1f * elapsedTime;
-		bt3 = world->BlockAt(GetPosition().x, GetPosition().y + m_velocity.y - 1.7f, GetPosition().z);
-		bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
-		if (bt3 != BTYPE_AIR) {
-			m_velocity.y = 0;
-			if (timing == 0.f) {
-				if (m_airborne) audio->Create3DAudioObj(step, AUDIO_PATH "hit.wav", GetPosition(), GetVelocity(), 1.f);
-				timing = .3f;
-			}
-			m_airborne = false;
-		}
-		else if (bt1 != BTYPE_AIR) {
-			m_velocity.y = -.1f;
-		}
-		else m_airborne = true;
-	}
-
-	if (timing > 0.f) timing -= elapsedTime;
-	if (timing < 0.f) timing = 0.f;
-
-	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 (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;
-	}
-
-	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 (input.z > 0)
-			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;
-	}
-
-	/* Fin gestion de collisions */
-	/* Gestion de la friction */
-
-	if (!m_airborne) {
-		m_velocity.x += input.x * 2.f * elapsedTime;
-		m_velocity.z += input.z * 2.f * elapsedTime;
-
-		if (input.x == 0.f) 
-			m_velocity.x *= .8f;
-		
-		if (input.z == 0.f) 
-			m_velocity.z *= .8f;
-	}
-	else {
-		m_velocity.x += input.x * .4f * elapsedTime; // Techniquement contre les lois de la physique, mais c'est beaucoup moins chiant pour grimper sur les blocs.
-		m_velocity.z += input.z * .4f * elapsedTime;
-		m_velocity.x *= .99f;
-		m_velocity.z *= .99f;
-	}
-
-	/* Fin gestion de la friction */
-
-	float vy = m_velocity.y;
-	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.
-	m_velocity.y = vy;
-
-	m_position += m_velocity;
-
-	static float bobbingtime = 0; // Gestion de la cam<61>ra
-	static bool leftright = false;
-	static bool isStep = false;
-	if (bobbingtime <= 360.f) 
-		bobbingtime += elapsedTime * 20.f; else bobbingtime = 0;
-	
-	if ((sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) < -.2f && !m_airborne) {
-		Vector3f vstep;
-		if (leftright)
-			vstep = Vector3f(GetPosition().x + GetDirection().z, GetPosition().y - 1.7f, GetPosition().z + GetDirection().x);
-		else vstep = Vector3f(GetPosition().x - GetDirection().z, GetPosition().y - 1.7f, GetPosition().z - GetDirection().x);
-		if (!isStep) {
-			audio->Create3DAudioObj(step, AUDIO_PATH "step.wav", vstep, GetVelocity(), .8f);
-			leftright = !leftright;
-		}
-		isStep = true;
-	}
-	else isStep = false;
-	m_POV = m_position.y;
-	m_POV += m_airborne ? 0 : (sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) * .2f;
-}
-
-void Player::ApplyTransformation(Transformation& transformation, bool rel) const {
-	transformation.ApplyRotation(-m_rotX, 1, 0, 0);
-	transformation.ApplyRotation(-m_rotY, 0, 1, 0);
-	if (rel) transformation.ApplyTranslation(-GetPOV());
-}
-
-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::GetVelocity() const { return m_velocity; }
-
-Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }
-
-Vector3f Player::GetDirection() const { return m_direction; }
-
-std::string Player::GetUsername() const { return m_username; }
-
-float Player::GetHP() const { return m_hp; }
-
-void Player::Teleport(int& x, int& z) {
-	m_position.x -= x * CHUNK_SIZE_X;
-	m_position.z -= z * CHUNK_SIZE_Z;
-}

SQCSim2021/player.h

@@ -1,43 +0,0 @@
-#ifndef _PLAYER_H__
-#define _PLAYER_H__
-#include "vector3.h"
-#include "transformation.h"
-#include "audio.h"
-#include <cmath>
-
-class World;
-
-class Player {
-public:
-	Player(const Vector3f& position, float rotX = 0, float rotY = 0);
-	void TurnLeftRight(float value);
-	void TurnTopBottom(float value);
-	Vector3f GetInput(bool front, bool back, bool left, bool right, bool jump, bool dash, float elapsedTime);
-	void ApplyPhysics(Vector3f input, World* world, float elapsedTime, Audio* audio);
-	void ApplyTransformation(Transformation& transformation, bool rel = true) const;
-
-	Vector3f GetPosition() const;
-	Vector3f GetDirection() const;
-	Vector3f GetVelocity() const;
-	Vector3f GetPOV() const;
-	std::string GetUsername() const;
-	float GetHP() const;
-	void Teleport(int& x, int& z);
-
-private:
-	Vector3f m_position;
-	Vector3f m_velocity;
-	Vector3f m_direction;
-
-	std::string m_username;
-
-	float m_rotX = 0; 
-	float m_rotY = 0;
-	float m_POV;
-
-	float m_hp;
-
-	bool m_airborne;
-};
-#endif //_PLAYER_H__
-

SQCSim2021/skybox.cpp

@@ -45,7 +45,7 @@ void Skybox::Init(float size){
 void Skybox::Render(Transformation tran) const {
 	glDisable(GL_DEPTH_TEST);
 	glDisable(GL_BLEND);
-	tran.Use();
+	glLoadMatrixf(tran.GetMatrix().GetInternalValues());
 	m_texture.Bind();
 	m_shader.Use();
 	m_vertexBuffer.Render(); 

SQCSim2021/skybox.h

@@ -1,10 +1,10 @@
 #ifndef SKYBOX_H__
 #define SKYBOX_H__
 
+#include "../SQCSim-common/transformation.h"
 #include "define.h"
 #include "vertexbuffer.h"
 #include "texture.h"
-#include "transformation.h"
 #include "shader.h"
 
 class Skybox {

SQCSim2021/texture.h

@@ -1,9 +1,9 @@
 #ifndef TEXTURE_H__
 #define TEXTURE_H__
 
-#include "define.h"
-#include <IL/il.h>
 #include <string>
+#include <IL/il.h>
+#include "define.h"
 
 class Texture
 {

SQCSim2021/textureatlas.h

@@ -1,9 +1,9 @@
 #ifndef TEXTUREATLAS_H__
 #define TEXTUREATLAS_H__
-#include "define.h"
 #include <string>
 #include <map>
 #include <IL/ilu.h>
+#include "define.h"
 
 class TextureAtlas
 {

SQCSim2021/vector3.h

@@ -1,219 +0,0 @@
-#ifndef VECTOR3_H__
-#define VECTOR3_H__
-
-#include <iostream>
-#include <cmath>
-
-template <class T>
-class Vector3
-{
-public:
-	Vector3();
-	Vector3(const T& x, const T& y, const T& z);
-	~Vector3();
-
-	T Length() const;
-	void Normalize();
-	void Zero();
-
-	T Dot(const Vector3<T>& v) const;
-	Vector3<T> Cross(const Vector3<T>& v) const;
-
-	Vector3<T> operator+(const Vector3<T>& v) const;
-	Vector3<T> operator-(const Vector3<T>& v) const;
-	Vector3<T> operator-() const;
-	Vector3<T> operator+(const T& v) const;
-	Vector3<T> operator-(const T& v) const;
-	Vector3<T> operator/(const T& v) const;
-	Vector3<T> operator*(const T& v) const;
-
-	Vector3<T>& operator=(const Vector3<T>& v);
-
-	Vector3<T>& operator+=(const Vector3<T>& v);
-	Vector3<T>& operator-=(const Vector3<T>& v);
-	Vector3<T>& operator+=(const T& v);
-	Vector3<T>& operator-=(const T& v);
-	Vector3<T>& operator/=(const T& v);
-	Vector3<T>& operator*=(const T& v);
-
-	bool operator==(const Vector3<T>& v) const;
-	bool operator!=(const Vector3<T>& v) const;
-
-	void Afficher() const;
-
-public:
-	T x, y, z;
-};
-
-typedef Vector3<int> Vector3i;
-typedef Vector3<float> Vector3f;
-
-template <class T>
-inline std::ostream& operator<<(std::ostream& out, const Vector3<T>& v)
-{
-	out << "[" << v.x << ", " << v.y << ", " << v.z << "]";
-    return out;
-}
-
-
-template <class T>
-Vector3<T>::Vector3()
-{
-}
-
-template <class T>
-Vector3<T>::Vector3(const T& x, const T& y, const T& z) : x(x), y(y), z(z)
-{
-}
-
-template <class T>
-Vector3<T>::~Vector3()
-{
-}
-
-template <class T>
-T Vector3<T>::Length() const
-{
-	return sqrt(x*x + y*y + z*z);
-}
-
-template <class T>
-void Vector3<T>::Normalize()
-{
-	T len = Length();
-	if (len != 0)
-	{
-		x /= len;
-		y /= len;
-		z /= len;
-	}
-}
-
-template <class T>
-void Vector3<T>::Zero()
-{
-	x = y = z = 0;
-}
-
-template <class T>
-T Vector3<T>::Dot(const Vector3<T>& v) const
-{
-	return (x * v.x) + (y * v.y) + (z * v.z);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::Cross(const Vector3<T>& v) const
-{
-	return Vector3<T>(
-		y * v.z - v.y * z,
-		z * v.x - v.z * x,
-		x * v.y - v.x * y);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator+(const Vector3<T>& v) const
-{
-	return Vector3<T>(x + v.x, y + v.y, z + v.z);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator-(const Vector3<T>& v) const
-{
-	return Vector3<T>(x - v.x, y - v.y, z - v.z);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator-() const
-{
-	return Vector3<T>(-x, -y, -z);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator+(const T& v) const
-{
-	return Vector3<T>(x + v, y + v, z + v);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator-(const T& v) const
-{
-	return Vector3<T>(x - v, y - v, z - v);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator/(const T& v) const
-{
-	return Vector3<T>(x / v, y / v, z / v);
-}
-
-template <class T>
-Vector3<T> Vector3<T>::operator*(const T& v) const
-{
-	return Vector3<T>(x * v, y * v, z * v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator=(const Vector3<T>& v)
-{
-	x = v.x;
-	y = v.y;
-	z = v.z;
-	return *this;
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator+=(const Vector3<T>& v)
-{
-	return (*this = *this + v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator-=(const Vector3<T>& v)
-{
-	return (*this = *this - v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator+=(const T& v)
-{
-	return (*this = *this + v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator-=(const T& v)
-{
-	return (*this = *this - v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator/=(const T& v)
-{
-	return (*this = *this / v);
-}
-
-template <class T>
-Vector3<T>& Vector3<T>::operator*=(const T& v)
-{
-	return (*this = *this * v);
-}
-
-template <class T>
-bool Vector3<T>::operator==(const Vector3<T>& v) const
-{
-	return (x == v.x && y == v.y && z == v.z);
-}
-
-template <class T>
-bool Vector3<T>::operator!=(const Vector3<T>& v) const
-{
-	return !(*this == v);
-}
-
-template <class T>
-void Vector3<T>::Afficher() const
-{
-	std::cout << "[" << x << ", " << y << ", " << z << "]" << std::endl;
-}
-
-
-#endif // VECTOR3_H__

SQCSim2021/vertexbuffer.h

@@ -1,8 +1,8 @@
 #ifndef VERTEXBUFFER_H__
 #define VERTEXBUFFER_H__
 
-#include "define.h"
 #include <mutex>
+#include "define.h"
 
 class VertexBuffer
 {

SQCSim2021/world.cpp

@@ -1,482 +0,0 @@
-#include "world.h"
-
-World::World() {}
-
-World::~World() {}
-
-Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
-
-Chunk* World::ChunkAt(float x, float y, float z) const {
-	int cx = (int)x / CHUNK_SIZE_X;
-	int cz = (int)z / CHUNK_SIZE_Z;
-
-	if (x < 0 || y < 0 || z < 0 ||
-		x >= WORLD_SIZE_X * CHUNK_SIZE_X ||
-		z >= CHUNK_SIZE_Z * WORLD_SIZE_Y ||
-		y > CHUNK_SIZE_Y)
-		return 0;
-
-	return m_chunks.Get(cx, cz);
-}
-
-Chunk* World::ChunkAt(const Vector3f& pos) const { return ChunkAt(pos.x, pos.y, pos.z); }
-
-BlockType World::BlockAt(float x, float y, float z, BlockType defaultBlockType) const {
-	Chunk* c = ChunkAt(x, y, z);
-
-	if (!c)
-		return defaultBlockType;
-
-	int bx = (int)x % CHUNK_SIZE_X;
-	int by = (int)y % CHUNK_SIZE_Y;
-	int bz = (int)z % CHUNK_SIZE_Z;
-
-	return c->GetBlock(bx, by, bz);
-}
-
-BlockType World::BlockAt(const Vector3f& pos, BlockType defaultBlockType) const {
-	return BlockAt(pos.x, pos.y, pos.z, defaultBlockType);
-}
-
-void World::TransposeWorld(Player& player, Bullet* bullets[MAX_BULLETS]) {
-	int x = 0, y = 0;
-
-	if (player.GetPosition().x > (WORLD_SIZE_X * CHUNK_SIZE_X) * .6f) ++x;
-	else if (player.GetPosition().x < (WORLD_SIZE_X * CHUNK_SIZE_X) * .4f) --x;
-	if (player.GetPosition().z > (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .6f) ++y;
-	else if (player.GetPosition().z < (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .4f) --y;
-
-	if (!x && !y) return;
-
-	if (x > 0) {
-		for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
-			for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
-				if (ax - x >= 0) {
-					m_chunks.Set(ax - x, ay,
-						m_chunks.Remove(ax, ay));
-					if (ax == WORLD_SIZE_X - 1 && m_chunks.Get(ax - x, ay))
-						m_chunks.Get(ax - x, ay)->MakeDirty();
-				}
-				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
-	}
-	else if (x < 0) {
-		for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
-			for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
-				if (ax - x < WORLD_SIZE_X) {
-					m_chunks.Set(ax - x, ay,
-						m_chunks.Remove(ax, ay));
-					if (ax == 0 && m_chunks.Get(ax - x, ay))
-						m_chunks.Get(ax - x, ay)->MakeDirty();
-				}
-				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
-	}
-
-	if (y > 0) {
-		for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
-			for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
-				if (ay - y >= 0) {
-					m_chunks.Set(ax, ay - y,
-						m_chunks.Remove(ax, ay));
-					if (ay == WORLD_SIZE_Y - 1 && m_chunks.Get(ax, ay - y))
-						m_chunks.Get(ax, ay - y)->MakeDirty();
-				}
-				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
-	}
-	else if (y < 0) {
-		for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
-			for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
-				if (ay - y < WORLD_SIZE_Y) {
-					m_chunks.Set(ax, ay - y,
-						m_chunks.Remove(ax, ay));
-					if (ay == 0 && m_chunks.Get(ax, ay - y))
-						m_chunks.Get(ax, ay - y)->MakeDirty();
-				}
-				else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
-	}
-
-	m_center[0] += x; m_center[1] += y;
-	player.Teleport(x, y);
-
-	for (int index = 0; index < MAX_BULLETS; ++index)
-		if (bullets[index]) bullets[index]->Transpose(x, y);
-}
-
-void World::CleanUpWorld(int& deleteframes, bool clear = false) {
-	if (clear) {
-		while (m_tbDeleted.size() > 0) {
-			delete m_tbDeleted.back();
-			m_tbDeleted.pop_back();
-		}
-	}
-	if (!m_tbDeleted.empty() && !deleteframes) {
-		int deleted = 0;
-		while (deleted < THREADS_DELETE_CHUNKS) {
-
-
-		}
-		delete m_tbDeleted.back();
-		m_tbDeleted.pop_back();
-		deleteframes = FRAMES_DELETE_CHUNKS;
-	}
-}
-
-void World::GetScope(unsigned int& x, unsigned int& y) {
-	x = m_center[0];
-	y = m_center[1];
-}
-
-void World::Update(int& rendercount, Bullet* bullets[MAX_BULLETS], Player& player, Transformation& world, Shader& shader, TextureAtlas& atlas, BlockInfo* blockinfo[BTYPE_LAST]) {
-	glStencilFunc(GL_EQUAL, 1, 0x00);
-	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-	atlas.Bind();
-	RenderWorld(rendercount, player, world, shader);
-	UpdateWorld(player, blockinfo);
-	//TransposeWorld(player, bullets);
-	shader.Disable();
-	glStencilFunc(GL_GREATER, 1, 0xFF);
-}
-
-void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
-	if (updates == 0 && ChunkAt(chx, 1, chy) &&
-		ChunkAt(chx, 1, chy)->IsDirty()) {
-		ChunkAt(chx, 1, chy)->Update(blockinfo, this);
-		updates = FRAMES_UPDATE_CHUNKS;
-	}
-
-}
-
-void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block) {
-	Vector3f currentPos = player.GetPosition();
-	Vector3f currentBlock = currentPos;
-	Vector3f ray = player.GetDirection();
-	bool found = false;
-
-	if (block) return;
-
-	while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
-		currentBlock += ray / 10.f;
-
-		BlockType bt = BlockAt(currentBlock);
-
-		if (bt != BTYPE_AIR)
-			found = true;
-	}
-
-	if (found)
-		if (blockType != BTYPE_AIR) {
-			found = false;
-			while ((currentPos - currentBlock).Length() >= 1.7f && !found) {
-				currentBlock -= ray / 10.f;
-
-				BlockType bt = BlockAt(currentBlock);
-
-				if (bt == BTYPE_AIR) { // V<>rification pour <20>tre s<>r que le bloc <20> changer n'est pas dans le joueur.
-					int Bx = (int)currentBlock.x;
-					int By = (int)currentBlock.y;
-					int Bz = (int)currentBlock.z;
-
-					int Px = (int)currentPos.x;
-					int PyA = (int)currentPos.y;
-					int PyB = (int)(currentPos.y - .9f);
-					int PyC = (int)(currentPos.y - 1.7f);
-					int Pz = (int)currentPos.z;
-
-					if (!(Bx == Px &&
-						(By == PyA ||
-							By == PyB ||
-							By == PyC) &&
-						Bz == Pz))
-						found = true;
-				}
-			}
-		}
-
-	if (found && (int)currentBlock.y < CHUNK_SIZE_Y) {
-		int bx = (int)currentBlock.x % CHUNK_SIZE_X;
-		int by = (int)currentBlock.y % CHUNK_SIZE_Y;
-		int bz = (int)currentBlock.z % CHUNK_SIZE_Z;
-
-		ChunkAt(currentBlock)->SetBlock(bx, by, bz, blockType, this);
-		ChunkAt(currentBlock)->MakeModified();
-		block = true;
-	}
-}
-
-void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
-	int bx = (int)pos.x % CHUNK_SIZE_X;
-	int by = (int)pos.y % CHUNK_SIZE_Y;
-	int bz = (int)pos.z % CHUNK_SIZE_Z;
-
-	ChunkAt(pos)->SetBlock(bx, by, bz, blockType, this);
-	ChunkAt(pos)->MakeModified();
-}
-
-void World::RenderWorld(int& rendercount, Player& player, Transformation& world, Shader& shader) {
-	shader.Use();
-	rendercount = 0;
-	Vector3f angle;
-	Vector3f cursor;
-	Vector3f direct = player.GetDirection();
-	Vector3f pos = player.GetPosition() - direct;
-
-	direct.y = 0;
-	direct.Normalize();
-	pos.y = 1;
-
-	static Vector3<unsigned int> renderManifest[VIEW_DISTANCE * 8]; // Nombre de Chunks maximal <20> <20>tre rendus.
-
-	//for (int dist = VIEW_DISTANCE; dist >= 0; dist -= CHUNK_SIZE_X) {
-	for (int dist = 0; dist <= VIEW_DISTANCE; dist += CHUNK_SIZE_X) {
-		// Configuration du radar.
-		float sinus, cosinus;
-		int echantillons;
-
-		if (dist > VIEW_DISTANCE * .1f) {
-			sinus = .00872653549f; // sin(1/2 degr<67>)
-			cosinus = .99996192306; // cos(1/2 degr<67>)
-			echantillons = 180;
-		}
-		//else if (dist > VIEW_DISTANCE * .3f) {
-		//	sinus = .01151891831f; // sin(2/3 degr<67>)
-		//	cosinus = .99993365506; // cos(2/3 degr<67>)
-		//	echantillons = 120;
-		//}
-		//else if (dist > VIEW_DISTANCE * .2f) {
-		//	sinus = .01745240643; // sin(1 degr<67>)
-		//	cosinus = .99984769515; // cos(1 degr<67>)
-		//	echantillons = 90;
-		//}
-		//else if (dist > VIEW_DISTANCE * .1f) {
-		//	sinus = .0261769483;
-		//	cosinus = .99965732497;
-		//	echantillons = 60;
-		//}
-		else {
-			sinus = .0348994967;
-			cosinus = .99939082701;
-			echantillons = 45;
-		}
-
-		angle.x = direct.z + direct.x;
-		angle.z = direct.z - direct.x;
-		angle.y = 0;
-		angle.Normalize();
-
-		for (int radar = 0; radar < echantillons; ++radar) {
-			float x = angle.x;
-
-			angle.x = angle.x * cosinus - angle.z * sinus;
-			angle.z = angle.z * cosinus + x * sinus;
-			angle.Normalize();
-
-			cursor = pos - direct * CHUNK_SIZE_X * 2 + angle * dist;
-			if (cursor.y >= 128.f || cursor.y >= 0.f) cursor.y = CHUNK_SIZE_Y / 2.f;
-
-
-			if (ChunkAt(cursor)) {
-				bool valide = true;
-				unsigned int chx, chy;
-				ChunkAt(cursor)->GetPosition(chx, chy);
-				for (int index = 0; index < rendercount; ++index) // Permet de v<>rifier seulement contre celles ajout<75>es dans la frame, et ne pas avoir <20> refaire l'array <20> chaque frame.
-					if (renderManifest[index].x == chx && renderManifest[index].z == chy)
-						valide = false;
-
-				if (valide) renderManifest[rendercount++] = Vector3<unsigned int>(chx, 
-					(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) < 0.f? 0: 
-					(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) * 1000, 
-					chy);
-			}
-		}
-	}
-	for (int index = 0; index < rendercount; ++index) {
-		int chx = (renderManifest[index].x - m_center[0]) * CHUNK_SIZE_X, chy = (renderManifest[index].z - m_center[1]) * CHUNK_SIZE_Z;
-
-		world.ApplyTranslation(chx, 0, chy);
-		world.Use();
-		float blcolor = renderManifest[index].y / (VIEW_DISTANCE / 50.f);
-		glBlendColor(blcolor, blcolor, blcolor, 1.f);
-		ChunkAt(chx, 1, chy)->Render();
-		world.ApplyTranslation(-chx, 0, -chy);
-	}
-	shader.Disable();
-};
-
-void World::UpdateWorld(Player& player, BlockInfo* blockinfo[BTYPE_LAST]) {
-	int cx = player.GetPosition().x;
-	int cy = player.GetPosition().z;
-	static int frameGenerate = 1;
-	static int frameUpdate = 2;
-	static int frameDelete = 3;
-	int side = 0;
-	int threads = 0;
-	std::future<Chunk*> genThList[THREADS_GENERATE_CHUNKS];
-	std::future<Chunk*> updateThList[THREADS_UPDATE_CHUNKS];
-	std::future<void> delThList[THREADS_DELETE_CHUNKS];
-
-	if (frameGenerate > 0) --frameGenerate;
-	if (frameUpdate > 0) --frameUpdate;
-	if (frameDelete > 0) --frameDelete;
-	
-	if (!frameGenerate)
-		while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2 + CHUNK_SIZE_X) {
-			int tx = -side, ty = -side;
-			int chx = 0;
-			int chy = 0;
-
-			for (; tx <= side; ++tx) {
-				if (frameGenerate)
-					break;
-				chx = cx + tx * CHUNK_SIZE_X;
-				chy = cy + ty * CHUNK_SIZE_Z;
-				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
-					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
-					genThList[threads++] = std::async(std::launch::async, [](unsigned int x, unsigned int y) { return new Chunk(x, y); }, chx / CHUNK_SIZE_X + m_center[0], chy / CHUNK_SIZE_Z + m_center[1]);
-				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
-			}
-			for (; ty <= side; ++ty) {
-				if (frameGenerate)
-					break;
-				chx = cx + tx * CHUNK_SIZE_X;
-				chy = cy + ty * CHUNK_SIZE_Z;
-				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
-					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
-					genThList[threads++] = std::async(std::launch::async, [](unsigned int x, unsigned int y) { return new Chunk(x, y); }, chx / CHUNK_SIZE_X + m_center[0], chy / CHUNK_SIZE_Z + m_center[1]);
-				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
-			}
-			for (; tx >= -side; --tx) {
-				if (frameGenerate)
-					break;
-				chx = cx + tx * CHUNK_SIZE_X;
-				chy = cy + ty * CHUNK_SIZE_Z;
-				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
-					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
-					genThList[threads++] = std::async(std::launch::async, [](unsigned int x, unsigned int y) { return new Chunk(x, y); }, chx / CHUNK_SIZE_X + m_center[0], chy / CHUNK_SIZE_Z + m_center[1]);
-				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
-			}
-			for (; ty >= -side; --ty) {
-				if (frameGenerate)
-					break;
-				chx = cx + tx * CHUNK_SIZE_X;
-				chy = cy + ty * CHUNK_SIZE_Z;
-				if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
-					chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
-					genThList[threads++] = std::async(std::launch::async, [](unsigned int x, unsigned int y) { return new Chunk(x, y); }, chx / CHUNK_SIZE_X + m_center[0], chy / CHUNK_SIZE_Z + m_center[1]);
-				if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
-			}
-			if (frameGenerate)
-				break;
-			++side;
-		}
-
-	if (threads > 0) {
-		for (int i = 0; i < threads; ++i)
-			genThList[i].wait();
-
-		for (int i = 0; i < threads; ++i) {
-			unsigned int x, y;
-			Chunk* chunk = genThList[i].get();
-			chunk->GetPosition(x, y);
-			m_chunks.Set(x - m_center[0], y - m_center[1], chunk);
-		}
-	}
-
-	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(); }

SQCSim2021/world.h

@@ -1,56 +0,0 @@
-#ifndef WORLD_H__
-#define WORLD_H__
-#include <fstream>
-#include <string>
-#include <vector>
-#include <future>
-#include <thread>
-#include "define.h"
-#include "chunk.h"
-#include "array2d.h"
-#include "vector3.h"
-#include "player.h"
-#include "transformation.h"
-#include "shader.h"
-#include "bullet.h"
-#include "textureatlas.h"
-
-class Chunk;
-class Player;
-class Bullet;
-
-class World {
-public:
-	World();
-	~World();
-
-	Array2d<Chunk*>& GetChunks();
-
-	Chunk* ChunkAt(float x, float y, float z) const;
-	Chunk* ChunkAt(const Vector3f& pos) const;
-
-	BlockType BlockAt(float x, float y, float z, BlockType defaultBlockType = BTYPE_AIR) const;
-	BlockType BlockAt(const Vector3f& pos, BlockType defaultBlockType = BTYPE_AIR) const;
-
-	void Update(int& rendercount, Bullet* bullets[MAX_BULLETS], Player& player, Transformation& world, Shader& shader, TextureAtlas& atlas, BlockInfo* blockinfo[BTYPE_LAST]);
-
-	void GetScope(unsigned int& x, unsigned int& y);
-
-	void ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block);
-	void ChangeBlockAtPosition(BlockType blockType, Vector3f pos);
-	void CleanUpWorld(int& deleteframes, bool clear);
-	int GettbDeleted() const;
-private:
-	Array2d<Chunk*> m_chunks = Array2d<Chunk*>(WORLD_SIZE_X, WORLD_SIZE_Y);
-	std::vector<Chunk*> m_tbDeleted;
-
-	unsigned int m_center[2] = { UINT16_MAX / 2 - WORLD_SIZE_X, UINT16_MAX / 2 - WORLD_SIZE_Y };
-
-	void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]);
-	void RenderWorld(int& rendercount, Player& player, Transformation& world, Shader& shader);
-	void UpdateWorld(Player& player, BlockInfo* blockinfo[BTYPE_LAST]);
-	void TransposeWorld(Player& player, Bullet* bullets[MAX_BULLETS]);
-
-};
-#endif // WORLD_H__
-

SQCSim2021/worldrenderer.cpp

@@ -0,0 +1,213 @@
+#include "worldrenderer.h"
+
+WorldRenderer::WorldRenderer() {
+	m_meshes.Reset(nullptr);
+}
+
+WorldRenderer::~WorldRenderer() {
+}
+
+void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas) {
+	rendercount = 0;
+	Vector3f angle;
+	Vector3f cursor;
+	Vector3f direct = player_dir;
+	Vector3f pos = player_pos - direct;
+
+	direct.y = 0;
+	direct.Normalize();
+	pos.y = 1;
+
+	static Vector3<unsigned int> renderManifest[VIEW_DISTANCE * 8]; // Nombre de Chunks maximal <20> <20>tre rendus.
+
+	//for (int dist = VIEW_DISTANCE; dist >= 0; dist -= CHUNK_SIZE_X) {
+	for (int dist = 0; dist <= VIEW_DISTANCE; dist += CHUNK_SIZE_X) {
+		// Configuration du radar.
+		float sinus, cosinus;
+		int echantillons;
+
+		if (dist > VIEW_DISTANCE * .1f) {
+			sinus = .00872653549f; // sin(1/2 degr<67>)
+			cosinus = .99996192306; // cos(1/2 degr<67>)
+			echantillons = 180;
+		}
+		//else {//if (dist > VIEW_DISTANCE * .3f) {
+		//	sinus = .01151891831f; // sin(2/3 degr<67>)
+		//	cosinus = .99993365506; // cos(2/3 degr<67>)
+		//	echantillons = 120;
+		//}
+		//else if (dist > VIEW_DISTANCE * .2f) {
+		//	sinus = .01745240643; // sin(1 degr<67>)
+		//	cosinus = .99984769515; // cos(1 degr<67>)
+		//	echantillons = 90;
+		//}
+		//else if (dist > VIEW_DISTANCE * .1f) {
+		//	sinus = .0261769483;
+		//	cosinus = .99965732497;
+		//	echantillons = 60;
+		//}
+		else {
+			sinus = .0348994967;
+			cosinus = .99939082701;
+			echantillons = 45;
+		}
+
+		angle.x = direct.z + direct.x;
+		angle.z = direct.z - direct.x;
+		angle.y = 0;
+		angle.Normalize();
+
+		for (int radar = 0; radar < echantillons; ++radar) {
+			float x = angle.x;
+
+			angle.x = angle.x * cosinus - angle.z * sinus;
+			angle.z = angle.z * cosinus + x * sinus;
+			angle.Normalize();
+
+			cursor = pos - direct * CHUNK_SIZE_X * 4 + angle * dist;
+			if (cursor.y >= 128.f || cursor.y >= 0.f) cursor.y = CHUNK_SIZE_Y / 4.f;
+
+
+			if (origin->ChunkAt(cursor)) {
+				bool valide = true;
+				unsigned int chx, chy;
+				origin->ChunkAt(cursor)->GetPosition(chx, chy);
+				for (int index = 0; index < rendercount; ++index) // Permet de v<>rifier seulement contre celles ajout<75>es dans la frame, et ne pas avoir <20> refaire l'array <20> chaque frame.
+					if (renderManifest[index].x == chx && renderManifest[index].z == chy)
+						valide = false;
+
+				if (valide) renderManifest[rendercount++] = Vector3<unsigned int>(chx,
+					(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) < 0.f ? 0 :
+					(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) * 1000,
+					chy);
+			}
+		}
+	}
+	shader.Use();
+	atlas.Bind();
+	glStencilFunc(GL_EQUAL, 1, 0x00);
+	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+
+	unsigned int sx, sy, cx, cy;
+	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;
+
+		world.ApplyTranslation(chx, 0, chy);
+		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);
+		if (m_meshes.Get(cx - sx, cy - sy))
+			m_meshes.Get(cx - sx, cy -sy)->Render();
+		world.ApplyTranslation(-chx, 0, -chy);
+	}
+	shader.Disable();
+	glStencilFunc(GL_GREATER, 1, 0xFF);
+};
+
+void WorldRenderer::UpdateWorld(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]) {
+	int cx = player.x;
+	int cy = player.z;
+	static int frameUpdate = 2;
+	int side = 0;
+	int threads = 0;
+	std::future<Mesh*> updateThList[THREADS_UPDATE_CHUNKS];
+
+	unsigned int mx = 0 , my = 0, sx, sy;
+
+	origin->GetScope(sx, sy);
+
+	if (frameUpdate > 0) --frameUpdate;
+
+	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 (origin->ChunkAt(chx, 1, chy) &&
+					origin->ChunkAt(chx, 1, chy)->IsDirty()) {
+					origin->ChunkAt(chx, 1, chy)->GetPosition(mx, my);
+					if (m_meshes.Get(mx - sx, my - sy))
+						updateThList[threads++] =
+						std::async(std::launch::async,
+							[](Mesh* mesh, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+								mesh->Update(blockinfo, world); return mesh; }, m_meshes.Get(mx - sx, my - sy), blockinfo, origin);
+					else updateThList[threads++] = std::async(std::launch::async,
+						[](Chunk* chunk) { return new Mesh(chunk); }, origin->ChunkAt(chx, 1, chy));
+					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 (origin->ChunkAt(chx, 1, chy) &&
+					origin->ChunkAt(chx, 1, chy)->IsDirty()) {
+					origin->ChunkAt(chx, 1, chy)->GetPosition(mx, my);
+					if (m_meshes.Get(mx - sx, my - sy))
+						updateThList[threads++] =
+						std::async(std::launch::async,
+							[](Mesh* mesh, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+								mesh->Update(blockinfo, world); return mesh; }, m_meshes.Get(mx - sx, my - sy), blockinfo, origin);
+					else updateThList[threads++] = std::async(std::launch::async,
+						[](Chunk* chunk) { return new Mesh(chunk); }, origin->ChunkAt(chx, 1, chy));
+					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 (origin->ChunkAt(chx, 1, chy) &&
+					origin->ChunkAt(chx, 1, chy)->IsDirty()) {
+					origin->ChunkAt(chx, 1, chy)->GetPosition(mx, my);
+					if (m_meshes.Get(mx - sx, my - sy))
+						updateThList[threads++] =
+						std::async(std::launch::async,
+							[](Mesh* mesh, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+								mesh->Update(blockinfo, world); return mesh; }, m_meshes.Get(mx - sx, my - sy), blockinfo, origin);
+					else updateThList[threads++] = std::async(std::launch::async,
+						[](Chunk* chunk) { return new Mesh(chunk); }, origin->ChunkAt(chx, 1, chy));
+					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 (origin->ChunkAt(chx, 1, chy) &&
+					origin->ChunkAt(chx, 1, chy)->IsDirty()) {
+					origin->ChunkAt(chx, 1, chy)->GetPosition(mx, my);
+					if (m_meshes.Get(mx - sx, my - sy))
+						updateThList[threads++] =
+						std::async(std::launch::async,
+							[](Mesh* mesh, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
+								mesh->Update(blockinfo, world); return mesh; }, m_meshes.Get(mx - sx, my - sy), blockinfo, origin);
+					else updateThList[threads++] = std::async(std::launch::async,
+						[](Chunk* chunk) { return new Mesh(chunk); }, origin->ChunkAt(chx, 1, chy));
+					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();
+			Mesh* mesh = updateThList[i].get();
+			if (mesh->IsNew()) {
+				unsigned int x, y;
+				mesh->GetPosition(x, y, origin);
+				m_meshes.Set(x, y, mesh);
+			}
+			mesh->FlushMeshToVBO();
+		}
+	}
+}

SQCSim2021/worldrenderer.h

@@ -0,0 +1,23 @@
+#ifndef WORLDRENDERER_H__
+#define WORLDRENDERER_H__
+#include <future>
+#include <thread>
+#include "../SQCSim-common/world.h"
+#include "../SQCSim-common/transformation.h"
+#include "define.h"
+#include "mesh.h"
+#include "textureatlas.h"
+#include "shader.h"
+
+class WorldRenderer {
+private:
+	Array2d<Mesh*> m_meshes = Array2d<Mesh*>(WORLD_SIZE_X, WORLD_SIZE_Y);
+
+public:
+	WorldRenderer();
+	~WorldRenderer();
+
+	void RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas);
+	void UpdateWorld(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]);
+};
+#endif