Push Optimisation mesh. Generation des Chunks à revoir.

2023-09-24 00:24:45 -04:00
900 changed files with 1354 additions and 127055 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -373,10 +373,3 @@ 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
 SQCSim2021/SQCSim2021.vcxproj.filters
 SQCSim2021/SQCSim2021.vcxproj
--- a/Debug/glew32.dll
+++ b/Debug/glew32.dll
--- a/Debug/openal32.dll
+++ b/Debug/openal32.dll
--- a/Debug/sfml-audio-d-2.dll
+++ b/Debug/sfml-audio-d-2.dll
--- a/Debug/sfml-graphics-d-2.dll
+++ b/Debug/sfml-graphics-d-2.dll
--- a/Debug/sfml-network-d-2.dll
+++ b/Debug/sfml-network-d-2.dll
--- a/Debug/sfml-system-d-2.dll
+++ b/Debug/sfml-system-d-2.dll
--- a/Debug/sfml-window-d-2.dll
+++ b/Debug/sfml-window-d-2.dll
--- a/Release/glew32.dll
+++ b/Release/glew32.dll
--- a/SQCSim-common/SQCSim-common.vcxproj
+++ b/SQCSim-common/SQCSim-common.vcxproj
@@ -1,163 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>17.0</VCProjectVersion>
    <Keyword>Win32Proj</Keyword>
    <ProjectGuid>{ee91ab12-4225-4a4d-931d-69d72f6d91fb}</ProjectGuid>
    <RootNamespace>SQCSimcommon</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClInclude Include="array2d.h" />
    <ClInclude Include="array3d.h" />
    <ClInclude Include="blockinfo.h" />
    <ClInclude Include="boostinfo.h" />
    <ClInclude Include="bullet.h" />
    <ClInclude Include="chunk.h" />
    <ClInclude Include="define.h" />
    <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>
  <ItemGroup>
    <ClCompile Include="blockinfo.cpp" />
    <ClCompile Include="boostinfo.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" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
 </Project>
--- a/SQCSim-common/SQCSim-common.vcxproj.filters
+++ b/SQCSim-common/SQCSim-common.vcxproj.filters
@@ -1,90 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Fichiers sources">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Fichiers d%27en-tête">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="Fichiers de ressources">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="world.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="player.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="opensimplex.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="array2d.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <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="bullet.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="matrix4.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <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>
    <ClInclude Include="boostinfo.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="world.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="blockinfo.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="bullet.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="chunk.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="opensimplex.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <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>
    <ClCompile Include="boostinfo.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
  </ItemGroup>
 </Project>
--- a/SQCSim-common/boostinfo.cpp
+++ b/SQCSim-common/boostinfo.cpp
@@ -1,32 +0,0 @@
 #include "boostinfo.h"
 #include <iostream>
 BoostInfo::BoostInfo(BoostType 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)
 {
 }
 BoostInfo::~BoostInfo()
 {
 }
 BoostType BoostInfo::GetType() const
 {
    return m_type;
 }
 void BoostInfo::GetTexture(float& u, float& v, float& s)
 {
    u = m_u;
    v = m_v;
    s = m_s;
 }
 void BoostInfo::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;
 }
--- a/SQCSim-common/boostinfo.h
+++ b/SQCSim-common/boostinfo.h
@@ -1,29 +0,0 @@
 #ifndef BOOSTINFO_H__
 #define BOOSTINFO_H__
 #include <string>
 #include "define.h"
 class BoostInfo
 {
 public:
    BoostInfo(BoostType type, const std::string& name, float u, float v, float s, int dur);
    ~BoostInfo();
    BoostType GetType() const;
    void GetTexture(float& u, float& v, float& s);
    void Show() const;
 private:
    BoostType m_type;
    float m_u;
    float m_v;
    float m_s;
    std::string m_name;
    int m_durability;
 };
 #endif // BOOSTINFO_H__
--- a/SQCSim-common/bullet.cpp
+++ b/SQCSim-common/bullet.cpp
@@ -1,52 +0,0 @@
 #include "bullet.h"
 #include "world.h"
 Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
 Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t tid): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_tid(tid) {}
 Bullet::~Bullet() {}
 bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> mapPlayer) {
 	int max = 100 / perframe;
 	float damage = 0.057f;
 	for (int x = 0; x < max; ++x) {
 		m_currentpos += m_velocity * elapsedtime;
 		for (auto& [key, player] : mapPlayer) {
 			if ((m_currentpos - player->GetPosition()).Length() < .4f) {
 				player->InflictDamage(damage);
 				return true;
 			}
 		}
 		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;
 }
 Vector3f Bullet::getPos() const {
 	return m_currentpos;
 }
 Vector3f Bullet::getVel() const {
 	return m_velocity;
 }
 uint64_t Bullet::getTeamID(){
 	return m_tid;
 }
--- a/SQCSim-common/bullet.h
+++ b/SQCSim-common/bullet.h
@@ -1,35 +0,0 @@
 #ifndef BULLET_H__
 #define BULLET_H__
 #include <unordered_map>
 #include "define.h"
 #include "vector3.h"
 #include "player.h"
 class World;
 class Player;
 class Bullet {
 public:
 	Bullet(Vector3f pos, Vector3f dir);
 	Bullet(Vector3f pos, Vector3f dir, uint64_t tid);
 	~Bullet();
 	bool Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> m_mapPlayer);
 	void Transpose(int& x, int& z);
 	Vector3f getPos() const;
 	Vector3f getVel() const;
 	uint64_t getTeamID();
 private:
 	Vector3f m_startpos, 
 			 m_currentpos, 
 			 m_velocity;
 	uint64_t m_tid = 0;
 };
 #endif // BULLET_H__
--- a/SQCSim-common/chunk.cpp
+++ b/SQCSim-common/chunk.cpp
@@ -1,205 +0,0 @@
 #include "chunk.h"
 #include "world.h"
 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);
 	m_blocks.Reset(BTYPE_AIR);
 	int ratio = 0;
 	ratio = x * y % 7;
 	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_GREENGRASS, 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);
 			}
 		}
 	//int rnd = rand() % 15;
 	if (ratio == 1)
 		for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
 			for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
 				for (int iy = 0; iy < 14; ++iy) {
 					if (ix == 3)
 						if (GetBlock(ix, iy, iz) == BTYPE_AIR)
 							Structure(ix, iy, iz, 2);
 				}
 			}
 	if (ratio == 3)
 		for (int ix = 0; ix < CHUNK_SIZE_Z; ++ix) // structure
 			for (int iz = 0; iz < CHUNK_SIZE_X; ++iz) {
 				for (int iy = 0; iy < 14; ++iy) {
 					if (iz == 4)
 						if (GetBlock(ix, iy, iz) == BTYPE_AIR)
 							Structure(ix, iy, iz, 1);
 				}
 			}
 	if (ratio == 5)
 		for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
 			for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
 				for (int iy = 0; iy < 14; ++iy) {
 					if (ix == 3)
 						if (GetBlock(ix, iy, iz) == BTYPE_AIR)
 							Structure(ix, iy, iz, 2);
 				}
 			}
 	//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; }
 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; }
 void Chunk::Structure(int x, int y, int z,int height)
 {
 	for (int i = 0; i < height; i++)
 	{
 		SetBlock(x, i + y, z, BTYPE_GRASS, nullptr);
 	}
 }
--- a/SQCSim-common/chunk.h
+++ b/SQCSim-common/chunk.h
@@ -1,38 +0,0 @@
 #ifndef CHUNK_H__
 #define CHUNK_H__
 #include "define.h"
 #include "array2d.h"
 #include "array3d.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);
        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, 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;
        void Structure(int x, int y, int z, int height);
        bool IsDirty() const;
        void MakeDirty();
        void MakeClean();
        void MakeModified();
 };
 #endif // CHUNK_H__
--- a/SQCSim-common/define.h
+++ b/SQCSim-common/define.h
@@ -1,87 +0,0 @@
 #ifndef DEFINE_H__
 #define DEFINE_H__
 #include <iostream>
 #include <chrono>
 #define SRV_PORT 10000
 #define CLI_PORT 10001
 #define BUFFER_LENGTH 1500
 #define CHUNK_SIZE_X  6
 #define CHUNK_SIZE_Y  64
 #define CHUNK_SIZE_Z  6
 #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 1
 #define FRAMES_UPDATE_CHUNKS 1
 #define FRAMES_DELETE_CHUNKS 1
 #define THREADS_GENERATE_CHUNKS 8
 #define THREADS_UPDATE_CHUNKS 6
 #define THREADS_DELETE_CHUNKS 3
 #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
 #define TIME_SPEED_BOOST 10		//secondes
 #define TIME_DAMAGE_BOOST 10	//secondes
 #define TIME_INVINCIBLE_BOOST 4	//secondes
 #define STRENGTH_SPEED_BOOST 10	//Pourcentage
 #define BULLET_TIME .1
 typedef uint8_t BlockType;
 enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_GREENGRASS, BTYPE_LAST };
 typedef uint8_t BoostType;
 enum BOOST_TYPE { BTYPE_SPEED, BTYPE_HEAL, BTYPE_DAMAGE, BTYPE_INVINCIBLE, BTYPE_BOOST_LAST };
 enum ANIM_TYPE { STILL = 0, SHOOTING = 8, JUMPING = 16, JUMPINGSHOOTING = 24, DEAD = 32, TYPE_LAST = 40};
 enum ANIM_POS {FRONT, QUARTER_FRONT_LEFT, QUATER_FRONT_RIGHT, PROFIL_LEFT, PROFIL_RIGHT, QUARTER_BACK_LEFT, QUARTER_BACK_RIGHT, BACK , POS_LAST};
 typedef uint64_t Timestamp;
 #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 poll WSAPoll
 #define flag_t u_long
 #define addrlen_t int
 #define ioctl ioctlsocket
 #define SOCK_NONBLOCK FIONBIO
 #define strcpy strcpy_s
 #define popen _popen
 #define pclose _pclose
 #else // Pas _WIN32
 #include <unistd.h>
 #include <time.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <cstring>
 #define flag_t unsigned int
 #define addrlen_t unsigned int
 #define SOCKET int
 #define INVALID_SOCKET -1
 #define closesocket close
 #endif // _WIN32
 #endif // DEFINE_H__
