Ajouts dans netprotocol

Sqc 13 connexion srv

SQCSim-common/SQCSim-common.vcxproj

@@ -0,0 +1,156 @@
+<?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>
+    </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>
+    </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>
+    </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>stdcpp17</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="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="vector3.h" />
+    <ClInclude Include="world.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="blockinfo.cpp" />
+    <ClCompile Include="bullet.cpp" />
+    <ClCompile Include="chunk.cpp" />
+    <ClCompile Include="netprotocol.cpp" />
+    <ClCompile Include="opensimplex.cpp" />
+    <ClCompile Include="player.cpp" />
+    <ClCompile Include="world.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

SQCSim-common/SQCSim-common.vcxproj.filters

@@ -0,0 +1,78 @@
+<?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>
+  </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>
+  </ItemGroup>
+</Project>

SQCSim-common/bullet.cpp

@@ -1,14 +1,13 @@
 #include "bullet.h"
 #include "world.h"
 
-Bullet::Bullet(Player& player) {
-	m_startpos = m_currentpos = player.GetPOV() + player.GetDirection();
-	m_velocity = player.GetDirection();
-}
+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, Transformation& tran, float elapsedtime) {
+bool Bullet::Update(World* world, float elapsedtime) {
 	for (int x = 0; x < 1000; ++x) {
 		m_currentpos += m_velocity * elapsedtime;
 
@@ -30,3 +29,11 @@ void Bullet::Transpose(int& x, int& z) {
 	m_startpos.x -= x * CHUNK_SIZE_X;
 	m_startpos.z -= z * CHUNK_SIZE_Z;
 }
+
+Vector3f Bullet::getPos() {
+	return m_currentpos;
+}
+
+uint64_t Bullet::getTeamID(){
+	return m_tid;
+}

SQCSim-common/bullet.h

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

SQCSim-common/chunk.cpp

@@ -0,0 +1,111 @@
+#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);
+}
+
+void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
+    m_blocks.Set(x, y, z, type);
+}
+
+BlockType Chunk::GetBlock(int x, int y, int z) { return m_blocks.Get(x, y, z); }
+
+void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
+
+void Chunk::MakeModified() { m_isModified = true; }

SQCSim-common/chunk.h

@@ -0,0 +1,31 @@
+#ifndef CHUNK_H__
+#define CHUNK_H__
+#include "define.h"
+#include "array3d.h"
+#include "array2d.h"
+#include "blockinfo.h"
+#include "opensimplex.h"
+
+class World;
+
+class Chunk {
+    protected:
+        Array3d<BlockType> m_blocks = Array3d<BlockType>(CHUNK_SIZE_X, CHUNK_SIZE_Y, CHUNK_SIZE_Z);
+        bool m_isModified = false;
+
+        unsigned int m_posX; // Position du chunk dans l'array constituant le monde.
+        unsigned int m_posY;
+
+    public:
+        Chunk(unsigned int x, unsigned int y);
+        ~Chunk();
+
+        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 GetPosition(unsigned int& x, unsigned int& y) const;
+
+        void MakeModified();
+};
+
+#endif // CHUNK_H__

SQCSim-common/define.h

@@ -0,0 +1,56 @@
+#ifndef DEFINE_H__
+#define DEFINE_H__
+
+#include <iostream>
+#include <chrono>
+
+#define SRV_PORT 1025
+#define CLI_PORT 1026
+
+#define CHUNK_SIZE_X  4
+#define CHUNK_SIZE_Y  64
+#define CHUNK_SIZE_Z  4
+#define MAX_SELECTION_DISTANCE 5
+#define SEED 0
+#define COUNTDOWN 300
+
+#define WORLD_SIZE_X 64
+#define WORLD_SIZE_Y 64
+
+#define VIEW_DISTANCE 512
+#define TEXTURE_SIZE 512
+#define MAX_BULLETS 512
+
+typedef uint8_t BlockType;
+enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_LAST };
+typedef uint64_t Timestamp;
+
+#ifdef _WIN32
+
+#pragma comment(lib,"wsock32.lib") // Pour pouvoir faire fonctionner le linker sans le vcxproject
+#pragma comment(lib,"ws2_32.lib")
+#include <ws2tcpip.h>
+#include <Windows.h>
+#include <cstdio>
+#include <ctime>
+
+#define popen _popen
+#define pclose _pclose
+
+#else // Pas _WIN32
+
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#define SOCKET int
+#define INVALID_SOCKET -1
+#define closesocket close
+
+#endif // _WIN32
+
+
+#endif // DEFINE_H__

SQCSim-common/netprotocol.cpp

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

SQCSim-common/netprotocol.h

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

SQCSim-common/player.cpp

@@ -0,0 +1,176 @@
+#include "player.h"
+#include "world.h"
+
+Player::Player(const Vector3f& position, float rotX, float rotY) : m_position(position), m_rotX(rotX), m_rotY(rotY) {
+	m_velocity = Vector3f(0, 0, 0);
+	m_airborne = true;
+}
+
+void Player::TurnLeftRight(float value) {
+	m_rotY += value;
+	if (m_rotY > 360) m_rotY = 0;
+	else if (m_rotY < -360) m_rotY = 0;
+}
+
+void Player::TurnTopBottom(float value) {
+	m_rotX += value;
+	if (m_rotX > 80) m_rotX = 80;
+	else if (m_rotX < -80) m_rotX = -80;
+}
+
+Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
+
+	Vector3f delta = Vector3f(0, 0, 0);
+
+	float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
+	float xrotrad = (m_rotX / 57.2957795056f);
+
+	m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
+						   -sin(xrotrad),
+						   cos(xrotrad) * -cos(yrotrad));
+
+	m_direction.Normalize();
+
+	if (front) {
+		delta.x += float(sin(yrotrad)) * elapsedTime * 10.f;
+		delta.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
+	}
+	else if (back) {
+		delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
+		delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
+	}
+
+	if (left) {
+		delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
+		delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
+	}
+	else if (right) {
+		delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
+		delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
+	}
+
+	delta.Normalize();
+	delta.x *= .6f;
+	delta.z *= .6f;
+
+	if ((jump || shoot ) && !m_airborne) {
+		delta.y += jump? .32f: shoot? .1f : 0.f;
+		m_airborne = true;
+	}
+
+	if (shoot) // Recoil!
+		TurnTopBottom(-1);
+
+	return delta;
+}
+
+void Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
+	static float timing = 0.f;
+	/* Gestion de collisions */
+	BlockType bt1, bt2, bt3;
+
+	bt1 = world->BlockAt(GetPosition().x, GetPosition().y + input.y, GetPosition().z);
+	bt2 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 0.9f, GetPosition().z);
+	bt3 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 1.7f, GetPosition().z);
+	if ((bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) && m_position.y < 129.7f) {
+		bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
+		if (bt1 == BTYPE_AIR) m_position.y = (int)m_position.y + .7f;
+		m_velocity.y = input.y = 0;
+		m_airborne = false;
+	}
+	else {
+		if (abs(m_velocity.y) < 1.1f) m_velocity.y += input.y - 1.1f * elapsedTime;
+		bt3 = world->BlockAt(GetPosition().x, GetPosition().y + m_velocity.y - 1.7f, GetPosition().z);
+		bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
+		if (bt3 != BTYPE_AIR) {
+			m_velocity.y = 0;
+			if (timing == 0.f) {
+				timing = .3f;
+			}
+			m_airborne = false;
+		}
+		else if (bt1 != BTYPE_AIR) {
+			m_velocity.y = -.1f;
+		}
+		else m_airborne = true;
+	}
+
+	if (timing > 0.f) timing -= elapsedTime;
+	if (timing < 0.f) timing = 0.f;
+
+	bt1 = world->BlockAt(GetPosition().x + input.x, GetPosition().y, GetPosition().z);
+	bt2 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 0.9f, GetPosition().z);
+	bt3 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 1.7f, GetPosition().z);
+	if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
+		if (input.x > 0)
+			input.x = m_velocity.x = 0.5f;
+		else
+			input.x = m_velocity.x = -0.5f;
+		m_velocity.y = 0.3;
+		m_velocity.z *= .5f;
+	}
+	else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+		input.x = m_velocity.x = 0;
+		m_velocity.z *= .5f;
+	}
+
+	bt1 = world->BlockAt(GetPosition().x, GetPosition().y, GetPosition().z + input.z);
+	bt2 = world->BlockAt(GetPosition().x, GetPosition().y - 0.9f, GetPosition().z + input.z);
+	bt3 = world->BlockAt(GetPosition().x, GetPosition().y - 1.7f, GetPosition().z + input.z);
+	if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
+		if (input.z > 0)
+			input.z = m_velocity.z = 0.5f;
+		else
+			input.z = m_velocity.z = -0.5f;
+		m_velocity.y = 0.3;
+		m_velocity.x *= .5f;
+	}
+	else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
+		input.z = m_velocity.z = 0;
+		m_velocity.x *= .5f;
+	}
+
+	/* Fin gestion de collisions */
+	/* Gestion de la friction */
+
+	if (!m_airborne) {
+		m_velocity.x += input.x * 2.f * elapsedTime;
+		m_velocity.z += input.z * 2.f * elapsedTime;
+
+		if (input.x == 0.f) 
+			m_velocity.x *= .8f;
+		
+		if (input.z == 0.f) 
+			m_velocity.z *= .8f;
+	}
+	else {
+		m_velocity.x += input.x * .4f * elapsedTime; // Techniquement contre les lois de la physique, mais c'est beaucoup moins chiant pour grimper sur les blocs.
+		m_velocity.z += input.z * .4f * elapsedTime;
+		m_velocity.x *= .99f;
+		m_velocity.z *= .99f;
+	}
+
+	/* Fin gestion de la friction */
+
+	float vy = m_velocity.y;
+	m_velocity.y = 1.f; // Padding pour limiter le x et z lors du Normalize().
+	if (m_velocity.Length() >= 1.f) m_velocity.Normalize(); // Limiteur de vitesse en x/z.
+	m_velocity.y = 0;
+	if (m_velocity.Length() < .005f) m_velocity.Zero(); // Threshold en x/z.
+	m_velocity.y = vy;
+
+	m_position += m_velocity;
+}
+
+Vector3f Player::GetPosition() const { return Vector3f(m_position.x + CHUNK_SIZE_X * WORLD_SIZE_X / 2, m_position.y, m_position.z + CHUNK_SIZE_Z * WORLD_SIZE_Y / 2); }
+
+Vector3f Player::GetVelocity() const { return m_velocity; }
+
+Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }
+
+Vector3f Player::GetDirection() const { return m_direction; }
+
+void Player::Teleport(int& x, int& z) {
+	m_position.x -= x * CHUNK_SIZE_X;
+	m_position.z -= z * CHUNK_SIZE_Z;
+}

