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

Changement dans le chunk a ajout des arbes avec le seed.

Browse Source
This commit is contained in:
Louis-CharlesG 2023-11-20 15:39:11 -05:00
parent 79013fe5d1
commit 732f74de91
2 changed files with 226 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

326
SQCSim-common/chunk.cpp
View File

@ -1,137 +1,259 @@
#include "chunk.h"
#include "world.h"
#include <random>
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);
//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);
//if (input.fail()) {
OpenSimplexNoise::Noise simplex = OpenSimplexNoise::Noise(seed);
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);
m_blocks.Reset(BTYPE_AIR);
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
input.read(data, size);
input.close();
#pragma region Montagnes et Grass des montagnes
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
float xnoiz, ynoiz;
xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 4796.;
ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 4796.;
double height = 0;
for (int x = 0; x < 39; ++x) {
height += simplex.eval(xnoiz, ynoiz);
height *= .79;
xnoiz *= 1.1305;
ynoiz *= 1.1305;
}
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) {
if (iy < 20)
{
//std::cout << "" << ynoiz << std::endl;
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr); // Blocs de montagnes
}
else if (iy == 20 || iy == 21) {
// Utilisez la partie décimale de la valeur de ynoiz pour déterminer le type de bloc
double fractionalPart = ynoiz - static_cast<int>(ynoiz);
// Variation pour iy égal à 24
if (iy == 20) {
if (fractionalPart < 0.3) {
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr); // Blocs de montagnes - Grass
}
else {
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr); // Blocs de montagnes - Metal
}
}
// Variation pour iy égal à 25
else if (iy == 21) {
if (fractionalPart < 0.6) {
SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr); // Blocs de montagnes - Grass
}
else {
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr); // Blocs de montagnes - Metal
}
}
}
else
{
SetBlock(ix, iy, iz, BTYPE_METAL, nullptr); // Grass des montagnes
}
}
}
#pragma endregion
#pragma region Lacs
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 (iy < 5 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr); // Partie inférieure du lac
}
else if (iy >= 5 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr); // Partie supérieure du lac (simulée avec de l'eau)
}
}
}
#pragma endregion
#pragma region Arbre
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) {
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
// Vérifiez d'abord que le bloc n'est pas un lac
if (GetBlock(ix, 0, iz) != BTYPE_ICE) {
// Recalculez la hauteur en fonction de la topographie du terrain
float xnoiz = (double)(ix + x * CHUNK_SIZE_X) / 5096.;
float ynoiz = (double)(iz + y * CHUNK_SIZE_Z) / 5096.;
double height = 0;
for (int i = 0; i < 39; ++i) {
height += simplex.eval(xnoiz, ynoiz);
height *= .79;
xnoiz *= 1.1305;
ynoiz *= 1.1305;
}
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.;
double minInput = 3068.84;
double maxInput = 3074.7;
double minOutput = 0.0;
double maxOutput = 100.0;
double valeurRnd = ((ynoiz - minInput) * (maxOutput - minOutput)) / (maxInput - minInput);
//std::cout << valeurRnd << std::endl;
// Ajout des arbres uniquement sur des blocs de type BTYPE_GRASS et avec une probabilité réduite
if (GetBlock(ix, 0, iz) != BTYPE_ICE && GetBlock(ix, (int)height, iz) == BTYPE_GRASS) {
// Vérifiez si vous souhaitez placer un arbre en fonction de votre logique de génération
if (valeurRnd < 20) {
// Calculez la position et la hauteur de l'arbre
// Exemple : Place un arbre à la position calculée avec une hauteur donnée
//
//PlaceTree(ix, height, iz, 10, 5 <= 5);
}
}
}
}
}
#pragma endregion
//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)]);
//}*/
//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 (iy < 10 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
// SetBlock(ix, iy, iz, BTYPE_METAL, nullptr); // Collines
// }
// else if (iy >= 10 && GetBlock(ix, iy, iz) == BTYPE_AIR) {
// SetBlock(ix, iy, iz, BTYPE_GRASS, nullptr); // Grass des collines
// }
// }
// }
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)]);
}*/
}
void Chunk::PlaceTree(int x, int y, int z, int height, int valeurRnd)
{
// Place le tronc
for (int iy = 0; iy < height; ++iy) {
SetBlock(x, y + iy, z, BTYPE_LAST, nullptr);
}
// Place les feuilles autour du tronc
int foliageHeight = height - 2;
for (int dy = 1; dy < foliageHeight; ++dy) {
for (int dx = -2; dx <= 2; ++dx) {
for (int dz = -2; dz <= 2; ++dz) {
if (valeurRnd < 50) {
SetBlock(x + dx, y + height + dy, z + dz, BTYPE_DIRT, nullptr);
}
}
}
}
}
Chunk::~Chunk() {
/*if (m_isModified) {
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
/*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);
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::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();
}*/
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;
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;
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;
unsigned int cx, cy;
world->GetScope(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 (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();
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; }

2
SQCSim-common/chunk.h
View File

@ -27,7 +27,7 @@ class Chunk {
BlockType GetBlock(int x, int y, int z);
void CheckNeighbors(unsigned int x, unsigned int z, World* world);
void GetPosition(unsigned int& x, unsigned int& y) const;
void PlaceTree(int x, int y, int z, int height,int valeurRnd);
bool IsDirty() const;
void MakeDirty();
void MakeClean();