--- a/SQCSim-common/netprotocol.cpp
+++ b/SQCSim-common/netprotocol.cpp
--- a/SQCSim-common/netprotocol.h
+++ b/SQCSim-common/netprotocol.h
@@ -1,226 +0,0 @@
 #ifndef NETPROTOCOL_H__
 #define NETPROTOCOL_H__
 #include <string>
 #include "define.h"
 #include "vector3.h"
 /* Protocole Particulier de Partie a Plusieurs Personnes (PPPPP) */
 namespace netprot {
 	enum class PACKET_TYPE: uint8_t {
 				ERR, INPUT, OUTPUT, SYNC,
 				TEAMINF, SELFINF, PLAYINF, LOGINF,
 				CHUNKMOD, PLAYERMOD, PICKUPMOD,
 				GAMEINFO, ENDINFO , CHAT, ERRLOG,
 				LAST_PACK
 			};
 	/* Structures */
 	struct Buffer { // Pour pouvoir rendre l'utilisation des buffers plus clean.
 		char* ptr = new char[BUFFER_LENGTH] { 1 }, * tmp = nullptr;
 		uint32_t len = BUFFER_LENGTH;
 		~Buffer() { delete[] ptr; }
 		void rstLen() { len = BUFFER_LENGTH; }
 	};
 	struct Packet { // Pour pouvoir recevoir les paquets du recv() sans avoir à les aiguiller dans la même thread.
 		void* ptr = nullptr; // Notez que le pointeur doit être supprimé séparément lorsqu'il n'est plus utile.
 		PACKET_TYPE type = PACKET_TYPE::ERR;
 	};
 	/* Constantes */
 	inline const char Footer[sizeof(uint32_t)] = { '\0', '\r', '\0', '\n' }; // constante de footer qui est ajoutée à chaque paquet envoyé.
 	/* Sous-structures */
 	struct Keys {
 		bool forward, 
 			 backward, 
 			 left, 
 			 right, 
 			 jump, 
 			 shoot,
 			 block;
 	};
 	struct States {
 		bool jumping, 
 			 shooting, 
 			 hit, 
 			 powerup,
 			 dead,
 			 still,
 		     jumpshot,
 			 running;
 	};
 	/* Structures de paquets */
 	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				- un premier sync démarre la partie.
 		Timestamp timestamp;
 		uint64_t sid = 0;
 		uint32_t timer = 0;
 		uint16_t ammo = 0;
 		uint8_t hp = 0;
 		Vector3f position;
 		Sync() {}
 		Sync(Sync* sync) : timestamp(sync->timestamp), sid(sync->sid), timer(sync->timer), ammo(sync->ammo), hp(sync->hp), position(sync->position) {}
 	};
 	struct TeamInfo {									// cli <-> srv			TCP			once
 		char name[32];
 		uint64_t id = 0;
 		TeamInfo() {}
 		TeamInfo(TeamInfo* tem) : id(tem->id) { strcpy(tem->name, name); }
 	};
 	struct LoginInfo {									// cli <-> srv			TCP			once
 		char name[32];
 		uint64_t sid = 0, 
 			     tid = 0;
 		LoginInfo() {}
 		LoginInfo(LoginInfo* ply): sid(ply->sid), tid(ply->tid) { strcpy(ply->name, name); }
 	};
 	struct PlayerInfo {									// cli <-> srv			TCP			once
 		char name[32];
 		uint64_t id = 0,
 				 tid = 0;
 		PlayerInfo() {}
 		PlayerInfo(PlayerInfo* log) : id(log->id), tid(log->tid) {
 			strcpy(log->name, name);
 		};
 		PlayerInfo(int id, int tid, std::string strname) : id(id), tid(tid) { memcpy((void*)strname.c_str(), name, strname.length());
 		}
 	};
 	struct GameInfo {									// cli <-> srv			TCP			event (before game start)/ once
 		uint64_t seed;
 		uint32_t countdown;
 		uint8_t gameType; // TODD: enum.
 		GameInfo() {}
 		GameInfo(GameInfo* gam) : seed(gam->seed), countdown(gam->countdown), gameType(gam->gameType) {}
 	};
 	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.
 		Chat() {}
 		Chat(Chat* cha) : src_id(cha->src_id), dest_id(cha->dest_id), dest_team_id(cha->dest_team_id) { strcpy(cha->mess, mess); }
 	};
 	struct ErrorLog {									// srv -> cli			TCP			event
 		char mess[140];
 		bool is_fatal;
 		ErrorLog() {};
 		ErrorLog(ErrorLog* err) : is_fatal(err->is_fatal) { strcpy(err->mess, mess); }
 	};
 	/* Fonctions */
 	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, uint32_t* buflen); // srv
 	bool Deserialize(Output* out, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(Sync* sync, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(TeamInfo* tinfo, char* buf, uint32_t* buflen); // cli/srv
 	bool Deserialize(LoginInfo* linfo, char* buf, uint32_t* buflen); // cli/srv
 	bool Deserialize(PlayerInfo* pinfo, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(GameInfo* ginfo, char* buf, uint32_t* buflen); // cli
 	bool Deserialize(Chat* chat, char* buf, uint32_t* buflen); // srv/cli
 	bool Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen); // srv
 	PACKET_TYPE getType(char* buf, uint32_t buflen);
 	Packet getPack(char* buf, uint32_t *buflen);
 	Packet getPack(Buffer* buf);
 	bool emptyPack(Packet pck);
 	Packet makePack(void* ptr, PACKET_TYPE type); // Pour pouvoir faire une liste de stock a supprimer sans avoir a en faire une pour chaque type.
 	template <class T> T copyPack(Packet* pck);
 	template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
 	template <class T> void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad);
 	template <class T> void sendPack(SOCKET sock, T* pack, Buffer* buf);
 	template <class T> void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad);
 	std::vector<char*> recvPacks(SOCKET sock, Buffer* buf, Buffer* oufbuf = nullptr);
 	std::vector<char*> recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, Buffer* oufbuf = nullptr);
 	/* Templates */
 	template <class T>
 	T copyPack(Packet* pck) { return T((T*)pck->ptr); }
 	template <class T>
 	void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
 		netprot::Serialize(pack, buf, buflen);
 		memcpy(*buf + *buflen, Footer, sizeof(uint32_t));
 		*buflen += sizeof(Footer);
 		send(sock, *buf, *buflen, 0);
 		*buflen = BUFFER_LENGTH;
 	}
 	template <class T>
 	void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad) {
 		const sockaddr_in addr = *sockad;
 		netprot::Serialize(pack, buf, buflen);
 		memcpy(*buf + *buflen, Footer, sizeof(uint32_t));
 		*buflen += sizeof(Footer);
 		sendto(sock, *buf, *buflen, 0, (sockaddr*)&addr, sizeof(addr));
 		*buflen = BUFFER_LENGTH;
 	}
 	template <class T>
 	void sendPack(SOCKET sock, T* pack, Buffer* buf) {
 		netprot::Serialize(pack, &buf->ptr, &buf->len);
 		memcpy(&buf->ptr[buf->len], Footer, sizeof(uint32_t));
 		buf->len += sizeof(Footer);
 		send(sock, buf->ptr, buf->len, 0);
 		buf->rstLen();
 	}
 	template <class T>
 	void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad) {
 		const sockaddr_in addr = *sockad;
 		netprot::Serialize(pack, &buf->ptr, &buf->len);
 		memcpy(&buf->ptr[buf->len], Footer, sizeof(uint32_t));
 		buf->len += sizeof(Footer);
 		sendto(sock, buf->ptr, buf->len, 0, (sockaddr*)&addr, sizeof(addr));
 		buf->rstLen();
 	}
 };
 #endif
--- a/SQCSim-common/world.cpp
+++ b/SQCSim-common/world.cpp
@@ -1,445 +0,0 @@
 #include "world.h"
 World::World() {}
 World::~World() {}
 Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
 void World::BuildWorld() {
 	for (int x = 0; x < WORLD_SIZE_X; ++x)
 		for (int y = 0; y < WORLD_SIZE_Y; ++y)
 			m_chunks.Set(x, y, new Chunk(x + m_center[0], y + m_center[1], m_seed));
 }
 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;
 	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); }
 void World::RemoveChunk(int nbReduit)
 {
 	for (int x = 0; x < WORLD_SIZE_X; ++x)
 		for (int y = 0; y < WORLD_SIZE_Y; ++y)
 		{
 			Chunk* chk = nullptr;
 			if (x < nbReduit)
 				chk = m_chunks.Remove(x, y);
 			if (y < nbReduit)
 				chk = m_chunks.Remove(x, y);
 			if (y > WORLD_SIZE_Y - nbReduit)
 				chk = m_chunks.Remove(x, y);
 			if (x > WORLD_SIZE_X - nbReduit)
 				chk = m_chunks.Remove(x, y);
 			// TODO: MakeDirty() les voisins pour qu'ils se redessinent.
 			if (!chk)
 				continue;
 			m_tbDeleted.emplace_back(chk);
 		}
 }
 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(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::Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]) {
 	UpdateWorld(player_pos, blockinfo);
 	//TransposeWorld(player_pos, bullets);
 }
 //
 //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, const Vector3f& player_pos, const Vector3f& player_dir, bool& block) {
 	Vector3f currentPos = player_pos;
 	Vector3f currentBlock = currentPos;
 	Vector3f ray = player_dir;
 	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::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(); }