SQCSim-common/player.h

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

SQCSim-common/world.cpp

@@ -0,0 +1,109 @@
+#include "world.h"
+
+World::World() {}
+
+World::~World() {}
+
+Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
+
+Chunk* World::ChunkAt(float x, float y, float z) const {
+	int cx = (int)x / CHUNK_SIZE_X;
+	int cz = (int)z / CHUNK_SIZE_Z;
+
+	if (x < 0 || y < 0 || z < 0 ||
+		x >= WORLD_SIZE_X * CHUNK_SIZE_X ||
+		z >= CHUNK_SIZE_Z * WORLD_SIZE_Y ||
+		y > CHUNK_SIZE_Y)
+		return 0;
+
+	return m_chunks.Get(cx, cz);
+}
+
+Chunk* World::ChunkAt(const Vector3f& pos) const { return ChunkAt(pos.x, pos.y, pos.z); }
+
+BlockType World::BlockAt(float x, float y, float z, BlockType defaultBlockType) const {
+	Chunk* c = ChunkAt(x, y, z);
+
+	if (!c)
+		return defaultBlockType;
+
+	int bx = (int)x % CHUNK_SIZE_X;
+	int by = (int)y % CHUNK_SIZE_Y;
+	int bz = (int)z % CHUNK_SIZE_Z;
+
+	return c->GetBlock(bx, by, bz);
+}
+
+BlockType World::BlockAt(const Vector3f& pos, BlockType defaultBlockType) const {
+	return BlockAt(pos.x, pos.y, pos.z, defaultBlockType);
+}
+
+void World::GetScope(unsigned int& x, unsigned int& y) {
+	x = m_center[0];
+	y = m_center[1];
+}
+
+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);
+}
+
+void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block) {
+	Vector3f currentPos = player.GetPosition();
+	Vector3f currentBlock = currentPos;
+	Vector3f ray = player.GetDirection();
+	bool found = false;
+
+	if (block) return;
+
+	while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
+		currentBlock += ray / 10.f;
+
+		BlockType bt = BlockAt(currentBlock);
+
+		if (bt != BTYPE_AIR)
+			found = true;
+	}
+
+	if (found)
+		if (blockType != BTYPE_AIR) {
+			found = false;
+			while ((currentPos - currentBlock).Length() >= 1.7f && !found) {
+				currentBlock -= ray / 10.f;
+
+				BlockType bt = BlockAt(currentBlock);
+
+				if (bt == BTYPE_AIR) { // V?rification pour ?tre s?r que le bloc ? 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;
+	}
+}

SQCSim-common/world.h

@@ -0,0 +1,45 @@
+#ifndef WORLD_H__
+#define WORLD_H__
+#include <fstream>
+#include <string>
+#include <vector>
+#include <future>
+#include <thread>
+#include "define.h"
+#include "chunk.h"
+#include "array2d.h"
+#include "vector3.h"
+#include "player.h"
+#include "bullet.h"
+
+class Chunk;
+class Player;
+class Bullet;
+
+class World {
+public:
+	World();
+	~World();
+
+	Array2d<Chunk*>& GetChunks();
+
+	Chunk* ChunkAt(float x, float y, float z) const;
+	Chunk* ChunkAt(const Vector3f& pos) const;
+
+	BlockType BlockAt(float x, float y, float z, BlockType defaultBlockType = BTYPE_AIR) const;
+	BlockType BlockAt(const Vector3f& pos, BlockType defaultBlockType = BTYPE_AIR) const;
+
+	void GetScope(unsigned int& x, unsigned int& y);
+
+	void ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block);
+	void ChangeBlockAtPosition(BlockType blockType, Vector3f pos);
+
+private:
+	Array2d<Chunk*> m_chunks = Array2d<Chunk*>(WORLD_SIZE_X, WORLD_SIZE_Y);
+	std::vector<Chunk*> m_tbDeleted;
+
+	unsigned int m_center[2] = { UINT16_MAX / 2 - WORLD_SIZE_X, UINT16_MAX / 2 - WORLD_SIZE_Y };
+
+};
+#endif // WORLD_H__
+

SQCSim-srv/SQCSim-srv.vcxproj

@@ -0,0 +1,148 @@
+<?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>
+    </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>Default</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>
+    </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>
+    </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>

SQCSim-srv/SQCSim-srv.vcxproj.filters

@@ -0,0 +1,39 @@
+<?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>

SQCSim-srv/connection.cpp

