memartel/SQCSimulator2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Merge branch 'master' into affichage_des_messages

Browse Source
This commit is contained in:
MarcEricMartel
2023-10-02 16:14:22 -04:00
parent 54e2f32aba 47906776c8
commit 432b8545a7
745 changed files with 123269 additions and 838 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
SQCSim-common/SQCSim-common.vcxproj Normal file
View File

@@ -0,0 +1,158 @@
<?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="transformation.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="transformation.cpp" />
<ClCompile Include="world.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

84
SQCSim-common/SQCSim-common.vcxproj.filters Normal file
View File

@@ -0,0 +1,84 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Fichiers sources">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Fichiers d%27en-tête">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="Fichiers de ressources">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="world.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="player.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="opensimplex.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="array2d.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="array3d.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="blockinfo.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="bullet.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="chunk.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="define.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="matrix4.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="vector3.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="netprotocol.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
<ClInclude Include="transformation.h">
<Filter>Fichiers d%27en-tête</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="world.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="blockinfo.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="bullet.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="chunk.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="opensimplex.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="player.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="netprotocol.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
<ClCompile Include="transformation.cpp">
<Filter>Fichiers sources</Filter>
</ClCompile>
</ItemGroup>
</Project>

61
SQCSim-common/array2d.h Normal file
View File

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

55
SQCSim-common/array3d.h Normal file
View File

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

42
SQCSim-common/blockinfo.cpp Normal file
View File

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

32
SQCSim-common/blockinfo.h Normal file
View File

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

39
SQCSim-common/bullet.cpp Normal file
View File

@@ -0,0 +1,39 @@
#include "bullet.h"
#include "world.h"
Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t tid): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_tid(tid) {}
Bullet::~Bullet() {}
bool Bullet::Update(World* world, float elapsedtime) {
for (int x = 0; x < 1000; ++x) {
m_currentpos += m_velocity * elapsedtime;
if (!world->ChunkAt(m_currentpos))
return true;
else if (world->BlockAt(m_currentpos) != BTYPE_AIR) {
world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
return true;
}
else if ((m_currentpos - m_startpos).Length() > VIEW_DISTANCE) return true;
}
return false;
}
void Bullet::Transpose(int& x, int& z) {
m_currentpos.x -= x * CHUNK_SIZE_X;
m_currentpos.z -= z * CHUNK_SIZE_Z;
m_startpos.x -= x * CHUNK_SIZE_X;
m_startpos.z -= z * CHUNK_SIZE_Z;
}
Vector3f Bullet::getPos() {
return m_currentpos;
}
uint64_t Bullet::getTeamID(){
return m_tid;
}

28
SQCSim-common/bullet.h Normal file
View File

@@ -0,0 +1,28 @@
#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__

142
SQCSim-common/chunk.cpp Normal file
View File