--- a/SQCSim-srv/SQCSim-srv.vcxproj
+++ b/SQCSim-srv/SQCSim-srv.vcxproj
@@ -1,151 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>17.0</VCProjectVersion>
    <Keyword>Win32Proj</Keyword>
    <ProjectGuid>{d3bb3300-25f0-42bf-a934-fac33b5c7d25}</ProjectGuid>
    <RootNamespace>SQCSimsrv</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="connection.cpp" />
    <ClCompile Include="main.cpp" />
    <ClCompile Include="server.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="connection.h" />
    <ClInclude Include="define.h" />
    <ClInclude Include="server.h" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\SQCSim-common\SQCSim-common.vcxproj">
      <Project>{ee91ab12-4225-4a4d-931d-69d72f6d91fb}</Project>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
 </Project>
--- a/SQCSim-srv/SQCSim-srv.vcxproj.filters
+++ b/SQCSim-srv/SQCSim-srv.vcxproj.filters
@@ -1,39 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Fichiers sources">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Fichiers d%27en-tête">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="Fichiers de ressources">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="main.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="server.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="connection.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="define.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="server.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="connection.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
  </ItemGroup>
 </Project>
--- a/SQCSim-srv/cmake/CMakeLists.txt
+++ b/SQCSim-srv/cmake/CMakeLists.txt
@@ -1,30 +0,0 @@
 cmake_minimum_required(VERSION 3.18.4)
 project(SQCSim-Server VERSION 0.1)
 add_compile_options("-Wno-narrowing")
 set(CMAKE_CXX_STANDARD 20)
 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)
--- a/SQCSim-srv/connection.cpp
+++ b/SQCSim-srv/connection.cpp
@@ -1,119 +0,0 @@
 #include "connection.h"
 Connection::Connection(SOCKET sock, 
 					   sockaddr_in sockaddr, 
 					   LoginInfo log, 
 					   PlayerInfo play):
 	m_sock(sock), 
 	m_addr(sockaddr), 
 	m_loginfo(log), 
 	m_playinfo(play) {
 }
 Connection::~Connection() { closesocket(m_sock); }
 uint64_t Connection::GetHash(bool self) const { return self? m_loginfo.sid: m_playinfo.id; }
 uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
 std::string Connection::GetName() const { return m_loginfo.name; }
 void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); }
 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) {
 	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_loginfo.sid;
 	}
 	return sync;
 }
 SOCKET Connection::getSock() const { return m_sock; }
 PlayerInfo* Connection::getInfo() const { return (PlayerInfo*)&m_playinfo; }
 sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
 void Connection::getPacks(SOCKET sock) {
 	std::vector<char*> lsPck;
 	Input in;
 	while (true) {
 		lsPck = recvPacksFrom(sock, &m_buf, m_addr);
 		for (auto& pck : lsPck) {
 			uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
 			switch (netprot::getType(pck, 1)) {
 				using enum netprot::PACKET_TYPE;
 			case INPUT:
 				if (Deserialize(&in, pck, &bsize))
 					m_input_manifest[in.timestamp] = in;
 				break;
 			default: break;
 			}
 		}
 		lsPck.clear();
 	}
 }
 void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns) {
 	while (m_last_out < m_output_manifest.size()) {
 		Output out = m_output_manifest.at(m_last_out++);
 		for (auto& [key, conn] : conns) {
 			if (m_playinfo.id == conn->GetHash(true))
 				continue;
 			sendPackTo<Output>(sock, &out, &m_bufout, conn->getAddr());
 		}
 	}
 }
 void Connection::Run(World* world) {
 	Input in, last;
 	Output out;
 	float el;
 	if (m_input_manifest.size() < 2)
 		return;
 	while (m_last_in < m_input_manifest.size()) {
 		in = m_input_manifest.at(m_last_in + 1);
 		last = m_input_manifest.at(m_last_in);
 		el = (float)(in.timestamp - last.timestamp) / 1000.;
 		player.get()->SetDirection(in.direction);
 		player.get()->ApplyPhysics(player.get()->GetInput(in.keys.forward, 
 														  in.keys.backward, 
 														  in.keys.left, 
 														  in.keys.right, 
 														  in.keys.jump, false, el), world, el);
 		out.position = player.get()->GetPosition();
 		out.direction = in.direction;
 		out.timestamp = in.timestamp;
 		out.id = m_playinfo.id;
 		m_output_manifest[out.timestamp] = out;
 		++m_last_in;
 	}
 }
 void Connection::CleanInputManifest(Timestamp time) {
 	auto wat = m_input_manifest.find(time);
 	while (wat != m_input_manifest.begin())
 		m_input_manifest.erase(wat--);
 }
--- a/SQCSim-srv/connection.h
+++ b/SQCSim-srv/connection.h
@@ -1,59 +0,0 @@
 #ifndef CONNECTION_H__
 #define CONNECTION_H__
 #include <deque>
 #include <unordered_map>
 #include "../SQCSim-common/player.h"
 #include "../SQCSim-common/vector3.h"
 #include "../SQCSim-common/netprotocol.h"
 #include "../SQCSim-common/world.h"
 #include "define.h"
 using namespace netprot;
 class Connection {
 public:
 	Connection(
 		SOCKET sock,
 		sockaddr_in sockaddr,
 		LoginInfo log,
 		PlayerInfo play);
 	~Connection();
 	std::unique_ptr<Player> player = nullptr;
 	uint64_t GetHash(bool self = true) const;
 	uint64_t GetTeamHash() const;
 	std::string GetName() const;
 	void AddInput(Input in);
 	Output* getOutput(Timestamp time);
 	Sync getSync(Timestamp time);
 	SOCKET getSock() const;
 	PlayerInfo* getInfo() const;
 	sockaddr_in* getAddr() const;
 	void getPacks(SOCKET sock);
 	void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns);
 	void Run(World* world);
 	void CleanInputManifest(Timestamp time);
 private:
 	std::unordered_map<Timestamp, Input> m_input_manifest;
 	std::unordered_map<Timestamp, Output> m_output_manifest;
 	std::unordered_map<Timestamp, Chat> m_chatlog;
 	SOCKET m_sock;
 	sockaddr_in m_addr;
 	LoginInfo m_loginfo;
 	PlayerInfo m_playinfo;
 	Timestamp m_startsync;
 	uint64_t m_last_in = 0, 
 			 m_last_out = 0;
 	Buffer m_buf,
 		   m_bufout;
 };
 #endif
--- a/SQCSim-srv/define.h
+++ b/SQCSim-srv/define.h
@@ -1,14 +0,0 @@
 #ifndef SRV_DEFINE_H__
 #define SRV_DEFINE_H__
 #include "../SQCSim-common/define.h"
 #include <iostream>
 #include <sstream>
 #include <cctype>
 #include <string>
 #define MAX_CONNECTIONS 16
 #define ID_LIST_SIZE 127
 #define SRV_MANUAL_SETUP true
 #endif
--- a/SQCSim-srv/main.cpp
+++ b/SQCSim-srv/main.cpp
@@ -1,8 +0,0 @@
 #include "server.h"
 int main() {
 	std::unique_ptr<Server> server = std::make_unique<Server>();
 	if (server->Init() == 0)
 		if (server->Ready() == 0)
 			server->Run();
 }