@@ -0,0 +1,54 @@
+#include "connection.h"
+
+
+
+Connection::Connection(SOCKET sock, 
+					   sockaddr_in sockaddr, 
+					   netprot::LoginInfo log, 
+					   netprot::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(netprot::Input in) {
+	m_input_manifest.insert({ in.timestamp, in });
+}
+
+netprot::Output* Connection::getOutput(Timestamp time) {
+	auto out = m_output_manifest.find(time);
+	if (out != m_output_manifest.end())
+		return &out->second;
+	return nullptr;
+}
+
+netprot::Sync Connection::getSync(Timestamp time) {
+	netprot::Sync sync;
+	auto out = m_output_manifest.find(time);
+	if (out != m_output_manifest.end()) {
+		sync.timestamp = out->second.timestamp;
+		sync.position = out->second.position;
+		sync.sid = m_loginfo.sid;
+	}
+	return sync;
+}
+
+void Connection::CleanInputManifest(Timestamp time) {
+	auto wat = m_input_manifest.find(time);
+
+	while (wat != m_input_manifest.begin())
+		m_input_manifest.erase(wat--);
+	
+}

SQCSim-srv/connection.h

@@ -0,0 +1,41 @@
+#ifndef CONNECTION_H__
+#define CONNECTION_H__
+#include <deque>
+#include <map>
+#include "../SQCSim-common/player.h"
+#include "../SQCSim-common/vector3.h"
+#include "../SQCSim-common/netprotocol.h"
+#include "define.h"
+
+class Connection {
+public:
+	Connection(
+		SOCKET sock,
+		sockaddr_in sockaddr,
+		netprot::LoginInfo log,
+		netprot::PlayerInfo play);
+	~Connection();
+
+	Player* player = nullptr;
+
+	uint64_t GetHash(bool self = true) const;
+	uint64_t GetTeamHash() const;
+	std::string GetName() const;
+
+	void AddInput(netprot::Input in);
+	netprot::Output* getOutput(Timestamp time);
+	netprot::Sync getSync(Timestamp time);
+
+	void CleanInputManifest(Timestamp time);
+private:
+	std::map<Timestamp, netprot::Input> m_input_manifest;
+	std::map<Timestamp, netprot::Output> m_output_manifest;
+	std::map<Timestamp, netprot::Chat> m_chatlog;
+
+	SOCKET m_sock;
+	sockaddr_in m_addr;
+	netprot::LoginInfo m_loginfo;
+	netprot::PlayerInfo m_playinfo;
+
+};
+#endif

SQCSim-srv/define.h

@@ -0,0 +1,17 @@
+#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 BUFFER_LENGTH 150
+
+typedef unsigned char LogDest;
+enum LOG_DEST { CONSOLE, LOGFILE, LOG_LAST };
+
+#endif

SQCSim-srv/main.cpp

@@ -0,0 +1,9 @@
+#include "server.h"
+
+int main() {
+	Server* server = new Server();
+	if (server->Init() == 0)
+		if (server->Ready() == 0)
+			server->Run();
+	delete server;
+}

SQCSim-srv/server.cpp

@@ -0,0 +1,327 @@
+#include "server.h"
+
+Server::Server(LogDest 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);
+#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() {
+	if (listen(m_sock_tcp, MAX_CONNECTIONS) < 0) {
+		Log("<EFBFBD>coute sur le port TCP.", true, true);
+		return 1;
+	}
+
+	char* buf = new char[150];
+	uint32_t buflen = 150;
+	bool readystart = false;
+	srand(time(NULL));
+
+	Log("<EFBFBD> l'<27>coute sur le port: " + std::to_string(SRV_PORT), false, false);
+
+	buildIdList(ID_LIST_SIZE);
+
+	m_game.countdown = 360;
+	m_game.gameType = 1;
+	m_game.seed = 9370707;
+
+	while (!readystart) {
+		sockaddr_in sockad;
+		int addrlen = sizeof(sockad);
+		SOCKET sock = accept(m_sock_tcp, (sockaddr*)&sockad, &addrlen);
+
+		if (sock < 0)
+			Log("Erreur de connexion", true, false);
+		else if (sock > 0) {
+			std::string str = "Nouvelle connection provenant de: ";
+			char* strbuf = new char[BUFFER_LENGTH];
+			uint32_t strbuflen = BUFFER_LENGTH;
+
+			str.append(inet_ntop(AF_INET, &sockad.sin_addr, strbuf, strbuflen)).append(": ").append(std::to_string(sockad.sin_port));
+
+			if (recv(sock, buf, buflen, 0) > 0) {
+				netprot::LoginInfo log;
+				netprot::PlayerInfo play;
+				if (netprot::Deserialize(&log, buf, buflen)) {
+					log.sid = getUniqueId();
+
+					log.tid = 0;
+
+					str.append(" Nom: ").append(log.name); 
+					Log(str, false, false);
+					str = "";
+					
+					str.append(log.name).append(" SID: [").append(std::to_string(log.sid).append("]"));
+					Log(str, false, false);
+
+					//netprot::Serialize(&log, &buf, &buflen);
+					//send(sock, buf, buflen, 0);
+					//buflen = 150;
+					sendPack<netprot::LoginInfo>(sock, &log, &buf, &buflen);
+
+					play.id = getUniqueId();
+					memcpy(play.name, log.name, std::strlen(log.name) + 1);
+					play.tid = log.tid;
+
+					//netprot::Serialize(&m_game, &buf, &buflen);
+					//send(sock, buf, buflen, 0);
+					sendPack<netprot::GameInfo>(sock, &m_game, &buf, &buflen);
+					Connection* conn = new Connection(sock, sockad, log, play);
+
+					m_players[log.sid] = conn;
+					readystart = true;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+void Server::Run() {
+
+	Log("Partie en cours...", false, false);
+}
+
+inline std::string Server::Timestamp() {
+	time_t rawtime;
+	struct tm timeinfo;
+	char buffer[80];
+
+	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) {
+	case LOG_DEST::LOGFILE:
+		m_logfile << Timestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
+		break;
+	case LOG_DEST::CONSOLE:
+	default:
+		std::cout << Timestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
+		break;
+	}
+
+	if (is_fatal) {
+		if (m_sock_udp)
+			closesocket(m_sock_udp);
+		if (m_sock_tcp)
+			closesocket(m_sock_tcp);
+#ifdef _WIN32
+		WSACleanup();
+#endif
+	}
+}
+
+void Server::buildIdList(size_t size) {
+	std::set<uint64_t> lst;
+
+	do lst.insert(((uint64_t)rand() << 25) % 8675309); // EIGHT SIX SEVENFIVE THREE AUGHT NIIIIIIiIIiiIiINE!
+	while (lst.size() < size);
+	
+	m_ids = std::vector<uint64_t>(lst.begin(), lst.end());
+}
+
+uint64_t Server::getUniqueId() {
+	uint64_t id = m_ids.back();
+	m_ids.pop_back();
+	return id;
+}
+
+// Test serialize/deserialize:
+/*
+	netprot::LoginInfo log, log2;
+	std::cout << "Nom? ";
+	std::cin.getline(log.name, 32); // NO! STD::CIN >> VARIABLE;! EVEEEEEERRRR!!!
+	log.sid = 12345;
+	char* buf = new char[150];
+	uint32_t buflen = 150;
+
+	netprot::Serialize(&log, &buf, &buflen);
+
+	bool is_work = netprot::Deserialize(&log2, buf, buflen);
+
+	std::string str;
+	str.append(is_work ? "Y " : "N ").append(log2.name).append(": ").append(std::to_string(log2.sid));
+
+	Log(str, false, false);
+*/
+
+
+///* Recevoir paquet */
+//while (true) {
+//	char buffer[2048];
+//	sockaddr_in client;
+//
+//#ifdef _WIN32 // Mais pourquoi?
+//	int clen = sizeof(client);
+//#else
+//	unsigned int clen = sizeof(client);
+//#endif
+//
+//	int count = recvfrom(socket_udp, buffer, sizeof(buffer) - 1, 0, (sockaddr*)&client, &clen);
+//
+//	if (count < 0) {
+//		Log("Erreur de reception de paquet.", socket_udp);
+//		return 4;
+//	}
+//
+//	buffer[count] = '\0';
+//
+//	/* G<>rer le paquet re<72>u */
+//	std::string commande(buffer);
+//
+//	if (commande.find("echo ") == 0) {													/*		ECHO		*/
+//		std::string::size_type pos = commande.find(' ');
+//		std::string parametres = commande.substr(pos + 1);
+//
+//		sendto(socket_udp, parametres.c_str(), parametres.length(), 0, (const sockaddr*)&client, sizeof(client));
+//	}
+//	else if (commande.find("date ") == 0) {												/*		DATE		*/
+//		time_t rawtime;
+//		struct tm* timeinfo = new tm();
+//		char tbuffer[80];
+//
+//		time(&rawtime);
+//
+//#ifdef _WIN32
+//		localtime_s(timeinfo, &rawtime);
+//#else
+//		localtime_r(&rawtime, timeinfo);
+//#endif
+//
+//		strftime(tbuffer, 80, "%a %b %e %T %G", timeinfo);
+//
+//		sendto(socket_udp, tbuffer, sizeof(tbuffer), 0, (const sockaddr*)&client, sizeof(client));
+//		delete timeinfo;
+//	}
+//	else if (commande.find("ping ") == 0) {												/*		PING		*/
+//		sendto(socket_udp, "pong", sizeof("pong"), 0, (const sockaddr*)&client, sizeof(client));
+//	}
+//	else if (commande.find("usager ") == 0) {											/*		USAGER		*/
+//		std::string user;
+//
+//#ifdef _WIN32
+//		wchar_t userbuf[30];
+//		DWORD usersize = 30;
+//
+//		GetUserNameW(userbuf, &usersize);
+//
+//		std::wstring wuser = userbuf;
+//		user = std::string(wuser.begin(), wuser.end());
+//#else
+//		char ptr[30];
+//		getlogin_r(ptr, sizeof(ptr) - 1);
+//		user = std::string(ptr);
+//#endif
+//
+//		sendto(socket_udp, user.c_str(), user.length(), 0, (const sockaddr*)&client, sizeof(client));
+//	}
+//	else if (commande.find("exec ") == 0) {												/*		EXEC		*/
+//		std::string::size_type pos = commande.find(' ');
+//		std::string parametres = commande.substr(pos + 1);
+//
+//		FILE* pipe = nullptr;
+//		char buffer[301]; // 300 caract<63>res + '\0'
+//		std::string reponse;
+//
+//		pipe = popen(parametres.c_str(), "r");
+//
+//		if (!pipe)
+//			reponse = "Erreur de commande!";
+//		else while (!feof(pipe)) {
+//			if (fgets(buffer, sizeof(buffer) - 1, pipe))
+//				reponse += buffer;
+//		}
+//
+//		if (pipe)
+//			pclose(pipe);
+//
+//		if (reponse.length() > 300)
+//			reponse = reponse.substr(0, 300);
+//		else if (reponse.length() < 1)
+//			reponse = "OK!";
+//
+//		sendto(socket_udp, reponse.c_str(), reponse.length(), 0, (const sockaddr*)&client, sizeof(client));
+//	}
+//	else if (commande.find("bye ") == 0) {											/*		BYE			*/
+//		Log("", 0); // Message d'erreur pas de message d'erreur!
+//		return 0;
+//	}
+//	else sendto(socket_udp, "huh?", sizeof("huh?"), 0, (const sockaddr*)&client, sizeof(client));		/*			DEFAULT			 */
+//}
+//
+///* Ce bout de code ne devrait theoriquement jamais etre atteint, mais au cas. */
+//Log("", 0);
+//return 0;
+//return false;
+//}
+//

SQCSim-srv/server.h

@@ -0,0 +1,54 @@
+#ifndef SERVER_H__
+#define SERVER_H__
+
+#include <fstream>
+#include <vector>
+#include <set>
+#include <string>
+#include "../SQCSim-common/world.h"
+#include "../SQCSim-common/netprotocol.h"
+#include "define.h"
+#include "connection.h"
+
+class Server {
+public:
+	Server(LogDest 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;
+	LogDest m_log;
+	std::ofstream m_logfile;
+
+	std::map<uint64_t, Connection*> m_players;
+	std::map <Timestamp, netprot::Chat> m_chatlog;
+	std::vector<uint64_t> m_ids;
+	netprot::GameInfo m_game;
+
+	World* m_world = nullptr;
+
+	std::string Timestamp();
+	void Log(std::string str, bool is_error, bool is_fatal);
+	void buildIdList(size_t size);
+
+	uint64_t getUniqueId(); 
+	template <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
+
+};
+
+template <class T>
+void Server::sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) {
+	netprot::Serialize(pack, buf, buflen);
+	send(sock, *buf, *buflen, 0);
+	*buflen = BUFFER_LENGTH;
+}
+
+#endif

SQCSim2021/SQCSim2021.vcxproj

@@ -19,17 +19,12 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="array2d.h" />
-    <ClInclude Include="array3d.h" />
     <ClInclude Include="audio.h" />
-    <ClInclude Include="blockinfo.h" />
-    <ClInclude Include="bullet.h" />
     <ClInclude Include="chunk.h" />
+    <ClInclude Include="connector.h" />
     <ClInclude Include="define.h" />
     <ClInclude Include="engine.h" />
-    <ClInclude Include="matrix4.h" />
     <ClInclude Include="openglcontext.h" />
-    <ClInclude Include="opensimplex.h" />
     <ClInclude Include="player.h" />
     <ClInclude Include="shader.h" />
     <ClInclude Include="skybox.h" />
@@ -37,19 +32,16 @@
     <ClInclude Include="textureatlas.h" />
     <ClInclude Include="tool.h" />
     <ClInclude Include="transformation.h" />
-    <ClInclude Include="vector3.h" />
     <ClInclude Include="vertexbuffer.h" />
     <ClInclude Include="world.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="audio.cpp" />
-    <ClCompile Include="blockinfo.cpp" />
-    <ClCompile Include="bullet.cpp" />
     <ClCompile Include="chunk.cpp" />
+    <ClCompile Include="connector.cpp" />
     <ClCompile Include="engine.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="openglcontext.cpp" />
-    <ClCompile Include="opensimplex.cpp" />
     <ClCompile Include="player.cpp" />
     <ClCompile Include="shader.cpp" />
     <ClCompile Include="skybox.cpp" />
@@ -60,6 +52,11 @@
     <ClCompile Include="vertexbuffer.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>
     <Keyword>Win32Proj</Keyword>
@@ -112,8 +109,8 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>external\irrKlang-1.6.0\include;external\glew170\include;external\devil178\include;external\sfml23\include;$(IncludePath)</IncludePath>
-    <LibraryPath>external\glew170\lib;external\devil178\lib;external\sfml23\lib;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
+    <IncludePath>external\irrKlang-1.6.0\include;external\glew210\include;external\devil178\include;external\sfml251\include;$(IncludePath)</IncludePath>
+    <LibraryPath>external\glew210\lib;external\sfml251\lib;external\devil178\lib;external\irrKlang-1.6.0\lib\Win32-visualStudio;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
@@ -122,8 +119,8 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>external\irrKlang-1.6.0\include;external\sfml23\include;external\devil178\include;external\glew170\include;$(IncludePath)</IncludePath>
-    <LibraryPath>external\sfml23\lib;external\devil178\lib;external\glew170\lib;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
+    <IncludePath>external\devil180\include;external\irrKlang-1.6.0\include;external\sfml251\include;external\glew210\include;$(IncludePath)</IncludePath>
+    <LibraryPath>external\sfml251\lib;external\devil180\lib\x86\Release;external\glew210\lib\Release\Win32;$(LibraryPath);external\irrKlang-1.6.0\lib\Win32-visualStudio</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>

SQCSim2021/SQCSim2021.vcxproj.filters

@@ -11,12 +11,6 @@
     </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>
@@ -26,36 +20,21 @@
     <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>
@@ -68,17 +47,17 @@
     <ClInclude Include="world.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="bullet.h">
+    <ClInclude Include="connector.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="opensimplex.h">
+    <ClInclude Include="openglcontext.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
+    <ClInclude Include="tool.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>
@@ -103,9 +82,6 @@
     <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>
@@ -121,10 +97,10 @@
     <ClCompile Include="world.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="bullet.cpp">
+    <ClCompile Include="connector.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="opensimplex.cpp">
+    <ClCompile Include="tool.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
   </ItemGroup>

SQCSim2021/audio.cpp

@@ -14,7 +14,7 @@ Audio::Audio(const char * music) {
 	m_engine->setRolloffFactor(1);
 	m_engine->setDefault3DSoundMinDistance(1);
 	m_engine->setDefault3DSoundMaxDistance(1000);
-	m_music = m_engine->play2D(music, true, true, true, irrklang::ESM_STREAMING);
+	m_music = m_engine->play2D(music, false, true, true, irrklang::ESM_STREAMING);
 }
 
 Audio::~Audio() { 
@@ -40,9 +40,9 @@ void Audio::Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& v
 	sound->setVolume(volume);
 }
 
-void Audio::PlaySong(const char* music) {
-	m_music = m_engine->play2D(music, true, true, true, irrklang::ESM_STREAMING);
-}
+//void Audio::PlaySong(const char* music) {
+//	m_music = m_engine->play2D(music, false, false, false, irrklang::ESM_STREAMING);
+//}
 
 void Audio::ToggleMusicState() { m_music->setIsPaused(!m_music->getIsPaused()); }
 

SQCSim2021/audio.h

@@ -4,7 +4,7 @@
 #include <irrKlang.h>
 #include <ik_ISoundSource.h>
 #include "define.h"
-#include "vector3.h"
+#include "../SQCSim-common/vector3.h"
 
 class Audio {
 private:
@@ -22,7 +22,7 @@ public:
 
 	void Render3DAudioObj(irrklang::ISound* sound, Vector3f& pos, Vector3f& vel, float volume);
 
-	void PlaySong(const char* music);
+	//void PlaySong(const char* music);
 
 	void ToggleMusicState();
 

SQCSim2021/bullet.h

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

SQCSim2021/chunk.cpp

@@ -1,13 +1,13 @@
 #include "chunk.h"
 #include "world.h"
 
-Chunk::Chunk(unsigned int x, unsigned int y) : m_posX(x), m_posY(y) { 
+Chunk::Chunk(unsigned int x, unsigned int y, int64_t seed) : m_posX(x), m_posY(y) { 
     //std::ostringstream pos; // V<>rifie l'existence d'un fichier .chunk avec sa position.
     //pos << CHUNK_PATH << x << '_' << y << ".chunk";
     //std::ifstream input(pos.str(), std::fstream::binary);
 
     //if (input.fail()) {
-        OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(SEED);
+        OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(seed);
         m_blocks.Reset(BTYPE_AIR);
 
         for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Montagnes

SQCSim2021/chunk.h

@@ -1,11 +1,11 @@
 #ifndef CHUNK_H__
 #define CHUNK_H__
 #include "define.h"
-#include "array3d.h"
-#include "array2d.h"
+#include "../SQCSim-common/array2d.h"
+#include "../SQCSim-common/array3d.h"
+#include "../SQCSim-common/blockinfo.h"
+#include "../SQCSim-common/opensimplex.h"
 #include "vertexbuffer.h"
-#include "blockinfo.h"
-#include "opensimplex.h"
 
 class World;
 
@@ -25,7 +25,7 @@ class Chunk {
         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(unsigned int x, unsigned int y, int64_t seed);
         ~Chunk();
 
         void RemoveBlock(int x, int y, int z, World* world);

SQCSim2021/connector.cpp

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

SQCSim2021/connector.h

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

SQCSim2021/define.h

@@ -1,65 +1,33 @@
-#ifndef DEFINE_H__
-#define DEFINE_H__
+#ifndef CLI_DEFINE_H__
+#define CLI_DEFINE_H__
 
+#include <iostream>
+#include <chrono>
+#include <iomanip>
 #include <SFML/Window.hpp>
 #include <SFML/Graphics.hpp>
-#include <iostream>
+#include "../SQCSim-common/define.h"
 
 #ifdef _WIN32
-#include <windows.h>
 #include <GL/glew.h>
 #include <gl/GL.h>
 #include <gl/GLU.h>
 #endif
 
-#define CHUNK_SIZE_X  16
-#define CHUNK_SIZE_Y  128
-#define CHUNK_SIZE_Z  16
-#define MAX_SELECTION_DISTANCE 5
-#define SEED 12345
-
-#ifdef _DEBUG
-#define WORLD_SIZE_X 64
-#define WORLD_SIZE_Y 64
-
-#define FRAMES_RENDER_CHUNKS 4
-#define FRAMES_UPDATE_CHUNKS 4
-#define FRAMES_DELETE_CHUNKS 4
-
-#define THREADS_GENERATE_CHUNKS 1
-#define THREADS_UPDATE_CHUNKS 1
-#define THREADS_DELETE_CHUNKS 1
-
-#define VIEW_DISTANCE 256
-#define TEXTURE_SIZE 128
-#define MAX_BULLETS 64
-#endif
-
-#ifdef NDEBUG
-#define WORLD_SIZE_X 16
-#define WORLD_SIZE_Y 16
+#define NETWORK_TEST false
+#define SRV_ADDR "127.0.0.1"
+#define COUNTDOWN 300
 
 #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 THREADS_GENERATE_CHUNKS 8
+#define THREADS_UPDATE_CHUNKS 3
+#define THREADS_DELETE_CHUNKS 3
 
-#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 };
-
-//#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 BASE_WIDTH 640
+#define BASE_HEIGHT 480
 
 #define TEXTURE_PATH        "./media/textures/"
 #define SHADER_PATH		    "./media/shaders/"

SQCSim2021/engine.cpp

@@ -1,12 +1,8 @@
 #include "engine.h"
-#include <algorithm>
-#include <cmath>
-#include "transformation.h"
-#include "player.h"
 
-Engine::Engine() { }
+Engine::Engine() {}
 
-Engine::~Engine() { 
+Engine::~Engine() {
 	m_world.CleanUpWorld(m_renderCount, true);
 	for (int x = 0; x < WORLD_SIZE_X; ++x)
 		for (int y = 0; y < WORLD_SIZE_Y; ++y)
@@ -21,34 +17,52 @@ void Engine::Init() {
 		abort();
 	}
 
-	glDisable(GL_FRAMEBUFFER_SRGB);
-	glClearColor(0.f, 0.f, 0.f, 1.f);
+	//glDisable(GL_FRAMEBUFFER_SRGB);
+	//glEnable(GL_DEPTH_TEST);
+	//glEnable(GL_STENCIL_TEST);
+	//glEnable(GL_POINT_SMOOTH);
+	//glEnable(GL_BLEND);
+	glEnable(GL_CULL_FACE);
 	glEnable(GL_TEXTURE_2D);
+
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
+
 	gluPerspective(45.0f, (float)Width() / (float)Height(), 0.1f, VIEW_DISTANCE);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_STENCIL_TEST);
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 	glShadeModel(GL_SMOOTH);
-	
-	glEnable(GL_POINT_SMOOTH);
-	glEnable(GL_CULL_FACE);
-
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
-	glBlendEquation(GL_FUNC_SUBTRACT);
 
+	//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+	//glDisable(GL_BLEND);
+	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	//glBlendEquation(GL_FUNC_SUBTRACT);
+	// 
 	// Objet de skybox avec sa propre texture et son propre shader!
 	m_skybox.Init(0.2f);
 
 	// Objet de musique!
-	m_audio.ToggleMusicState();
+	//m_audio.ToggleMusicState();
 
 	// Array pour les balles.
 	for (int x = 0; x < MAX_BULLETS; ++x)
 		m_bullets[x] = nullptr;
 
+	uint64_t seed = SEED;
+	std::string playname = "La Chienne <20> Jacques";
+	if (NETWORK_TEST) { // Test connexion r<>seau.
+		if (!m_conn.Init()) {
+			if (!m_conn.Connect(SRV_ADDR, playname)) {
+				// setup jeu en r<>seau.
+				std::cout << "ID re<72>u du serveur: " << std::to_string(m_conn.getId()) << "!" << std::endl;
+				std::cout << "Seed re<72>u du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl;
+				seed = m_conn.getSeed();
+			}
+			else std::cout << "Erreur de connexion." << std::endl;
+		}
+		else std::cout << "Erreur de cr<63>ation de socket." << std::endl;
+	}
+
+	m_world.SetSeed(seed);
+
 	// Init Chunks
 	m_world.GetChunks().Reset(nullptr);
 
@@ -57,12 +71,14 @@ void Engine::Init() {
 	HideCursor();
 }
 
-void Engine::DeInit() { }
+void Engine::DeInit() {}
 
 void Engine::LoadResource() {
-	LoadTexture(m_skybox.GetTexture(), TEXTURE_PATH "skybox.png");
-	LoadTexture(m_textureCrosshair, TEXTURE_PATH "cross.bmp");
-	LoadTexture(m_textureFont, TEXTURE_PATH "font.bmp");
+	LoadTexture(m_skybox.GetTexture(), TEXTURE_PATH "skybox.png", true);
+	LoadTexture(m_textureCrosshair, TEXTURE_PATH "cross.bmp", true);
+	LoadTexture(m_textureFont, TEXTURE_PATH "font.bmp", true);
+	LoadTexture(m_textureGun, TEXTURE_PATH "gun01.png", false);
+
 	TextureAtlas::TextureIndex texDirtIndex = m_textureAtlas.AddTexture(TEXTURE_PATH "metal3.png");
 	TextureAtlas::TextureIndex texIceIndex = m_textureAtlas.AddTexture(TEXTURE_PATH "metal2.png");
 	TextureAtlas::TextureIndex texGrassIndex = m_textureAtlas.AddTexture(TEXTURE_PATH "grass.png");
@@ -97,92 +113,220 @@ void Engine::LoadResource() {
 
 void Engine::UnloadResource() {}
 
-void Engine::DrawHud(float elapsedTime, BlockType bloc) {
-	// Setter le blend function , tout ce qui sera noir sera transparent
-	glDisable(GL_STENCIL_TEST);
-	glColor4f(1.f, 1.f, 1.f, 1.f);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-	glBlendEquation(GL_FUNC_ADD);
-	glDisable(GL_DEPTH_TEST);
-	glMatrixMode(GL_PROJECTION);
-	glPushMatrix();
-	glLoadIdentity();
-	glOrtho(0, Width(), 0, Height(), -1, 1);
-	glMatrixMode(GL_MODELVIEW);
-	glPushMatrix();
-
-	// Bind de la texture pour le font
-	m_textureFont.Bind();
-	std::ostringstream ss;
-	ss << " Fps : " << GetFps(elapsedTime);
-	PrintText(10, Height() - 25, ss.str());
-	ss.str("");
-	ss << " Rendered Chunks : " << m_renderCount;
-	PrintText(10, Height() - 35, ss.str());
-	ss.str("");
-	ss << " To-Be-Deleted Chunks : " << m_world.GettbDeleted();
-	PrintText(10, Height() - 45, ss.str());
-	ss.str("");
-	ss << " Velocity  : " << m_player.GetVelocity(); // IMPORTANT : on utilise l <20> operateur << pour afficher la position
-	PrintText(10, 10, ss.str());
-	ss.str("");
-	ss << " Direction : " << m_player.GetDirection();
-	PrintText(10, 20, ss.str());
-	ss.str("");
-	ss << " Position  : " << m_player.GetPosition();
-	PrintText(10, 30, ss.str());
-	ss.str("");
-	ss << " Block  : ";
-	if (bloc == BTYPE_LAST)
-		ss << "Weapon.";
-	else ss << (int)bloc;
-	PrintText(10, 40, ss.str());
+void Engine::DisplayCrosshair() {
 	m_textureCrosshair.Bind();
 	static const int crossSize = 32;
 	glLoadIdentity();
 	glTranslated(Width() / 2 - crossSize / 2, Height() / 2 - crossSize / 2, 0);
 	glBegin(GL_QUADS);
-	glTexCoord2f(0, 0);
-	glVertex2i(0, 0);
-	glTexCoord2f(1, 0);
-	glVertex2i(crossSize, 0);
-	glTexCoord2f(1, 1);
-	glVertex2i(crossSize, crossSize);
-	glTexCoord2f(0, 1);
-	glVertex2i(0, crossSize);
+		glTexCoord2f(0, 0);
+		glVertex2i(0, 0);
+		glTexCoord2f(1, 0);
+		glVertex2i(crossSize, 0);
+		glTexCoord2f(1, 1);
+		glVertex2i(crossSize, crossSize);
+		glTexCoord2f(0, 1);
+		glVertex2i(0, crossSize);
 	glEnd();
+}
+
+void Engine::DisplayCurrentItem() {
+}
+
+void Engine::DisplayHud(int timer) {
+	glBindTexture(GL_TEXTURE_2D, 0);
+	glLoadIdentity();
+	glDisable(GL_BLEND);
+
+	// Barre HP
+	float fBarWidth = Width() / 4;
+	float fBarHeight = Height() / 25;
+	float fPosX = Width() / 20;
+	float fPosY = Height() - (Height() - (fBarHeight * 4));
+	float playerHp = m_player.GetHP();
+	float facteurOmbrage = m_displayInfo ? 0.5f : 1.0f;
+
+	// Arri<72>re-plan (Barre HP)
+	glColor3f(1.0f * facteurOmbrage, 1.0f * facteurOmbrage, 1.0f * facteurOmbrage);
+	glBegin(GL_QUADS);
+		glVertex2f(fPosX, fPosY - fBarHeight);				// Bas-Gauche
+		glVertex2f(fPosX + fBarWidth, fPosY - fBarHeight);  // Bas-Droite
+		glVertex2f(fPosX + fBarWidth, fPosY);				// Haut-Droite
+		glVertex2f(fPosX, fPosY);							// Haut-Gauche
+	glEnd();
+
+	//TODO: Associer avec m<>chanique de vie du joueur
+
+	// Barre HP
+	glColor3f(0.0f * facteurOmbrage, 1.0f * facteurOmbrage, 0.0f * facteurOmbrage);
+	glBegin(GL_QUADS);
+		glVertex2f(fPosX, fPosY - fBarHeight);							// Bas-Gauche
+		glVertex2f(fPosX + fBarWidth * playerHp, fPosY - fBarHeight);	// Bas-Droite
+		glVertex2f(fPosX + fBarWidth * playerHp, fPosY);				// Haut-Droite
+		glVertex2f(fPosX, fPosY);										// Haut-Gauche
+	glEnd();
+
+	// Barre <20>quip
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glColor3f(1.0f * facteurOmbrage, 1.0f * facteurOmbrage, 1.0f * facteurOmbrage);
+	m_textureGun.Bind();
+
+	float margin = Width() * 0.05;
+	float itemWidth = Width() * 0.33;
+	float itemHeight = itemWidth / 2.208;
+	float startX = Width() - itemWidth - margin;
+	float startY = margin;
+
+	glTranslated(startX, startY, 0);
+
+	glBegin(GL_QUADS);
+	glTexCoord2f(1, 0); glVertex2i(0, 0);
+	glTexCoord2f(0, 0); glVertex2i(itemWidth, 0);
+	glTexCoord2f(0, 1); glVertex2i(itemWidth, itemHeight);
+	glTexCoord2f(1, 1); glVertex2i(0, itemHeight);
+	glEnd();
+
+	glDisable(GL_BLEND);
+
+	// Username
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+
+	glColor3f(1.0f, 1.0f, 1.0f);
+	float scale = GetScale();
+	m_textureFont.Bind();
+	std::ostringstream ss;
+	ss << m_player.GetUsername();
+	PrintText(fPosX, fPosY, scale, ss.str());
+
+	//Countdown
+	ss.str("");
+	ss << "Time: " << (int)(timer / 60) << ":" << std::setw(2) << std::setfill('0') << timer % 60;
+	PrintText(Width() - Width() * 0.15, Height() - (Height() / 19.2), scale, ss.str());
+	
+}
+
+void Engine::DisplayInfo(float elapsedTime, BlockType bloc) {
+	// Bind de la texture pour le font
+	m_textureFont.Bind();
+	std::ostringstream ss;
+
+	float scale = GetScale();
+	unsigned int x = Width() / 25;
+
+	ss << " Fps : " << GetFps(elapsedTime);
+	PrintText(x, Height() - (Height() / 19.2), scale, ss.str());
+	ss.str("");
+	ss << " Rendered Chunks : " << m_renderCount;
+	PrintText(x, Height() - (Height() / 13.7), scale, ss.str());
+	ss.str("");
+	ss << " To-Be-Deleted Chunks : " << m_world.GettbDeleted();
+	PrintText(x, Height() - (Height() / 10.7), scale, ss.str());
+	ss.str("");
+	ss << " Velocity  : " << m_player.GetVelocity(); // IMPORTANT : on utilise l <20> operateur << pour afficher la position
+	PrintText(x, Height() / 48, scale, ss.str());
+	ss.str("");
+	ss << " Direction : " << m_player.GetDirection();
+	PrintText(x, Height() / 24, scale, ss.str());
+	ss.str("");
+	ss << " Position  : " << m_player.GetPosition();
+	PrintText(x, Height() / 16, scale, ss.str());
+	ss.str("");
+	ss << " Block  : ";
+
+	if (bloc == BTYPE_LAST)
+		ss << "Weapon.";
+	else ss << (int)bloc;
+
+	PrintText(x, Height() / 12, scale, ss.str());
+}
+
+void Engine::DrawHud(float elapsedTime, BlockType bloc) {
+	// Setter le blend function, tout ce qui sera noir sera transparent
+	glDisable(GL_STENCIL_TEST);
+	glDisable(GL_DEPTH_TEST);
+
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	glBlendEquation(GL_FUNC_ADD);
+
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+
+	glLoadIdentity();
+	glOrtho(0, Width(), 0, Height(), -1, 1);
+
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+
+	int timer = GetCountdown(elapsedTime);
+
+	if (m_displayInfo) {
+		DisplayInfo(elapsedTime, bloc);
+	}
+
+	if (m_displayHud) {
+		DisplayHud(timer);
+	}
+
+	if (m_displayCrosshair) {
+		DisplayCrosshair();
+	}
+
+	// Reset du blend function
 	glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
 	glBlendEquation(GL_FUNC_SUBTRACT);
-	glEnable(GL_DEPTH_TEST);
+
 	glEnable(GL_STENCIL_TEST);
+	glEnable(GL_DEPTH_TEST);
+
 	glMatrixMode(GL_PROJECTION);
 	glPopMatrix();
+
 	glMatrixMode(GL_MODELVIEW);
 	glPopMatrix();
 }
 
-void Engine::PrintText(unsigned int x, unsigned int y, const std::string& t) {
+void Engine::PrintText(float x, float y, float scale, const std::string& t) {
 	glLoadIdentity();
 	glTranslated(x, y, 0);
+
 	for (unsigned int i = 0; i < t.length(); ++i) {
 		float left = (float)((t[i] - 32) % 16) / 16.f;
 		float top = (float)((t[i] - 32) / 16) / 16.f;
 		top += .5f;
+
 		glBegin(GL_QUADS);
-		glTexCoord2f(left, 1.f - top - .0625f);
-		glVertex2f(0, 0);
-		glTexCoord2f(left + .0625f, 1.f - top - .0625f);
-		glVertex2f(12, 0);
-		glTexCoord2f(left + .0625f, 1.f - top);
-		glVertex2f(12, 12);
-		glTexCoord2f(left, 1.f - top);
-		glVertex2f(0, 12);
+			glTexCoord2f(left, 1.f - top - .0625f);			 glVertex2f(0, 0);
+			glTexCoord2f(left + .0625f, 1.f - top - .0625f); glVertex2f(12 * scale, 0);
+			glTexCoord2f(left + .0625f, 1.f - top);			 glVertex2f(12 * scale, 12 * scale);
+			glTexCoord2f(left, 1.f - top);					 glVertex2f(0, 12 * scale);
 		glEnd();
-		glTranslated(8, 0, 0);
+
+		glTranslated(8 * scale, 0, 0);
 	}
 }
 
+float Engine::GetScale() const {
+	float widthRatio = Width() / BASE_WIDTH;
+	float heightRatio = Height() / BASE_HEIGHT;
+
+	return (widthRatio + heightRatio) / 2.0f;
+}
+
 int Engine::GetFps(float elapsedTime) const { return 1 / elapsedTime; }
+int Engine::GetCountdown(float elapsedTime) {
+	if (m_resetcountdown)
+	{
+		m_countdown = m_time + COUNTDOWN;
+		m_resetcountdown = false;
+	}
+	if (m_countdown < m_time)
+		Stop();
+	if(!m_stopcountdown)
+		m_time += elapsedTime;
+	return m_countdown - (int)m_time;
+}
 
 void Engine::Render(float elapsedTime) {
 	//static float gameTime = elapsedTime;
@@ -207,17 +351,17 @@ void Engine::Render(float elapsedTime) {
 	if (bulletTime < 0.f) bulletTime = 0.f;
 
 	if (pollTime >= .005f) {
-	m_player.ApplyPhysics(m_player.GetInput(m_keyW, m_keyS, m_keyA, m_keyD, m_keySpace, (bloc == BTYPE_LAST && bulletTime <= 0.f && m_mouseL), elapsedTime), &m_world, elapsedTime, &m_audio);
-	m_audio.Update3DAudio(m_player.GetPOV(), m_player.GetDirection(), m_player.GetVelocity()); // Ajustement du positionnement 3D avec les coordonn<6E>es du joueur et
-																									// son vecteur de v<>locit<69> (pour l'effet Doppler)
-	pollTime = 0;
+		m_player.ApplyPhysics(m_player.GetInput(m_keyW, m_keyS, m_keyA, m_keyD, m_keySpace, (bloc == BTYPE_LAST && bulletTime <= 0.f && m_mouseL), elapsedTime), &m_world, elapsedTime, &m_audio);
+		m_audio.Update3DAudio(m_player.GetPOV(), m_player.GetDirection(), m_player.GetVelocity()); // Ajustement du positionnement 3D avec les coordonn<6E>es du joueur et
+		// son vecteur de v<>locit<69> (pour l'effet Doppler)
+		pollTime = 0;
 	}
 
 	m_player.ApplyTransformation(all);
 
 	m_player.ApplyTransformation(skybox, false); // Version d'ApplyTransformation qui ne tient compte que de la rotation 
-												// (donc l'objet ne bouge pas relativement au joueur, ce qui est pratique pour une skybox!).
-	
+	// (donc l'objet ne bouge pas relativement au joueur, ce qui est pratique pour une skybox!).
+
 	if (m_mouseWU) bloc++;
 	else if (m_mouseWD) bloc--;
 	if (bloc == BTYPE_LAST + 1) bloc = BTYPE_AIR + 1;
@@ -230,15 +374,15 @@ void Engine::Render(float elapsedTime) {
 		else if (bulletTime <= 0.f) {
 			for (int x = 0; x < MAX_BULLETS; ++x)  // Ajouter une balle dans l'array (aussi connu sous le nom de "faire pow pow").
 				if (!m_bullets[x]) {
-					m_bullets[x] = new Bullet(m_player);
+					m_bullets[x] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection());
 					break;
 				}
 				else if (x == MAX_BULLETS - 1) { // S'il y a pas d'espace dans l'array, prendre la place de la premi<6D>re balle de l'array.
 					m_bullets[0]->~Bullet();
-					m_bullets[0] = new Bullet(m_player);
+					m_bullets[0] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection());
 				}
 			bulletTime = .1f;
-			m_audio.Create3DAudioObj(m_powpow, AUDIO_PATH "pow.wav", m_player.GetPOV(), m_player.GetDirection() * 10, .5f);
+			m_audio.Create3DAudioObj(m_powpow, AUDIO_PATH "windowsaccount.wav", m_player.GetPOV(), m_player.GetDirection() * 10, .5f);
 			if (m_flash) { // Coupe le rendering et affiche un frame blanc, pour simuler un flash.
 				glClearColor(.8f, .8f, .8f, 1.f);
 				glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
@@ -252,7 +396,7 @@ void Engine::Render(float elapsedTime) {
 
 	for (int x = 0; x < MAX_BULLETS; ++x) // Array de bullets en jeu.
 		if (m_bullets[x])
-			if (m_bullets[x]->Update(&m_world, all, elapsedTime)) {
+			if (m_bullets[x]->Update(&m_world, elapsedTime)) {
 				m_bullets[x]->~Bullet();
 				m_bullets[x] = nullptr;
 			}
@@ -260,13 +404,9 @@ void Engine::Render(float elapsedTime) {
 	m_world.Update(m_renderCount, m_bullets, m_player, all, m_shader01, m_textureAtlas, m_blockinfo);
 
 	if (m_isSkybox) m_skybox.Render(skybox);
-	
-	if (m_wireframe)
-		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-	DrawHud(elapsedTime, bloc);
-	if (m_wireframe)
-		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
+	DrawHud(elapsedTime, bloc);
+	
 	static bool fell = false;
 	if (m_player.GetPosition().y < 1.7f && !fell) {
 		m_audio.Create3DAudioObj(m_scream, AUDIO_PATH "scream.wav", m_player.GetPOV(), m_player.GetVelocity(), 1.f);
@@ -280,54 +420,58 @@ void Engine::Render(float elapsedTime) {
 
 void Engine::KeyPressEvent(unsigned char key) {
 	switch (key) {
-	case 36: // ESC
-		Stop();
-		break;
-	case 94: // F10
-		SetFullscreen(!IsFullscreen());
-		break;
-	case 22: // W
-		if (!m_keyW) {
-		//	std::cout << "W " << std::endl;
-			m_keyW = true;
-		}
-		break;
-	case 0: // A
+	case 0: // A - Gauche
 		if (!m_keyA) {
-			//std::cout << "A " << std::endl;
 			m_keyA = true;
 		}
 		break;
-	case 18: // S
-		if (!m_keyS) {
-			//std::cout << "S " << std::endl;
-			m_keyS = true;
-		}
-		break;
-	case 3: // D
+	case 3: // D - Droite
 		if (!m_keyD) {
-			//std::cout << "D " << std::endl;
 			m_keyD = true;
 		}
 		break;
-	case 38: // Left Shift
-		if (!m_keylshift) {
-			//std::cout << "Dash!" << std::endl;
-			m_keylshift = true;
+	case 18: // S - Reculer
+		if (!m_keyS) {
+			m_keyS = true;
 		}
 		break;
-	case 57: // Space
+	case 22: // W - Avancer
+		if (!m_keyW) {
+			m_keyW = true;
+		}
+		break;
+	case 36: // ESC - Quitter
+		Stop();
+		break;
+	case 57: // Space - Sauter
 		if (!m_keySpace) {
-			//std::cout << "Jump! " << std::endl;
 			m_keySpace = true;
 		}
 		break;
+	case 94: // F10 - Plein <20>cran
+		IsFullscreen() ? SetFullscreen(false) : SetFullscreen(true);
+		//SetFullscreen(!IsFullscreen());
+		break;
+	case 2: // C - Ignorer
+		break;
 	case 5: // F - Ignorer
-	case 24: // Y - Ignorer
-	case 255: // Fn - Ignorer
+		break;
+	case 6: // G - Ignorer
+		break;
 	case 12: // M - Ignorer
+		break;
+	case 7: // H - Ignorer
+		break;
+	case 8: // I - Ignorer
+		break;
 	case 17: // R - Ignorer
 		break;
+	case 19: // T - Ignorer
+		break; 
+	case 24: // Y - Ignorer
+		break;
+	case 255: // Fn - Ignorer
+		break;
 	default:
 		std::cout << "Unhandled key: " << (int)key << std::endl;
 	}
@@ -335,44 +479,55 @@ void Engine::KeyPressEvent(unsigned char key) {
 
 void Engine::KeyReleaseEvent(unsigned char key) {
 	switch (key) {
-	case 5:
+	case 0: // A - Stop gauche
+		m_keyA = false;
+		break;
+	case 2: // C - Toggle crosshair
+		m_displayCrosshair = !m_displayCrosshair;
+		std::cout << "DISPLAY CROSSHAIR " << (m_displayCrosshair ? "enabled" : "disabled") << std::endl;
+		break;
+	case 3: // D - Stop droite
+		m_keyD = false;
+		break;
+	case 5: // F - Toggle flash
 		m_flash = !m_flash;
 		break;
-	case 12:
+	case 6: // G - Toggle Stop Countdown
+		m_stopcountdown = !m_stopcountdown;
+		std::cout << "STOP COUNTDOWN " << (m_stopcountdown ? "enabled" : "disabled") << std::endl;
+		break;
+	case 7: // H - Toggle HUD
+		m_displayHud = !m_displayHud;
+		std::cout << "DISPLAY HUD " << (m_displayHud ? "enabled" : "disabled") << std::endl;
+		break;
+	case 8: // I - Toggle render data
+		m_displayInfo = !m_displayInfo;
+		std::cout << "DISPLAY INFO " << (m_displayInfo ? "enabled" : "disabled") << std::endl;
+		break;
+	case 12: // M - Toggle music
 		m_audio.ToggleMusicState();
 		break;
-	case 17:
+	case 17: // R - Toggle skybox
 		m_isSkybox = !m_isSkybox;
 		break;
-	case 24: // Y
+	case 18: // S - Stop reculer
+		m_keyS = false;
+		break;
+	case 19: // T -Reset countdown
+		m_resetcountdown = true;
+		std::cout << "RESET COUNTDOWN" << std::endl;
+		break;
+	case 22: // W - Stop avancer
+		m_keyW = false;
+		break;
+	case 24: // Y - Wireframe
 		m_wireframe = !m_wireframe;
 		if (m_wireframe)
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		else
 			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 		break;
-	case 22: // W
-		//std::cout << "rW " << std::endl;
-		m_keyW = false;
-		break;
-	case 0: // A
-		//std::cout << "rA " << std::endl;
-		m_keyA = false;
-		break;
-	case 18: // S
-		//std::cout << "rS " << std::endl;
-		m_keyS = false;
-		break;
-	case 3: // D
-		//std::cout << "rD " << std::endl;
-		m_keyD = false;
-		break;
-	case 38: // Left Shift
-		//std::cout << "rLS " << std::endl;
-		m_keylshift = false;
-		break;
-	case 57: // Espace
-		//std::cout << "rSpace " << std::endl;
+	case 57: // Espace - Stop sauter
 		m_keySpace = false;
 		break;
 	}
@@ -437,10 +592,9 @@ void Engine::MouseReleaseEvent(const MOUSE_BUTTON& button, int x, int y) {
 	}
 }
 
-bool Engine::LoadTexture(Texture& texture, const std::string& filename, bool stopOnError) {
-	texture.Load(filename);
-	if (!texture.IsValid())
-	{
+bool Engine::LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps, bool stopOnError) {
+	texture.Load(filename, useMipmaps);
+	if (!texture.IsValid()) {
 		std::cerr << "Unable to load texture (" << filename << ")" << std::endl;
 		if (stopOnError)
 			Stop();

SQCSim2021/engine.h

@@ -1,5 +1,11 @@
 #ifndef ENGINE_H__
 #define ENGINE_H__
+
+#include <algorithm>
+#include <cmath>
+#include "../SQCSim-common/array2d.h"
+#include "../SQCSim-common/blockinfo.h"
+#include "../SQCSim-common/bullet.h"
 #include "define.h"
 #include "openglcontext.h"
 #include "texture.h"
@@ -10,10 +16,8 @@
 #include "skybox.h"
 #include "audio.h"
 #include "textureatlas.h"
-#include "blockinfo.h"
-#include "array2d.h"
 #include "world.h"
-#include "bullet.h"
+#include "connector.h"
 
 class Engine : public OpenglContext {
 public:
@@ -31,16 +35,21 @@ public:
     virtual void MouseReleaseEvent(const MOUSE_BUTTON &button, int x, int y);
 
 private:
-    bool LoadTexture(Texture& texture, const std::string& filename, bool stopOnError = true);
-    void DrawHud(float elapsedTime, BlockType bloc);
-    void PrintText(unsigned int x, unsigned int y, const std::string& t);
+    float GetScale() const;
+
     int GetFps(float elapsedTime) const;
+    int GetCountdown(float elapsedTime);
 
-    bool m_wireframe = false;
-    bool m_isSkybox = true;
+    bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps = true, bool stopOnError = true);
 
-    int m_renderCount = 0;
+    void DisplayCrosshair();
+    void DisplayCurrentItem();
+    void DisplayHud(int timer);
+    void DisplayInfo(float elapsedTime, BlockType bloc);
+    void DrawHud(float elapsedTime, BlockType bloc);
+    void PrintText(float x, float y, float scale, const std::string& t);
 
+    Connector m_conn;
     Shader m_shader01;
     BlockInfo* m_blockinfo[BTYPE_LAST];
     TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST);
@@ -50,9 +59,10 @@ private:
     Texture m_textureSkybox;
     Texture m_textureFont;
     Texture m_textureCrosshair;
-    
+    Texture m_textureGun;
+
     Skybox m_skybox;
-    Audio m_audio = Audio(AUDIO_PATH "music01.wav");
+    Audio m_audio = Audio(AUDIO_PATH "start.wav");
 
     irrklang::ISound* m_powpow;
     irrklang::ISound* m_scream;
@@ -61,21 +71,32 @@ private:
 
     Bullet* m_bullets[MAX_BULLETS];
 
+    float m_scale;
+    float m_time = 0;
+
+    int m_renderCount = 0;
+    int m_countdown = COUNTDOWN;
+
+    bool m_wireframe = false;
+    bool m_isSkybox = true;
+    bool m_block = false;
+    bool m_flash = true;
+    bool m_displayCrosshair = true;
+    bool m_displayHud = true;
+    bool m_displayInfo = false;
+    bool m_resetcountdown = false;
+    bool m_stopcountdown = false;
+    
     bool m_keyW = false;
     bool m_keyA = false;
     bool m_keyS = false;
     bool m_keyD = false;
-    bool m_keylshift = 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;
-
-    bool m_block = false;
-    bool m_flash = true;
 };
 
-
 #endif // ENGINE_H__

SQCSim2021/main.cpp

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