@@ -0,0 +1,142 @@
#include "chunk.h"
#include "world.h"
Chunk::Chunk(unsigned int x, unsigned int y, int64_t seed) : m_posX(x), m_posY(y) {
//std::ostringstream pos; // V<>rifie l'existence d'un fichier .chunk avec sa position.
//pos << CHUNK_PATH << x << '_' << y << ".chunk";
//std::ifstream input(pos.str(), std::fstream::binary);
//if (input.fail()) {
OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(seed);
m_blocks.Reset(BTYPE_AIR);
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Montagnes
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
float xnoiz, ynoiz;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4096.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4096.;
double height = 0;
for (int x = 0; x < 39; ++x) {
height += simplex.eval(xnoiz, ynoiz);
height *= .79;
xnoiz *= 1.139;
ynoiz *= 1.139;
}
height = height * 2000. * simplex.eval((double)(ix + x * CHUNK_SIZE_X) / 512., (double)(iz + y * CHUNK_SIZE_Z) / 512.);
height /= (CHUNK_SIZE_Y / 1.9);
height += 15.;
for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy)
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr);
}
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // Collines
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
float xnoiz, ynoiz;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 512.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 512.;
float height = simplex.eval(xnoiz, ynoiz) * 50.f;// +1.f;
for (int iy = 0; iy <= (int)height % CHUNK_SIZE_Y; ++iy) {
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr);
}
}
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Lacs"
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
for (int iy = 0; iy < 13; ++iy) {
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr);
}
}
//for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Arbres"
// for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
// float xnoiz, ynoiz;
// xnoiz = (double)(iz * CHUNK_SIZE_Y + x * CHUNK_SIZE_X) / 256.;
// ynoiz = (double)(ix * CHUNK_SIZE_Y + y * CHUNK_SIZE_Z) / 256.;
// bool tree = (int)(abs(simplex.eval(xnoiz, ynoiz)) * 17933.f) % CHUNK_SIZE_Y > 126 ? true : false;
// for (int iy = 0; iy < CHUNK_SIZE_Y - 10; ++iy)
// if (GetBlock(ix, iy, iz) == BTYPE_AIR)
// if (GetBlock(ix, iy - 1, iz) == BTYPE_GRASS)
// if (tree) {
// for (int i = 0; i < (int)(abs(simplex.eval(xnoiz, ynoiz) * 4)) % 42 + 1; ++i)
// SetBlock(ix, iy + i, iz, BTYPE_DIRT, nullptr);
// break;
// }
// }
/* }
else {
input.seekg(0, std::ios_base::end);
int size = input.tellg();
input.seekg(0, std::ios_base::beg);
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
input.read(data, size);
input.close();
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz)
for (int iy = 0; iy < CHUNK_SIZE_Y; ++iy)
m_blocks.Set(ix, iy, iz, data[ix + (iz * CHUNK_SIZE_X) + (iy * CHUNK_SIZE_Z * CHUNK_SIZE_X)]);
}*/
}
Chunk::~Chunk() {
/*if (m_isModified) {
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
for (int x = 0; x < CHUNK_SIZE_X; ++x)
for (int z = 0; z < CHUNK_SIZE_Z; ++z)
for (int y = 0; y < CHUNK_SIZE_Y; ++y)
data[x + (z * CHUNK_SIZE_X) + (y * CHUNK_SIZE_Z * CHUNK_SIZE_X)] = (char)GetBlock(x, y, z);
std::ostringstream pos;
pos << CHUNK_PATH << m_posX << '_' << m_posY << ".chunk";
std::ofstream output(pos.str(), std::fstream::binary);
output.write(data, sizeof(data));
output.close();
}*/
}
void Chunk::RemoveBlock(int x, int y, int z, World* world) {
m_blocks.Set(x, y, z, BTYPE_AIR);
CheckNeighbors(x, y, world);
m_isDirty = true;
}
void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
m_blocks.Set(x, y, z, type);
if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas v<>rifier les chunks voisines.
m_isDirty = true;
}
BlockType Chunk::GetBlock(int x, int y, int z) { return m_blocks.Get(x, y, z); }
void Chunk::CheckNeighbors(unsigned int x, unsigned int z, World* world) {
unsigned int cx, cy;
world->GetScope(cx, cy);
if (x == 0 && m_posX - cx >= 0 &&
world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
else if (x == CHUNK_SIZE_X - 1 && m_posX - cx < WORLD_SIZE_X &&
world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
if (z == 0 && m_posY - cy >= 0 &&
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z))
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z)->MakeDirty();
else if (z == CHUNK_SIZE_X - 1 && m_posY - cy < WORLD_SIZE_Y &&
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z))
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z)->MakeDirty();
}
void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
bool Chunk::IsDirty() const { return m_isDirty; }
void Chunk::MakeDirty() { m_isDirty = true; }
void Chunk::MakeClean() { m_isDirty = false; }
void Chunk::MakeModified() { m_isModified = true; }

37
SQCSim-common/chunk.h Normal file
View File

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

64
SQCSim-common/define.h Normal file
View File

@@ -0,0 +1,64 @@
#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 FRAMES_RENDER_CHUNKS 1
#define FRAMES_UPDATE_CHUNKS 1
#define FRAMES_DELETE_CHUNKS 1
#define THREADS_GENERATE_CHUNKS 8
#define THREADS_UPDATE_CHUNKS 6
#define THREADS_DELETE_CHUNKS 3
#define VIEW_DISTANCE 512 // Si les chunks arr<72>tent de s'afficher pendant une game et qu'il y a un access violation quand tu quitte, il faut augmenter ce chiffre.
#define TEXTURE_SIZE 512
#define MAX_BULLETS 512
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__