--- a/SQCSim-srv/server.cpp
+++ b/SQCSim-srv/server.cpp
@@ -1,304 +0,0 @@
 #include "server.h"
 Server::Server(LOG_DEST log) {
 	m_log = log;
 	if (log == LOG_DEST::LOGFILE) {
 		m_logfile = std::ofstream("server.log", std::ofstream::out);
 		if (!m_logfile.is_open()) {
 			m_log = LOG_DEST::CONSOLE; // Fallback console.
 			Log("Ouverture fichier log: repli vers console.", true, false);
 		}
 	}
 }
 Server::~Server() {
 	if (m_logfile.is_open())
 		m_logfile.close();
 	if (m_sock_udp)
 		closesocket(m_sock_udp);
 	if (m_sock_tcp)
 		closesocket(m_sock_tcp);	
 	for (const auto& [key, player] : m_players)
 			closesocket(player->getSock());
 		m_players.clear();
 #ifdef _WIN32
 	WSACleanup();
 #endif
 }
 int Server::Init() {
 	Log("Initialisation du serveur...", false, false);
 #ifdef _WIN32
 	if (WSAStartup(MAKEWORD(2, 2), &m_wsaData) != 0) { /* Initialisation de l'environnement reseau (Windows only) */
 		Log("Initialisation WinSock.", true, true);
 		return 1;
 	}
 #endif
 	m_sock_udp = socket(AF_INET, SOCK_DGRAM, 0);
 	if (m_sock_udp == INVALID_SOCKET) { /* Creation du socket UDP */
 		Log("Creation Socket UDP.", true, true);
 		return 2;
 	}
 	m_sock_tcp = socket(AF_INET, SOCK_STREAM, 0);
 	if (m_sock_tcp == INVALID_SOCKET) { /* Creation du socket TCP */
 		Log("Creation Socket TCP.", true, true);
 		return 3;
 	}
 	/* Creation structure donnes descripteur du socket serveur */
 	sockaddr_in addr;
 	addr.sin_family = AF_INET;
 	addr.sin_port = htons(SRV_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 */
 		Log("Association Socket UDP.", true, true);
 		return 4;
 	}
 	if (bind(m_sock_tcp, (sockaddr*)&addr, sizeof(addr)) != 0) { /* Associer le socket TCP au port */
 		Log("Association Socket TCP.", true, true);
 		return 5;
 	}
 	return 0;
 }
 int Server::Ready() {
 	int nbrjoueurs = 0, 
 		nbrconn = 0;
 	bool readystart = false;
 	do {
 		Log("Entrez la duree de la partie: ", false, false);
 		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
 		try {	
 			m_game.countdown = std::stoi(m_buf.ptr);
 		} catch(const std::exception& e) {
 			Log(e.what(), true, false);
 			m_game.countdown = 0;
 		}
 	} while (m_game.countdown < 1);
 	do {
 		Log("Entrez le seed de la partie: ", false, false);
 		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
 		try {	
 			m_game.seed = std::stoi(m_buf.ptr);
 		} catch(const std::exception& e) {
 			Log(e.what(), true, false);
 			m_game.seed = 0;
 		}
 	} while (m_game.seed < 1);
 	do {
 		Log("Entrez le nombre de joueurs: ", false, false);
 		std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
 		try {	
 			nbrjoueurs = std::stoi(m_buf.ptr);
 		} catch(const std::exception& e) {
 			Log(e.what(), true, false);
 			nbrjoueurs = 0;
 		}
 		if (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS)
 			Log("Nombre de joueurs invalide.", true, false);
 	} while (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS);
 	m_game.gameType = 1;
 	if (listen(m_sock_tcp, MAX_CONNECTIONS) < 0) {
 		Log("Ecoute sur le port TCP.", true, true);
 		return 1;
 	}
 	buildIdList(ID_LIST_SIZE);
 	Log("A l'ecoute sur le port: " + std::to_string(SRV_PORT), false, false);
 	while (!readystart) {
 		sockaddr_in sockad;
 		addrlen_t 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 connexion provenant de: ";
 			str.append(inet_ntop(AF_INET, &sockad.sin_addr, m_buf.ptr, m_buf.len)).append(": ").append(std::to_string(sockad.sin_port));
 			if (recv(sock, m_buf.ptr, m_buf.len, 0) > 0) {
 				PlayerInfo play;
 				m_buf.len = BUFFER_LENGTH;
 				Packet pck = getPack(&m_buf);
 				if (pck.type != PACKET_TYPE::LOGINF) {
 					Log("Paquet invalide.", true, false);
 					if (pck.type != PACKET_TYPE::ERR)
 						netprot::emptyPack(pck); 
 					continue; // Passer au prochain appel si c'est pas un LoginInfo ou un LoginInfo invalide qui rentre.
 				}
 				LoginInfo* log = (LoginInfo*)pck.ptr;
 				log->sid = getUniqueId();
 				log->tid = 1145389380; // TODO: À changer si on implemente un mode en equipe.
 				Log(str.append(" Nom: ").append(log->name), false, false);
 				str.clear();
 				Log(str.append(log->name).append(" SID: [").append(std::to_string(log->sid).append("]")), false, false);
 				sendPack<LoginInfo>(sock, log, &m_buf);
 				play.id = getUniqueId();
 				strcpy(play.name, log->name);
 				play.tid = log->tid;
 				sendPack<GameInfo>(sock, &m_game, &m_buf);
 				Connection* conn = new Connection(sock, sockad, *log, play);
 				for (auto& [key, player] : m_players) {
 					sendPack<PlayerInfo>(player->getSock(), &play, &m_buf); // Envoyer les infos de joueur distant aux joueurs d<>j<EFBFBD> connect<63>s		
 					sendPack<PlayerInfo>(sock, player->getInfo(), &m_buf); // et envoyer les infos des joueurs distants au nouveau joueur.
 				}
 				m_players[log->sid] = std::move(conn);
 				delete log;
 				if (++nbrconn >= nbrjoueurs)
 					readystart = true;
 			}
 		}
 	}
 	return 0;
 }
 void Server::Run() {
 	bool endgame = false;
 	Input in;
 	sockaddr_in sockad;
 	addrlen_t socklen = sizeof(sockad);
 	Log("Debut de la partie...", false, false);
 	int players = m_players.size();
 	m_world = new World();
 	m_world->SetSeed(m_game.seed);
 	m_world->GetChunks().Reset(nullptr);
 	m_world->BuildWorld();
 	for (auto& [key, conn] : m_players) { // Creation des instances de joueurs et premier sync.
 		conn->player = std::make_unique<Player>(Vector3f(8.5f, CHUNK_SIZE_Y + 1.8f, 8.5f));
 		Sync sync;
 		sync.position = conn->player->GetPosition();
 		sync.hp = conn->player->GetHP();
 		sync.sid = key;
 		sync.ammo = 0;
 		sync.timestamp = 0;
 		sync.timer = m_game.countdown;
 		sendPack<Sync>(conn->getSock(), &sync, &m_buf);
 	}
 	while (!endgame) {
 		for (auto& [key, conn] : m_players) {
 			conn->getPacks(m_sock_udp);
 			conn->Run(m_world);
 			conn->sendPacks(m_sock_udp, m_players);
 		}
 	}
 	//while (true) {
 	//	if (recvfrom(m_sock_udp, m_buf.ptr, m_buf.len, 0, (sockaddr*)&sockad, &socklen) > 0) {
 	//		Packet pck = getPack(&m_buf);
 	//		switch (pck.type) {
 	//			using enum netprot::PACKET_TYPE;
 //           	case ERR:			std::puts("ERROR!");		break;
 //               case INPUT:			std::puts("INPUT!");		break;
 //               case OUTPUT:		std::puts("OUTPUT!");		break;
 	//			case SYNC:			std::puts("SYNC!");			break;
 //               case TEAMINF:		std::puts("TEAMINF!");		break;
 //               case SELFINF:		std::puts("SELFINF!");		break;
 //               case PLAYINF:		std::puts("PLAYINF!");		break;
 //               case LOGINF:		std::puts("LOGINF!");		break;
 //               case CHUNKMOD:		std::puts("CHUNKMOD!");		break;
 //               case PLAYERMOD:		std::puts("PLAYERMOD!");	break;
 //               case PICKUPMOD:		std::puts("PICKUPMOD!");	break;
 //               case GAMEINFO:		std::puts("GAMEINFO!");		break;
 //               case ENDINFO:		std::puts("ENDINFO!");		break;
 //               case CHAT:			std::puts("CHAT!");			break;
 //               case ERRLOG:		std::puts("ERRLOG!");		break;
 	//			case LAST_PACK:									[[falltrough]];
 	//			default:			std::puts("wtf?!");			break;
 //           }
 	//		netprot::emptyPack(pck);
 //       }
 	//}
 }
 inline std::string Server::LogTimestamp() {
 	time_t rawtime;
 	tm timeinfo;
 	char buffer[50];
 	time(&rawtime);
 #ifdef _WIN32
 	localtime_s(&timeinfo, &rawtime);
 #else
 	localtime_r(&rawtime, &timeinfo);
 #endif
 	strftime(buffer, sizeof(buffer), "%d-%m-%Y %H:%M:%S", &timeinfo);
 	std::string str(buffer);
 	return "[" + str + "] ";
 }
 void Server::Log(std::string str, bool is_error = false, bool is_fatal = false) {
 	switch (m_log) {
 		using enum LOG_DEST; // C++20!
 		case LOGFILE:
 			m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
 			break;
 		case CONSOLE: [[fallthrough]]; // Pour dire que c'est voulu que ça traverse vers le case en dessous (C++17!)
 		default:
 			std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
 			break;
 	}
 	if (is_fatal) {
 		if (m_logfile.is_open())
 			m_logfile.close();
 		if (m_sock_udp)
 			closesocket(m_sock_udp);
 		if (m_sock_tcp)
 			closesocket(m_sock_tcp);
 		for (const auto& [key, player] : m_players) {
 			closesocket(player->getSock());
 		}
 		m_players.clear();
 #ifdef _WIN32
 		WSACleanup();
 #endif
 		exit(-1);
 	}
 }
 void Server::buildIdList(size_t size) {
 	std::set<uint64_t> lst;
 	srand(time(NULL));
 	do lst.insert(((uint64_t)rand() << 32 | rand()));
 	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;
 }
--- a/SQCSim-srv/server.h
+++ b/SQCSim-srv/server.h
@@ -1,55 +0,0 @@
 #ifndef SERVER_H__
 #define SERVER_H__
 #include <fstream>
 #include <vector>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include "../SQCSim-common/world.h"
 #include "../SQCSim-common/netprotocol.h"
 #include "define.h"
 #include "connection.h"
 using namespace netprot;
 class Server {
 public:
 	enum LOG_DEST: unsigned char { CONSOLE, LOGFILE, LOG_LAST };
 	Server(LOG_DEST log = LOG_DEST::CONSOLE);
 	~Server();
 	int Init();
 	int Ready();
 	void Run();
 private:
 #ifdef _WIN32
 	WSADATA m_wsaData;
 #endif
 	SOCKET m_sock_udp = 0,
 		   m_sock_tcp = 0;
 	LOG_DEST m_log;
 	std::ofstream m_logfile;
 	Buffer m_buf;
 	std::unordered_map<uint64_t, Connection*> m_players;
 	std::unordered_map<Timestamp, Chat> m_chatlog;
 	std::vector<uint64_t> m_ids;
 	GameInfo m_game;
 	World* m_world = nullptr;
 	const bool m_manual_setup = SRV_MANUAL_SETUP;
 	std::string LogTimestamp();
 	void Log(std::string str, bool is_error, bool is_fatal);
 	void buildIdList(size_t size);
 	uint64_t getUniqueId(); 	
 };
 #endif
--- a/SQCSim2021/SQCSim2021.vcxproj
+++ b/SQCSim2021/SQCSim2021.vcxproj
@@ -19,45 +19,46 @@
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="array2d.h" />
    <ClInclude Include="array3d.h" />
    <ClInclude Include="audio.h" />
-    <ClInclude Include="booster.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="mesh.h" />
+    <ClInclude Include="matrix4.h" />
    <ClInclude Include="openglcontext.h" />
-    <ClInclude Include="remoteplayer.h" />
+    <ClInclude Include="opensimplex.h" />
-    <ClInclude Include="settings.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="renderer.h" />
+    <ClInclude Include="world.h" />
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="audio.cpp" />
-    <ClCompile Include="booster.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="remoteplayer.cpp" />
+    <ClCompile Include="opensimplex.cpp" />
-    <ClCompile Include="settings.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="renderer.cpp" />
+    <ClCompile Include="world.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>
@@ -111,8 +112,8 @@
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>external\irrKlang-1.6.0\include;external\glew210\include;external\devil180\include;external\sfml251-32\include;$(IncludePath)</IncludePath>
+    <IncludePath>external\irrKlang-1.6.0\include;external\glew170\include;external\devil178\include;external\sfml23\include;$(IncludePath)</IncludePath>
-    <LibraryPath>external\glew210\lib\Release\Win32;external\sfml251-32\lib;external\devil180\lib\x86\Release;external\irrKlang-1.6.0\lib\Win32-visualStudio;$(LibraryPath)</LibraryPath>
+    <LibraryPath>external\glew170\lib;external\devil178\lib;external\sfml23\lib;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
@@ -121,8 +122,8 @@
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>external\devil180\include;external\irrKlang-1.6.0\include;external\sfml251-32\include;external\glew210\include;$(IncludePath)</IncludePath>
+    <IncludePath>external\irrKlang-1.6.0\include;external\sfml23\include;external\devil178\include;external\glew170\include;$(IncludePath)</IncludePath>
-    <LibraryPath>external\sfml251-32\lib;external\devil180\lib\x86\Release;external\glew210\lib\Release\Win32;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
+    <LibraryPath>external\sfml23\lib;external\devil178\lib;external\glew170\lib;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
@@ -136,7 +137,7 @@
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -151,7 +152,7 @@
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -168,14 +169,14 @@
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
      <FloatingPointModel>Fast</FloatingPointModel>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>true</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>
@@ -190,14 +191,14 @@
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
      <FloatingPointModel>Fast</FloatingPointModel>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>true</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>
--- a/SQCSim2021/SQCSim2021.vcxproj.filters
+++ b/SQCSim2021/SQCSim2021.vcxproj.filters
@@ -11,21 +11,51 @@
    </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>
@@ -35,32 +65,23 @@
    <ClInclude Include="textureatlas.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
-    <ClInclude Include="connector.h">
+    <ClInclude Include="world.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
-    <ClInclude Include="openglcontext.h">
+    <ClInclude Include="bullet.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
-    <ClInclude Include="tool.h">
+    <ClInclude Include="opensimplex.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="mesh.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="renderer.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="remoteplayer.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="booster.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
    <ClInclude Include="settings.h">
      <Filter>Fichiers d%27en-tête</Filter>
    </ClInclude>
  </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>
@@ -73,9 +94,18 @@
    <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>
@@ -88,25 +118,13 @@
    <ClCompile Include="textureatlas.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
-    <ClCompile Include="connector.cpp">
+    <ClCompile Include="world.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
-    <ClCompile Include="tool.cpp">
+    <ClCompile Include="bullet.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
-    <ClCompile Include="mesh.cpp">
+    <ClCompile Include="opensimplex.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="renderer.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="remoteplayer.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="booster.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
    <ClCompile Include="settings.cpp">
      <Filter>Fichiers sources</Filter>
    </ClCompile>
  </ItemGroup>
--- a/SQCSim-common/array2d.h
+++ b/SQCSim-common/array2d.h
--- a/SQCSim-common/array3d.h
+++ b/SQCSim-common/array3d.h
--- a/SQCSim2021/audio.cpp
+++ b/SQCSim2021/audio.cpp
@@ -2,17 +2,17 @@
 Audio::Audio() {
 	m_engine = irrklang::createIrrKlangDevice();
-	m_engine->setDopplerEffectParameters(10);
+	m_engine->setDopplerEffectParameters(1);
-	m_engine->setRolloffFactor(2);
+	m_engine->setRolloffFactor(1);
-	m_engine->setDefault3DSoundMinDistance(.1);
+	m_engine->setDefault3DSoundMinDistance(1);
 	m_engine->setDefault3DSoundMaxDistance(1000);
 }
 Audio::Audio(const char * music) {
 	m_engine = irrklang::createIrrKlangDevice();
 	m_engine->setDopplerEffectParameters(1);
-	m_engine->setRolloffFactor(2);
+	m_engine->setRolloffFactor(1);
-	m_engine->setDefault3DSoundMinDistance(.1);
+	m_engine->setDefault3DSoundMinDistance(1);
 	m_engine->setDefault3DSoundMaxDistance(1000);
 	m_music = m_engine->play2D(music, false, true, true, irrklang::ESM_STREAMING);
 }
@@ -28,11 +28,10 @@ void Audio::Update3DAudio(Vector3f pos, Vector3f dir, Vector3f vel) {
 								  irrklang::vec3df(vel.x, vel.y, vel.z));
 }
-irrklang::ISound* Audio::Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped = false, float volume = 1) {
+void Audio::Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, float volume = 1) {
-	sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), is_looped, false, true, is_looped? irrklang::ESM_STREAMING: irrklang::ESM_NO_STREAMING, true);
+	sound = m_engine->play3D(name, irrklang::vec3df(pos.x, pos.y, pos.z), false, false, true, irrklang::ESM_NO_STREAMING, true);
 	sound->setVelocity(irrklang::vec3df(vel.x, vel.y, vel.z));
 	sound->setVolume(volume);
 	return sound;
 }
 void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume = 1) {
@@ -48,7 +47,3 @@ void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& v
 void Audio::ToggleMusicState() { m_music->setIsPaused(!m_music->getIsPaused()); }
 void Audio::PauseEngine() { m_engine->setAllSoundsPaused(); }
 float Audio::GetMusicVolume() const {
 	return m_music->getVolume();
 }
--- a/SQCSim2021/audio.h
+++ b/SQCSim2021/audio.h
@@ -1,30 +1,24 @@
 #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:
 	irrklang::ISoundEngine* m_engine;
 	irrklang::ISound* m_music;
 public:
 	Audio();
 	Audio(const char* music);
 	~Audio();
 	irrklang::ISoundEngine* m_engine;
 	void Update3DAudio(Vector3f pos, Vector3f dir, Vector3f speed);
-	irrklang::ISound* Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, bool is_looped, float volume);
+	void Create3DAudioObj(irrklang::ISound* sound, const char* name, Vector3f pos, Vector3f vel, float volume);
 	void Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume);
@@ -33,8 +27,6 @@ public:
 	void ToggleMusicState();
 	void PauseEngine();
 	float GetMusicVolume() const;
 };
 #endif // AUDIO_H__