571
SQCSim-common/matrix4.h Normal file
View File

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

506
SQCSim-common/netprotocol.cpp Normal file
View File

@@ -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];
}

120
SQCSim-common/netprotocol.h Normal file
View File

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

2542
SQCSim-common/opensimplex.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

51
SQCSim-common/opensimplex.h Normal file
View File

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

208
SQCSim-common/player.cpp Normal file
View File

@@ -0,0 +1,208 @@
#include "player.h"
#include "world.h"
Player::Player(const Vector3f& position, float rotX, float rotY) : m_position(position), m_rotX(rotX), m_rotY(rotY) {
m_velocity = Vector3f(0, 0, 0);
m_airborne = true;
m_hp = 0.75f; //TODO: Remettre <20> 1.0f
m_username = "Zelda Bee-Bop56";
}
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;
}
Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTime) {
Player::Sound snd = Player::Sound::NOSOUND;
static float timing = 0.f;
/* Gestion de collisions */
BlockType bt1, bt2, bt3;
bt1 = world->BlockAt(GetPosition().x, GetPosition().y + input.y, GetPosition().z);
bt2 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 0.9f, GetPosition().z);
bt3 = world->BlockAt(GetPosition().x, GetPosition().y + input.y - 1.7f, GetPosition().z);
if ((bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) && m_position.y < 129.7f) {
bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
if (bt1 == BTYPE_AIR) m_position.y = (int)m_position.y + .7f;
m_velocity.y = input.y = 0;
m_airborne = false;
}
else {
if (abs(m_velocity.y) < 1.1f) m_velocity.y += input.y - 1.1f * elapsedTime;
bt3 = world->BlockAt(GetPosition().x, GetPosition().y + m_velocity.y - 1.7f, GetPosition().z);
bt1 = world->BlockAt(GetPosition().x, GetPosition().y + .3f, GetPosition().z);
if (bt3 != BTYPE_AIR) {
m_velocity.y = 0;
if (timing == 0.f) {
if (m_airborne) snd = Player::Sound::FALL;
timing = .3f;
}
m_airborne = false;
}
else if (bt1 != BTYPE_AIR) {
m_velocity.y = -.1f;
}
else m_airborne = true;
}
if (timing > 0.f) timing -= elapsedTime;
if (timing < 0.f) timing = 0.f;
bt1 = world->BlockAt(GetPosition().x + input.x, GetPosition().y, GetPosition().z);
bt2 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 0.9f, GetPosition().z);
bt3 = world->BlockAt(GetPosition().x + input.x, GetPosition().y - 1.7f, GetPosition().z);
if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
if (input.x > 0)
input.x = m_velocity.x = 0.5f;
else
input.x = m_velocity.x = -0.5f;
m_velocity.y = 0.3;
m_velocity.z *= .5f;
}
else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
input.x = m_velocity.x = 0;
m_velocity.z *= .5f;
}
bt1 = world->BlockAt(GetPosition().x, GetPosition().y, GetPosition().z + input.z);
bt2 = world->BlockAt(GetPosition().x, GetPosition().y - 0.9f, GetPosition().z + input.z);
bt3 = world->BlockAt(GetPosition().x, GetPosition().y - 1.7f, GetPosition().z + input.z);
if (bt1 == BTYPE_AIR && bt2 != BTYPE_AIR && bt3 != BTYPE_AIR) {
if (input.z > 0)
input.z = m_velocity.z = 0.5f;
else
input.z = m_velocity.z = -0.5f;
m_velocity.y = 0.3;
m_velocity.x *= .5f;
}
else if (bt1 != BTYPE_AIR || bt2 != BTYPE_AIR || bt3 != BTYPE_AIR) {
input.z = m_velocity.z = 0;
m_velocity.x *= .5f;
}
/* Fin gestion de collisions */
/* Gestion de la friction */
if (!m_airborne) {
m_velocity.x += input.x * 2.f * elapsedTime;
m_velocity.z += input.z * 2.f * elapsedTime;
if (input.x == 0.f)
m_velocity.x *= .8f;
if (input.z == 0.f)
m_velocity.z *= .8f;
}
else {
m_velocity.x += input.x * .4f * elapsedTime; // Techniquement contre les lois de la physique, mais c'est beaucoup moins chiant pour grimper sur les blocs.
m_velocity.z += input.z * .4f * elapsedTime;
m_velocity.x *= .99f;
m_velocity.z *= .99f;
}
/* Fin gestion de la friction */
float vy = m_velocity.y;
m_velocity.y = 1.f; // Padding pour limiter le x et z lors du Normalize().
if (m_velocity.Length() >= 1.f) m_velocity.Normalize(); // Limiteur de vitesse en x/z.
m_velocity.y = 0;
if (m_velocity.Length() < .005f) m_velocity.Zero(); // Threshold en x/z.
m_velocity.y = vy;
m_position += m_velocity;
static float bobbingtime = 0; // Gestion de la cam<61>ra
static bool leftright = false;
static bool isStep = false;
if (bobbingtime <= 360.f)
bobbingtime += elapsedTime * 20.f; else bobbingtime = 0;
if ((sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) < -.2f && !m_airborne) {
if (!isStep) {
snd = Player::Sound::STEP;
}
isStep = true;
}
else isStep = false;
m_POV = m_position.y;
m_POV += m_airborne ? 0 : (sin(bobbingtime) - 0.5f) * (abs(m_velocity.x) + abs(m_velocity.z)) * .2f;
return snd;
}
void Player::ApplyTransformation(Transformation& transformation, bool rel) const {
transformation.ApplyRotation(-m_rotX, 1, 0, 0);
transformation.ApplyRotation(-m_rotY, 0, 1, 0);
if (rel) transformation.ApplyTranslation(-GetPOV());
}
Vector3f Player::GetPosition() const { return Vector3f(m_position.x + CHUNK_SIZE_X * WORLD_SIZE_X / 2, m_position.y, m_position.z + CHUNK_SIZE_Z * WORLD_SIZE_Y / 2); }
Vector3f Player::GetVelocity() const { return m_velocity; }
Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }
Vector3f Player::GetDirection() const { return m_direction; }
std::string Player::GetUsername() const { return m_username; }
float Player::GetHP() const { return m_hp; }
void Player::Teleport(int& x, int& z) {
m_position.x -= x * CHUNK_SIZE_X;
m_position.z -= z * CHUNK_SIZE_Z;
}