--- a/SQCSim-common/blockinfo.cpp
+++ b/SQCSim-common/blockinfo.cpp
--- a/SQCSim-common/blockinfo.h
+++ b/SQCSim-common/blockinfo.h
--- a/SQCSim2021/booster.cpp
+++ b/SQCSim2021/booster.cpp
@@ -1,46 +0,0 @@
 #include "booster.h";
 void Booster::RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas,  Shader& shader, Transformation tran)
 {
 	//
 	//Vector3f playerToQuad = m_player.GetPosition() - m_position;
 	//playerToQuad.Normalize();
 	//Vector3f targetPosition = m_player.GetPosition() + playerToQuad * 10.0f;
 	//Matrix4f rotationMatrix;
 	//rotationMatrix.SetLookAt(m_position, targetPosition, Vector3f(0, 1, 0));
 	//glMultMatrixf(rotationMatrix.GetInternalValues());
 	float x = pos.x;
 	float y = pos.y;
 	float z = pos.z;
 	float width = 1.0f;
 	float height = 1.0f;
 	//Pt override les collisions.. a ce point la je sais pas quoi faire
 	//Matrix4 mat4 = tran.GetMatrix();
 	//mat4 VP = pMatrix * vMatrix;
 	//Vector3f CameraRight = Vector3f(mat4.Get11(), mat4.Get21(), mat4.Get31());
 	//Vector3f CameraUp = Vector3f(mat4.Get12(), mat4.Get22(), mat4.Get32());
 	//Vector3f v1 = (m_position + CameraRight * 0.5 * width + CameraUp * -0.5 * width);
 	//Vector3f v2 = (m_position + CameraRight * 0.5 * width + CameraUp * 0.5 * width);
 	//Vector3f v4 = (m_position + CameraRight * -0.5 * width + CameraUp * -0.5 * width);
 	//Vector3f v3 = (m_position + CameraRight * -0.5 * width + CameraUp * 0.5 * width);
 	//tran.ApplyTranslation(m_position);
 	float u, v, w, h;
 	//glDisable(GL_DEPTH_TEST);
 	shader.Use();
 	textureAtlas.Bind();
 	textureAtlas.TextureIndexToCoord(8, u, v, w, h);
 	//glLoadIdentity();
 	glLoadMatrixf(tran.GetMatrix().GetInternalValues());
 	glBegin(GL_QUADS);
 	glTexCoord2f(u, v); glVertex3f(x - width / 2., y - height, z); //glVertex3f(v4.x, v4.y, v4.z);//glVertex3f(0, 50, 0);
 	glTexCoord2f(u + w, v); glVertex3f(x + width / 2., y - height, z); //glVertex3f(v3.x, v3.y, v3.z); //glVertex3f(50,50, 0);
 	glTexCoord2f(u + w, v + h); glVertex3f(x + width / 2., y, z); //glVertex3f(v2.x, v2.y, v2.z); //glVertex3f(50, 0, 0);
 	glTexCoord2f(u, v + h); glVertex3f(x - width / 2., y, z); //glVertex3f(v1.x, v1.y, v1.z);// glVertex3f(0, 0, 0);
 	glEnd();
 	shader.Disable();
 	//tran.ApplyTranslation(-m_position);
 	//glEnable(GL_DEPTH_TEST);
 }
--- a/SQCSim2021/booster.h
+++ b/SQCSim2021/booster.h
@@ -1,14 +0,0 @@
 #ifndef BOOSTER_H__
 #define BOOSTER_H__
 #include "define.h"
 #include "textureatlas.h"
 #include "shader.h"
 #include "../SQCSim-common/vector3.h"
 #include "../SQCSim-common/transformation.h"
 class Booster {
 public:
 	void RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas,  Shader& shader, Transformation tran);
 };
 #endif
--- a/SQCSim2021/bullet.cpp
+++ b/SQCSim2021/bullet.cpp
@@ -0,0 +1,32 @@
 #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;
 }
--- a/SQCSim2021/bullet.h
+++ b/SQCSim2021/bullet.h
@@ -0,0 +1,27 @@
 #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__
--- a/SQCSim2021/chunk.cpp
+++ b/SQCSim2021/chunk.cpp
@@ -0,0 +1,274 @@
 #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); }
 NEIGHBOR_CHUNK_POSITION 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();
        return X_MINUS;
    }
    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();
        return X_PLUS;
    }
    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();
        return Z_MINUS;
    }
    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();
        return Z_PLUS;
    }
    return NONE;
 }
 void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
 void Chunk::AddAllVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int cx, int cy, int x, int y, int z, float u, float v, float s, World* world) {
    if (world->BlockAt(cx + 1, y, cy) == BTYPE_AIR) {
        AddXPlusVertices(vd, count, bt, x, y, z, u, v, s);
    }
    if (world->BlockAt(cx - 1, y, cy) == BTYPE_AIR) {
        AddXMinusVertices(vd, count, bt, x, y, z, u, v, s);
    }
    if (world->BlockAt(cx, y, cy + 1) == BTYPE_AIR) {
        AddZPlusVertices(vd, count, bt, x, y, z, u, v, s);
    }
    if (world->BlockAt(cx, y, cy - 1) == BTYPE_AIR) {
        AddZMinusVertices(vd, count, bt, x, y, z, u, v, s);
    }
 }
 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;
    bool isOnBorder = (x == 0 || x == CHUNK_SIZE_X - 1 ||
                       z == 0 || z == CHUNK_SIZE_Z - 1 ||
                       y == 0 || y == CHUNK_SIZE_Y - 1);
    NEIGHBOR_CHUNK_POSITION ncp = CheckNeighbors(x, z, world);
    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 (!isOnBorder || (x == CHUNK_SIZE_X - 1 && ncp == X_PLUS) || (x == CHUNK_SIZE_X - 1 && ncp == NONE)) {        // X+
        AddAllVertices(vd, count, bt, cx, cy, x, y, z, u, v, s, world);
    }
    else if (!isOnBorder || (x == 0 && ncp == X_MINUS) || (x == 0 && ncp == NONE)) {							    // X-
        AddAllVertices(vd, count, bt, cx, cy, x, y, z, u, v, s, world);
 	}
    else if (!isOnBorder || (z == CHUNK_SIZE_Z - 1 && ncp == Z_PLUS) || (z == CHUNK_SIZE_Z - 1 && ncp == NONE)) {	// Z+
        AddAllVertices(vd, count, bt, cx, cy, x, y, z, u, v, s, world);
 	}
    else if (!isOnBorder || (z == 0 && ncp == Z_MINUS) || (z == 0 && ncp == NONE)) {								// Z-
        AddAllVertices(vd, count, bt, cx, cy, x, y, z, u, v, s, world);
    }
 }
 void Chunk::AddXPlusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s) {
    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);
 }
 void Chunk::AddXMinusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s) {
    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);
 }
 void Chunk::AddZPlusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s) {
    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);
 }
 void Chunk::AddZMinusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s) {
    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; }
--- a/SQCSim2021/chunk.h
+++ b/SQCSim2021/chunk.h
@@ -0,0 +1,54 @@
 #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);
        NEIGHBOR_CHUNK_POSITION CheckNeighbors(unsigned int x, unsigned int z, World* world);
        void GetPosition(unsigned int& x, unsigned int& y) const;
        void AddAllVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt,int cx, int cy, int x, int y, int z, float u, float v, float s, World* world);
        void AddXPlusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s);
        void AddXMinusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s);
        void AddZPlusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s);
        void AddZMinusVertices(VertexBuffer::VertexData* vd, int& count, BlockType bt, int x, int y, int z, float u, float v, float s);
        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__
--- a/SQCSim2021/cmake/CMakeLists.txt
+++ b/SQCSim2021/cmake/CMakeLists.txt
@@ -1,69 +0,0 @@
 cmake_minimum_required(VERSION 3.18.4)
 project(SQCSim-Client VERSION 0.8)
 set(CMAKE_CXX_STANDARD 20)
 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"
 			"../renderer.cpp"
 			"../remoteplayer.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}
 			)
--- a/SQCSim2021/connector.cpp
+++ b/SQCSim2021/connector.cpp
@@ -1,126 +0,0 @@
 #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(const 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;
 		return 2;
 	}
 	flag_t flag = 1;
 	if (ioctl(m_sock_tcp, SOCK_NONBLOCK, &flag) < 0) {
 		std::cout << "Impossible de mettre le socket en mode non-bloquant." << std::endl;
 		return 3;
 	}
 	netprot::Buffer bf;
 	netprot::LoginInfo log;
 	strcpy(log.name, name.c_str());
 	netprot::sendPack(m_sock_tcp, &log, &bf);
 	//using namespace std::chrono_literals;
 	//std::this_thread::sleep_for(100ms);
 	memset(bf.ptr, '\0', BUFFER_LENGTH);
 	bool ready = false;
 	int errors = 0;
 	std::vector<char*> lsPck;
 	while (!ready) {
 		lsPck = netprot::recvPacks(m_sock_tcp, &bf);
 		for (auto& pck : lsPck) {
 			uint32_t bsize = bf.len - (pck - bf.ptr);
 			netprot::PlayerInfo* pl = nullptr;
 			switch (netprot::getType(pck, 1)) {
 				using enum netprot::PACKET_TYPE;
 			case LOGINF:
 				if (!netprot::Deserialize(&m_loginfo, pck, &bsize))
 					++errors;
 				break;
 			case GAMEINFO:
 				if (!netprot::Deserialize(&m_gameinfo, pck, &bsize))
 					++errors;
 				break;
 			case PLAYINF:
 				pl = new netprot::PlayerInfo();
 				if (!netprot::Deserialize(pl, pck, &bsize))
 					++errors;
 				else m_players[pl->id] = pl;
 				break;
 			case TEAMINF:
 				// TODO: Faire dequoi avec TeamInfo si on fini par avoir des teams.
 				break;
 			case SYNC:
 				if (!netprot::Deserialize(&m_origin, pck, &bsize))
 					++errors;
 				ready = true;
 				break;
 			default:
 				errors++;
 				break;
 			}
 		}
 		lsPck.clear();
 		if (errors > 1000)
 			return 4;
 	}
 	return 0;
 }
 uint64_t Connector::getId() const { return m_loginfo.sid; }
 unsigned int Connector::getSeed() const { return m_gameinfo.seed; }
 netprot::Sync Connector::getOrigin() const { return m_origin; }
--- a/SQCSim2021/connector.h
+++ b/SQCSim2021/connector.h
@@ -1,43 +0,0 @@
 #ifndef CONNECTOR_H__
 #define CONNECTOR_H__
 #include <stdlib.h>
 #include <unordered_map>
 #include "../SQCSim-common/netprotocol.h"
 #include "define.h"
 class Connector {
 public:
 	Connector();
 	~Connector();
 	int Init();
 	int Connect(const char* srv_addr, std::string name);
 	uint64_t getId() const;
 	unsigned int getSeed() const;
 	netprot::Sync getOrigin() const;
 	//void SendInput();
 	//int Sync();
 	SOCKET m_sock_udp = 0,
 		m_sock_tcp = 0;
 	sockaddr_in m_srvsockaddr;
 	// void updateRemotePlayers(std::map<RemotePlayers> rplayers);
 	std::unordered_map<uint64_t, netprot::PlayerInfo> m_players;
 private:
 #ifdef _WIN32
 	WSADATA m_wsaData;
 #endif
 	std::unordered_map<Timestamp, netprot::Input> m_inputmanifest;
 	std::unordered_map<uint64_t, netprot::TeamInfo> m_teams;
 	netprot::LoginInfo m_loginfo;
 	netprot::GameInfo m_gameinfo;
 	netprot::Sync m_origin;
 };
 #endif
--- a/SQCSim2021/define.h
+++ b/SQCSim2021/define.h
@@ -1,55 +1,73 @@
-#ifndef CLI_DEFINE_H__
+#ifndef DEFINE_H__
-#define CLI_DEFINE_H__
+#define DEFINE_H__
 //#define SFML_STATIC true
 #include <iostream>
 #include <chrono>
 #include <iomanip>
 #include <GL/glew.h>
 #include <SFML/Window.hpp>
 #include <SFML/Graphics.hpp>
-#include "../SQCSim-common/define.h"
+#include <iostream>
 #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 SRV_ADDR "127.0.0.1"
+#define CHUNK_SIZE_X  16
-#define COUNTDOWN 300
+#define CHUNK_SIZE_Y  128
 #define CHUNK_SIZE_Z  16
 #define MAX_SELECTION_DISTANCE 5
 #define SEED 12345
-#define BULLET_UPDATES_PER_FRAME 20
+#ifdef _DEBUG
 #define WORLD_SIZE_X 2
 #define WORLD_SIZE_Y 2
 #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
 #define BASE_WIDTH 640
 #define BASE_HEIGHT 480
 #endif
 #ifdef NDEBUG
 #define WORLD_SIZE_X 2
 #define WORLD_SIZE_Y 2
 #define FRAMES_RENDER_CHUNKS 1
 #define FRAMES_UPDATE_CHUNKS 1
 #define FRAMES_DELETE_CHUNKS 1
 #define THREADS_GENERATE_CHUNKS 12
 #define THREADS_UPDATE_CHUNKS 5
 #define THREADS_DELETE_CHUNKS 2
 #define VIEW_DISTANCE 1024
 #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 };
 enum NEIGHBOR_CHUNK_POSITION { NONE, X_MINUS, X_PLUS, Z_MINUS, Z_PLUS };
 //#define TEXTURE_PATH        "../SQCSim2021/media/textures/"
 //#define SHADER_PATH		    "../SQCSim2021/media/shaders/"
 //#define AUDIO_PATH			"../SQCSim2021/media/audio/"
 //#define CHUNK_PATH			"../SQCSim2021/media/chunks/"
 #define ANIME_PATH_JUMP		"./media/textures/AssetOtherPlayer/FinalPNGJumping/"
 #define ANIME_PATH_STILL	"./media/textures/AssetOtherPlayer/FinalPNGStanding/"
 #define TEXTURE_PATH        "./media/textures/"
 #define SHADER_PATH		    "./media/shaders/"
 #define AUDIO_PATH			"./media/audio/"
 #define CHUNK_PATH			"./media/chunks/"
 #define BOOSTER_TEXTURE_PATH "./media/textures/Booster/"
 enum GameState { 
 	MAIN_MENU, 
 	SPLASH,
 	OPTIONS,
 	QUIT, 
 	PLAY, 
 	PAUSE
 };
 enum Resolution {
 	HD = 0,		// 1280x720	 (High Definition)
 	FHD,		// 1920x1080 (Full HD)
 	QHD,		// 2560x1440 (Quad HD)
 	UHD			// 3840x2160 (Ultra HD)
 };
 #endif // DEFINE_H__
--- a/SQCSim2021/docs/analyse_preliminaire.md
+++ b/SQCSim2021/docs/analyse_preliminaire.md
--- a/SQCSim2021/docs/analyse_serveur.md
+++ b/SQCSim2021/docs/analyse_serveur.md
@@ -1 +0,0 @@
--- a/SQCSim2021/engine.cpp
+++ b/SQCSim2021/engine.cpp
--- a/SQCSim2021/engine.h
+++ b/SQCSim2021/engine.h
@@ -1,30 +1,20 @@
 #ifndef ENGINE_H__
 #define ENGINE_H__
 #include <algorithm>
 #include <chrono>
 #include <cmath>
 #include <unordered_map>
 #include "../SQCSim-common/array2d.h"
 #include "../SQCSim-common/blockinfo.h"
 #include "../SQCSim-common/boostinfo.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 "connector.h"
+#include "blockinfo.h"
-#include "renderer.h"
+#include "array2d.h"
-#include "remoteplayer.h"
+#include "world.h"
-#include "booster.h"
+#include "bullet.h"
 #include "settings.h"
 class Engine : public OpenglContext {
 public:
@@ -42,145 +32,43 @@ public:
    virtual void MouseReleaseEvent(const MOUSE_BUTTON &button, int x, int y);
 private:
    float GetScale() const;
    int GetFps(float elapsedTime) const;
    int GetCountdown(float elapsedTime);
    int GetOptionsChoice();
    bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps = true, bool stopOnError = true);
    void InstantDamage();
    void SystemNotification(std::string systemLog);
    void KillNotification(Player killer, Player killed);
    void DisplayNotification(std::string message);
    void DisplayCrosshair();
    void DisplayPovGun();
    void DisplayCurrentItem();
-    void DisplayHud(int timer);
+    void DisplayHud();
    void DrawHud(float elapsedTime, BlockType bloc);
    void DisplayInfo(float elapsedTime, BlockType bloc);
    void DrawHud(float elapsedTime, BlockType bloc);
    void PrintText(float x, float y, float scale, const std::string& t);
-    void DisplaySplashScreen();
+    Shader m_shader01;
-    void DisplayPauseMenu();
+    BlockInfo* m_blockinfo[BTYPE_LAST];
    TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
-    void DisplayMainMenu();
+    World m_world = World();
    void DrawButtonBackgrounds(float centerX, float centerY, int iterations);
    void DrawMainMenuButtons(float centerX, float centerY);
    void DrawSingleMultiButtons(float centerX, float centerY);
-    void DisplayOptionsMenu();
+    Texture m_textureSkybox;
-    void DisplayAudioMenu(float centerX, float centerY);
+    Texture m_textureFont;
-    void DisplayGraphicsMenu(float centerX, float centerY);
+    Texture m_textureCrosshair;
-    void DisplayGameplayMenu(float centerX, float centerY);
+    Texture m_textureGun;
    void DrawSliderBackground(float centerX, float centerY, float minVal, float maxVal, float bottomSideValue, float topSideValue);
    void DisplayBarPercentValue(float centerX, float centerY, float posX, float posY, float minVal, float maxVal, float value);
    void DrawSlider(float centerX, float centerY, float value, float minVal, float maxVal, float bottomSideValue, float topSideValue);
    void PrintText(float x, float y, const std::string& t, float charSizeMultiplier = 1.0f);
    void ProcessNotificationQueue();
    Connector m_conn;
    Skybox m_skybox;
    Audio m_audio = Audio(AUDIO_PATH "start.wav");
-    irrklang::ISound* m_powpow, * m_scream;
+
-    irrklang::ISound* m_whoosh[MAX_BULLETS];
+    irrklang::ISound* m_powpow;
    irrklang::ISound* m_scream;
    Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
    Bullet* m_bullets[MAX_BULLETS];
    std::chrono::high_resolution_clock::time_point m_startTime;
    std::unordered_map<uint64_t, Player*> m_players;
    netprot::Buffer m_buf, m_bufout;
    netprot::PlayerInfo m_pinfo;
    RemotePlayer m_remotePlayer = RemotePlayer(netprot::PlayerInfo(), Vector3f(5.5f, CHUNK_SIZE_Y + 1.8f, 5.5f));
    std::string m_messageNotification = "";
    World m_world = World();
    Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
    Renderer m_renderer = Renderer();
    Booster m_booster = Booster();
    BlockInfo* m_blockinfo[BTYPE_LAST];
    BoostInfo* m_boostinfo[BTYPE_BOOST_LAST];
    GameState m_gamestate = GameState::SPLASH;
    Shader m_shader01;
    Skybox m_skybox;
    TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
    TextureAtlas m_animeAtlas = TextureAtlas(TYPE_LAST + POS_LAST);
    TextureAtlas::TextureIndex texBoostHeal;
    Texture m_textureCrosshair;
    Texture m_textureFont;
    Texture m_textureGun;
    Texture m_texturePovGun;
    Texture m_textureSkybox;
    Texture m_textureMainMenu;
    Texture m_textureOptionsMenu;
    Texture m_texturePauseMenu;
    Texture m_textureSplashScreen;
    Texture m_textureHd;
    Texture m_textureFhd;
    Texture m_textureQhd;
    Texture m_textureUhd;
    Texture m_textureCheck;
    Texture m_textureChecked;
    Texture m_textureOptAudio;
    Texture m_textureOptBack;
    Texture m_textureOptGameplay;
    Texture m_textureOptGraphics;
    Texture m_textureOptMain;
    Texture m_textureOptMusic;
    Texture m_textureOptOptions;
    Texture m_textureOptResolution;
    Texture m_textureOptSensitivity;
    Texture m_textureOptSfx;
    Texture m_textureMenuBack;
    Texture m_textureMenuMulti;
    Texture m_textureMenuOptions;
    Texture m_textureMenuPlay;
    Texture m_textureMenuQuit;
    Texture m_textureMenuSingle;
    Texture m_textureMenuTitle;
    Settings m_options = Settings(m_audio);
    Resolution m_resolution = HD;
    float m_splashTime = 2.0f;
    float m_scale;
    float m_time = 0;
    float m_titleX = 0;
    float m_titleY = 0;
    int m_renderCount = 0;
    int m_countdown = COUNTDOWN;
    int m_nbReductionChunk = 4;
    int m_timerReductionChunk = 30;
    float m_volPrincipal = 0.0f;
    float m_volMusique = 0.0f;
    float m_volEffets = 0.0f;
    float m_volSensible = 0.0f;
    int m_selectedOption = 0;
    bool m_selectedOptAudioMainBar = false;
    bool m_selectedOptAudioMusicBar = false;
 	bool m_selectedOptAudioSfxBar = false;
    bool m_selectedGameplaySensitivityBar = false;
    bool m_damage = false;
    bool m_wireframe = false;
    bool m_isSkybox = true;