45
SQCSim-common/player.h Normal file
View File

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

63
SQCSim-common/transformation.cpp Normal file
View File

@@ -0,0 +1,63 @@
#include "transformation.h"
Transformation::Transformation()
{
m_stack.push(Matrix4f::IDENTITY);
}
void Transformation::SetIdentity()
{
m_stack.top().SetIdentity();
}
void Transformation::Push()
{
m_stack.push(m_stack.top());
}
void Transformation::Pop()
{
m_stack.pop();
}
void Transformation::ApplyTranslation(float x, float y, float z)
{
m_stack.top().ApplyTranslation(x, y, z);
}
void Transformation::ApplyTranslation(const Vector3f& v)
{
ApplyTranslation(v.x, v.y, v.z);
}
void Transformation::ApplyRotation(float angle, float x, float y, float z)
{
m_stack.top().ApplyRotation(angle, x, y, z);
}
void Transformation::ApplyRotation(float angle, const Vector3f& v)
{
ApplyRotation(angle, v.x, v.y, v.z);
}
void Transformation::ApplyScale(float x, float y, float z)
{
m_stack.top().ApplyScale(x, y, z);
}
void Transformation::ApplyScale(const Vector3f& v)
{
ApplyScale(v.x, v.y, v.z);
}
//void Transformation::Use() const
//{
// glLoadMatrixf(m_stack.top().GetInternalValues());
//}
const Matrix4f& Transformation::GetMatrix() const
{
return m_stack.top();
}