@@ -188,35 +76,18 @@ private:
    bool m_flash = true;
    bool m_displayCrosshair = true;
    bool m_displayHud = true;
-    bool m_displayInfo = true;
+    bool m_displayInfo = false;
    bool m_resetcountdown = false;
    bool m_soloMultiChoiceMade = false;
    bool m_stopcountdown = false;
    bool m_selectedPlayOptions = false;
    bool m_selectedOptions = false;
    bool m_selectedQuit = false;
    bool m_key1 = false;
    bool m_key2 = false;
    bool m_keyK = false;
    bool m_keyL = false;
    bool m_keyW = false;
    bool m_keyA = false;
    bool m_keyS = false;
    bool m_keyD = false;
    bool m_keySpace = false;
    bool m_mouseL = false;
    bool m_mouseR = false;
    bool m_mouseC = false;
    bool m_mouseWU = false;
    bool m_mouseWD = false;
    float m_mousemx = 0;
    float m_mousemy = 0;
    bool m_networkgame = false;
 };
 #endif // ENGINE_H__
--- a/SQCSim2021/external/sfml251-32/doc/html/AlResource_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/AlResource_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Audio_2Export_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Audio_2Export_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Audio_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Audio_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/BlendMode_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/BlendMode_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/CircleShape_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/CircleShape_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Clipboard_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Clipboard_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Clock_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Clock_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Color_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Color_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Config_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Config_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/ContextSettings_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/ContextSettings_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Context_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Context_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/ConvexShape_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/ConvexShape_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Cursor_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Cursor_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Drawable_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Drawable_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Err_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Err_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Event_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Event_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/FileInputStream_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/FileInputStream_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Font_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Font_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Ftp_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Ftp_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/GlResource_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/GlResource_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Glsl_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Glsl_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Glyph_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Glyph_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/GpuPreference_8hpp.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/GpuPreference_8hpp.html
@@ -1,98 +0,0 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>SFML - Simple and Fast Multimedia Library</title>
        <meta http-equiv="Content-Type" content="text/html;"/>
        <meta charset="utf-8"/>
        <!--<link rel='stylesheet' type='text/css' href="https://fonts.googleapis.com/css?family=Ubuntu:400,700,400italic"/>-->
        <link rel="stylesheet" type="text/css" href="doxygen.css" title="default" media="screen,print" />
        <script type="text/javascript" src="jquery.js"></script>
        <script type="text/javascript" src="dynsections.js"></script>
    </head>
    <body>
        <div id="banner-container">
            <div id="banner">
                <span id="sfml">SFML 2.5.1</span>
            </div>
        </div>
        <div id="content">
 <!-- Generated by Doxygen 1.8.14 -->
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="pages.html"><span>Related&#160;Pages</span></a></li>
      <li><a href="modules.html"><span>Modules</span></a></li>
      <li><a href="namespaces.html"><span>Namespaces</span></a></li>
      <li><a href="annotated.html"><span>Classes</span></a></li>
      <li class="current"><a href="files.html"><span>Files</span></a></li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="files.html"><span>File&#160;List</span></a></li>
      <li><a href="globals.html"><span>File&#160;Members</span></a></li>
    </ul>
  </div>
 <div id="nav-path" class="navpath">
  <ul>
 <li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li><li class="navelem"><a class="el" href="dir_c0a853e81d6f1c1f0a3eb7a27dc24256.html">SFML</a></li>  </ul>
 </div>
 </div><!-- top -->
 <div class="header">
  <div class="summary">
 <a href="#define-members">Macros</a>  </div>
  <div class="headertitle">
 <div class="title">GpuPreference.hpp File Reference</div>  </div>
 </div><!--header-->
 <div class="contents">
 <p>Headers.  
 <a href="#details">More...</a></p>
 <div class="textblock"><code>#include &lt;SFML/Config.hpp&gt;</code><br />
 </div>
 <p><a href="GpuPreference_8hpp_source.html">Go to the source code of this file.</a></p>
 <table class="memberdecls">
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
 Macros</h2></td></tr>
 <tr class="memitem:ab0233c2d867cbd561036ed2440a4fec0"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="GpuPreference_8hpp.html#ab0233c2d867cbd561036ed2440a4fec0">SFML_DEFINE_DISCRETE_GPU_PREFERENCE</a></td></tr>
 <tr class="memdesc:ab0233c2d867cbd561036ed2440a4fec0"><td class="mdescLeft">&#160;</td><td class="mdescRight">A macro to encourage usage of the discrete GPU.  <a href="#ab0233c2d867cbd561036ed2440a4fec0">More...</a><br /></td></tr>
 <tr class="separator:ab0233c2d867cbd561036ed2440a4fec0"><td class="memSeparator" colspan="2">&#160;</td></tr>
 </table>
 <a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
 <div class="textblock"><p>Headers. </p>
 <p>File containing SFML_DEFINE_DISCRETE_GPU_PREFERENCE </p>
 <p class="definition">Definition in file <a class="el" href="GpuPreference_8hpp_source.html">GpuPreference.hpp</a>.</p>
 </div><h2 class="groupheader">Macro Definition Documentation</h2>
 <a id="ab0233c2d867cbd561036ed2440a4fec0"></a>
 <h2 class="memtitle"><span class="permalink"><a href="#ab0233c2d867cbd561036ed2440a4fec0">&#9670;&nbsp;</a></span>SFML_DEFINE_DISCRETE_GPU_PREFERENCE</h2>
 <div class="memitem">
 <div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE</td>
        </tr>
      </table>
 </div><div class="memdoc">
 <p>A macro to encourage usage of the discrete GPU. </p>
 <p>In order to inform the Nvidia/AMD driver that an SFML application could benefit from using the more powerful discrete GPU, special symbols have to be publicly exported from the final executable.</p>
 <p>SFML defines a helper macro to easily do this.</p>
 <p>Place SFML_DEFINE_DISCRETE_GPU_PREFERENCE in the global scope of a source file that will be linked into the final executable. Typically it is best to place it where the main function is also defined. </p>
 <p class="definition">Definition at line <a class="el" href="GpuPreference_8hpp_source.html#l00069">69</a> of file <a class="el" href="GpuPreference_8hpp_source.html">GpuPreference.hpp</a>.</p>
 </div>
 </div>
 </div><!-- contents -->
        </div>
        <div id="footer-container">
            <div id="footer">
                SFML is licensed under the terms and conditions of the <a href="https://www.sfml-dev.org/license.php">zlib/png license</a>.<br>
                Copyright &copy; Laurent Gomila &nbsp;::&nbsp;
                Documentation generated by <a href="http://www.doxygen.org/" title="doxygen website">doxygen</a> &nbsp;::&nbsp;
            </div>
        </div>
    </body>
 </html>
--- a/SQCSim2021/external/sfml251-32/doc/html/GpuPreference_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/GpuPreference_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Graphics_2Export_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Graphics_2Export_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Graphics_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Graphics_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Http_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Http_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Image_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Image_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/InputSoundFile_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/InputSoundFile_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/InputStream_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/InputStream_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/IpAddress_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/IpAddress_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Joystick_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Joystick_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Keyboard_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Keyboard_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Listener_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Listener_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Lock_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Lock_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Main_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Main_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/MemoryInputStream_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/MemoryInputStream_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Mouse_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Mouse_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Music_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Music_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Mutex_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Mutex_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/NativeActivity_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/NativeActivity_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Network_2Export_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Network_2Export_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Network_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Network_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/NonCopyable_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/NonCopyable_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/OpenGL_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/OpenGL_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/OutputSoundFile_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/OutputSoundFile_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/Packet_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/Packet_8hpp_source.html
--- a/SQCSim2021/external/sfml251-32/doc/html/PrimitiveType_8hpp_source.html
+++ b/SQCSim2021/external/sfml251-32/doc/html/PrimitiveType_8hpp_source.html
--- a/Show More
+++ b/Show More