36
SQCSim-common/transformation.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef TRANSFORMATION_H__
#define TRANSFORMATION_H__
#include <stack>
#include "define.h"
#include "matrix4.h"
#include "vector3.h"
class Transformation
{
public:
Transformation();
void SetIdentity();
void Push();
void Pop();
void ApplyTranslation(float x, float y, float z);
void ApplyTranslation(const Vector3f& v);
void ApplyRotation(float angle, float x, float y, float z);
void ApplyRotation(float angle, const Vector3f& v);
void ApplyScale(float x, float y, float z);
void ApplyScale(const Vector3f& v);
//void Use() const;
const Matrix4f& GetMatrix() const;
private:
std::stack<Matrix4f> m_stack;
};
#endif // TRANSFORMATION_H__

219
SQCSim-common/vector3.h Normal file
View File

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

410
SQCSim-common/world.cpp Normal file
View File

@@ -0,0 +1,410 @@
#include "world.h"
World::World() {}
World::~World() {}
Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
void World::SetSeed(uint64_t seed) {
m_seed = seed;
}
Chunk* World::ChunkAt(float x, float y, float z) const {
int cx = (int)x / CHUNK_SIZE_X;
int cz = (int)z / CHUNK_SIZE_Z;
if (x < 0 || y < 0 || z < 0 ||
x >= WORLD_SIZE_X * CHUNK_SIZE_X ||
z >= CHUNK_SIZE_Z * WORLD_SIZE_Y ||
y > CHUNK_SIZE_Y)
return 0;
return m_chunks.Get(cx, cz);
}
Chunk* World::ChunkAt(const Vector3f& pos) const { return ChunkAt(pos.x, pos.y, pos.z); }
BlockType World::BlockAt(float x, float y, float z, BlockType defaultBlockType) const {
Chunk* c = ChunkAt(x, y, z);
if (!c)
return defaultBlockType;
int bx = (int)x % CHUNK_SIZE_X;
int by = (int)y % CHUNK_SIZE_Y;
int bz = (int)z % CHUNK_SIZE_Z;
return c->GetBlock(bx, by, bz);
}
BlockType World::BlockAt(const Vector3f& pos, BlockType defaultBlockType) const {
return BlockAt(pos.x, pos.y, pos.z, defaultBlockType);
}
void World::TransposeWorld(Vector3f& player, Bullet* bullets[MAX_BULLETS]) {
int x = 0, y = 0;
if (player.x > (WORLD_SIZE_X * CHUNK_SIZE_X) * .6f) ++x;
else if (player.x < (WORLD_SIZE_X * CHUNK_SIZE_X) * .4f) --x;
if (player.z > (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .6f) ++y;
else if (player.z < (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .4f) --y;
if (!x && !y) return;
if (x > 0) {
for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
if (ax - x >= 0) {
m_chunks.Set(ax - x, ay,
m_chunks.Remove(ax, ay));
if (ax == WORLD_SIZE_X - 1 && m_chunks.Get(ax - x, ay))
m_chunks.Get(ax - x, ay)->MakeDirty();
}
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
}
else if (x < 0) {
for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
if (ax - x < WORLD_SIZE_X) {
m_chunks.Set(ax - x, ay,
m_chunks.Remove(ax, ay));
if (ax == 0 && m_chunks.Get(ax - x, ay))
m_chunks.Get(ax - x, ay)->MakeDirty();
}
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
}
if (y > 0) {
for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
if (ay - y >= 0) {
m_chunks.Set(ax, ay - y,
m_chunks.Remove(ax, ay));
if (ay == WORLD_SIZE_Y - 1 && m_chunks.Get(ax, ay - y))
m_chunks.Get(ax, ay - y)->MakeDirty();
}
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
}
else if (y < 0) {
for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
if (ay - y < WORLD_SIZE_Y) {
m_chunks.Set(ax, ay - y,
m_chunks.Remove(ax, ay));
if (ay == 0 && m_chunks.Get(ax, ay - y))
m_chunks.Get(ax, ay - y)->MakeDirty();
}
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
}
m_center[0] += x; m_center[1] += y;
player.x -= x * CHUNK_SIZE_X;
player.z -= y * CHUNK_SIZE_Z;
for (int index = 0; index < MAX_BULLETS; ++index)
if (bullets[index]) bullets[index]->Transpose(x, y);
}
void World::CleanUpWorld(int& deleteframes, bool clear = false) {
if (clear) {
while (m_tbDeleted.size() > 0) {
delete m_tbDeleted.back();
m_tbDeleted.pop_back();
}
}
if (!m_tbDeleted.empty() && !deleteframes) {
int deleted = 0;
while (deleted < THREADS_DELETE_CHUNKS) {
}
delete m_tbDeleted.back();
m_tbDeleted.pop_back();
deleteframes = FRAMES_DELETE_CHUNKS;
}
}
void World::GetScope(unsigned int& x, unsigned int& y) {
x = m_center[0];
y = m_center[1];
}
void World::Update(Bullet* bullets[MAX_BULLETS], Vector3f& player_pos, BlockInfo* blockinfo[BTYPE_LAST]) {
UpdateWorld(player_pos, blockinfo);
//TransposeWorld(player_pos, bullets);
}
//
//void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
// if (updates == 0 && ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// ChunkAt(chx, 1, chy)->Update(blockinfo, this);
// updates = FRAMES_UPDATE_CHUNKS;
// }
//
//}
void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block) {
Vector3f currentPos = player_pos;
Vector3f currentBlock = currentPos;
Vector3f ray = player_dir;
bool found = false;
if (block) return;
while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
currentBlock += ray / 10.f;
BlockType bt = BlockAt(currentBlock);
if (bt != BTYPE_AIR)
found = true;
}
if (found)
if (blockType != BTYPE_AIR) {
found = false;
while ((currentPos - currentBlock).Length() >= 1.7f && !found) {
currentBlock -= ray / 10.f;
BlockType bt = BlockAt(currentBlock);
if (bt == BTYPE_AIR) { // V<>rification pour <20>tre s<>r que le bloc <20> changer n'est pas dans le joueur.
int Bx = (int)currentBlock.x;
int By = (int)currentBlock.y;
int Bz = (int)currentBlock.z;
int Px = (int)currentPos.x;
int PyA = (int)currentPos.y;
int PyB = (int)(currentPos.y - .9f);
int PyC = (int)(currentPos.y - 1.7f);
int Pz = (int)currentPos.z;
if (!(Bx == Px &&
(By == PyA ||
By == PyB ||
By == PyC) &&
Bz == Pz))
found = true;
}
}
}
if (found && (int)currentBlock.y < CHUNK_SIZE_Y) {
int bx = (int)currentBlock.x % CHUNK_SIZE_X;
int by = (int)currentBlock.y % CHUNK_SIZE_Y;
int bz = (int)currentBlock.z % CHUNK_SIZE_Z;
ChunkAt(currentBlock)->SetBlock(bx, by, bz, blockType, this);
ChunkAt(currentBlock)->MakeModified();
block = true;
}
}
void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
int bx = (int)pos.x % CHUNK_SIZE_X;
int by = (int)pos.y % CHUNK_SIZE_Y;
int bz = (int)pos.z % CHUNK_SIZE_Z;
ChunkAt(pos)->SetBlock(bx, by, bz, blockType, this);
ChunkAt(pos)->MakeModified();
}
void World::UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]) {
int cx = player.x;
int cy = player.z;
static int frameGenerate = 1;
static int frameUpdate = 2;
static int frameDelete = 3;
int side = 0;
int threads = 0;
std::future<Chunk*> genThList[THREADS_GENERATE_CHUNKS];
//std::future<void> delThList[THREADS_DELETE_CHUNKS];
if (frameGenerate > 0) --frameGenerate;
if (frameUpdate > 0) --frameUpdate;
if (frameDelete > 0) --frameDelete;
if (!frameGenerate)
while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2 + CHUNK_SIZE_X) {
int tx = -side, ty = -side;
int chx = 0;
int chy = 0;
for (; tx <= side; ++tx) {
if (frameGenerate)
break;
chx = cx + tx * CHUNK_SIZE_X;
chy = cy + ty * CHUNK_SIZE_Z;
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
genThList[threads++] = std::async(std::launch::async,
[](unsigned int x, unsigned int y, uint64_t seed) {
return new Chunk(x, y, seed); },
chx / CHUNK_SIZE_X + m_center[0],
chy / CHUNK_SIZE_Z + m_center[1],
m_seed);
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
}
for (; ty <= side; ++ty) {
if (frameGenerate)
break;
chx = cx + tx * CHUNK_SIZE_X;
chy = cy + ty * CHUNK_SIZE_Z;
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
genThList[threads++] = std::async(std::launch::async,
[](unsigned int x, unsigned int y, uint64_t seed) {
return new Chunk(x, y, seed); },
chx / CHUNK_SIZE_X + m_center[0],
chy / CHUNK_SIZE_Z + m_center[1],
m_seed);
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
}
for (; tx >= -side; --tx) {
if (frameGenerate)
break;
chx = cx + tx * CHUNK_SIZE_X;
chy = cy + ty * CHUNK_SIZE_Z;
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
genThList[threads++] = std::async(std::launch::async,
[](unsigned int x, unsigned int y, uint64_t seed) {
return new Chunk(x, y, seed); },
chx / CHUNK_SIZE_X + m_center[0],
chy / CHUNK_SIZE_Z + m_center[1],
m_seed);
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
}
for (; ty >= -side; --ty) {
if (frameGenerate)
break;
chx = cx + tx * CHUNK_SIZE_X;
chy = cy + ty * CHUNK_SIZE_Z;
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
genThList[threads++] = std::async(std::launch::async,
[](unsigned int x, unsigned int y, uint64_t seed) {
return new Chunk(x, y, seed); },
chx / CHUNK_SIZE_X + m_center[0],
chy / CHUNK_SIZE_Z + m_center[1],
m_seed);
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
}
if (frameGenerate)
break;
++side;
}
if (threads > 0) {
for (int i = 0; i < threads; ++i)
genThList[i].wait();
for (int i = 0; i < threads; ++i) {
unsigned int x, y;
Chunk* chunk = genThList[i].get();
chunk->GetPosition(x, y);
m_chunks.Set(x - m_center[0], y - m_center[1], chunk);
}
}
side = 0;
threads = 0;
//if (!frameUpdate)
// while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2) {
// int tx = -side, ty = -side;
// for (; tx <= side; ++tx) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; ty <= side; ++ty) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; tx >= -side; --tx) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// for (; ty >= -side; --ty) {
// if (frameUpdate)
// break;
// unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
// if (ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// updateThList[threads++] =
// std::async(std::launch::async,
// [](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
// chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
// if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
// }
// }
// if (frameUpdate)
// break;
// ++side;
// }
//if (threads > 0) {
// for (int i = 0; i < threads; ++i) {
// updateThList[i].wait();
// Chunk* chunk = updateThList[i].get();
// chunk->FlushMeshToVBO();
// }
//}
threads = 0;
//int del = THREADS_DELETE_CHUNKS;
//while (!m_tbDeleted.empty() && del--) { // Moins rapide que le bout en dessous, mais -beaucoup- plus stable.
// m_tbDeleted.back()->FlushVBO();
// m_tbDeleted.back()->~Chunk();
// m_tbDeleted.pop_back();
//}
/*while (!m_tbDeleted.empty() && !frameDelete) {
if (m_tbDeleted.back()) {
m_tbDeleted.back()->FlushVBO();
delThList[threads] =
std::async(std::launch::async,
[](Chunk* chunk) { delete chunk; }, m_tbDeleted.back());
m_tbDeleted.pop_back();
if (++threads > THREADS_DELETE_CHUNKS) frameDelete = FRAMES_DELETE_CHUNKS;
}
else m_tbDeleted.pop_back();
}*/
/*for (int x = 0; x < threads; ++x) {
delThList[x].wait();
delThList[x].get();
}*/
}
int World::GettbDeleted() const { return m_tbDeleted.size(); }

54
SQCSim-common/world.h Normal file
View File

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