202 lines
6.3 KiB
C++
202 lines
6.3 KiB
C++
#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_GREENGRASS, nullptr);
|
|
}
|
|
}
|
|
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Lacs"
|
|
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
|
|
for (int iy = 0; iy < 13; ++iy) {
|
|
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
|
|
SetBlock(ix, iy, iz, BTYPE_ICE, nullptr);
|
|
}
|
|
}
|
|
|
|
int rnd = rand() % 15;
|
|
if (rnd == 4)
|
|
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
|
|
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
|
|
for (int iy = 0; iy < 14; ++iy) {
|
|
if (ix == 3)
|
|
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
|
|
Structure(ix, iy, iz, 2);
|
|
}
|
|
}
|
|
if (rnd == 3)
|
|
for (int ix = 0; ix < CHUNK_SIZE_Z; ++ix) // structure
|
|
for (int iz = 0; iz < CHUNK_SIZE_X; ++iz) {
|
|
for (int iy = 0; iy < 14; ++iy) {
|
|
if (iz == 4)
|
|
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
|
|
Structure(ix, iy, iz, 2);
|
|
}
|
|
}
|
|
if (rnd == 6)
|
|
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // structure
|
|
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
|
|
for (int iy = 0; iy < 14; ++iy) {
|
|
if (ix == 3)
|
|
if (GetBlock(ix, iy, iz) == BTYPE_AIR)
|
|
Structure(ix, iy, iz, 2);
|
|
}
|
|
}
|
|
|
|
|
|
//for (int ix = 0; ix < CHUNK_SIZE_X; ++ix) // "Arbres"
|
|
// for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz) {
|
|
// float xnoiz, ynoiz;
|
|
// xnoiz = (double)(iz * CHUNK_SIZE_Y + x * CHUNK_SIZE_X) / 256.;
|
|
// ynoiz = (double)(ix * CHUNK_SIZE_Y + y * CHUNK_SIZE_Z) / 256.;
|
|
// bool tree = (int)(abs(simplex.eval(xnoiz, ynoiz)) * 17933.f) % CHUNK_SIZE_Y > 126 ? true : false;
|
|
// for (int iy = 0; iy < CHUNK_SIZE_Y - 10; ++iy)
|
|
// if (GetBlock(ix, iy, iz) == BTYPE_AIR)
|
|
// if (GetBlock(ix, iy - 1, iz) == BTYPE_GRASS)
|
|
// if (tree) {
|
|
// for (int i = 0; i < (int)(abs(simplex.eval(xnoiz, ynoiz) * 4)) % 42 + 1; ++i)
|
|
// SetBlock(ix, iy + i, iz, BTYPE_DIRT, nullptr);
|
|
// break;
|
|
// }
|
|
// }
|
|
/* }
|
|
else {
|
|
input.seekg(0, std::ios_base::end);
|
|
int size = input.tellg();
|
|
input.seekg(0, std::ios_base::beg);
|
|
|
|
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
|
|
input.read(data, size);
|
|
input.close();
|
|
|
|
for (int ix = 0; ix < CHUNK_SIZE_X; ++ix)
|
|
for (int iz = 0; iz < CHUNK_SIZE_Z; ++iz)
|
|
for (int iy = 0; iy < CHUNK_SIZE_Y; ++iy)
|
|
m_blocks.Set(ix, iy, iz, data[ix + (iz * CHUNK_SIZE_X) + (iy * CHUNK_SIZE_Z * CHUNK_SIZE_X)]);
|
|
}*/
|
|
}
|
|
|
|
Chunk::~Chunk() {
|
|
/*if (m_isModified) {
|
|
char data[CHUNK_SIZE_X * CHUNK_SIZE_Y * CHUNK_SIZE_Z];
|
|
|
|
for (int x = 0; x < CHUNK_SIZE_X; ++x)
|
|
for (int z = 0; z < CHUNK_SIZE_Z; ++z)
|
|
for (int y = 0; y < CHUNK_SIZE_Y; ++y)
|
|
data[x + (z * CHUNK_SIZE_X) + (y * CHUNK_SIZE_Z * CHUNK_SIZE_X)] = (char)GetBlock(x, y, z);
|
|
|
|
std::ostringstream pos;
|
|
pos << CHUNK_PATH << m_posX << '_' << m_posY << ".chunk";
|
|
|
|
std::ofstream output(pos.str(), std::fstream::binary);
|
|
output.write(data, sizeof(data));
|
|
output.close();
|
|
}*/
|
|
}
|
|
|
|
void Chunk::RemoveBlock(int x, int y, int z, World* world) {
|
|
m_blocks.Set(x, y, z, BTYPE_AIR);
|
|
CheckNeighbors(x, y, world);
|
|
m_isDirty = true;
|
|
}
|
|
|
|
void Chunk::SetBlock(int x, int y, int z, BlockType type, World* world) {
|
|
m_blocks.Set(x, y, z, type);
|
|
if (world) CheckNeighbors(x, z, world); // Si nullptr, ne pas vérifier les chunks voisines.
|
|
m_isDirty = true;
|
|
}
|
|
|
|
BlockType Chunk::GetBlock(int x, int y, int z) { return m_blocks.Get(x, y, z); }
|
|
|
|
void Chunk::CheckNeighbors(unsigned int x, unsigned int z, World* world) {
|
|
unsigned int cx, cy;
|
|
|
|
world->GetScope(cx, cy);
|
|
|
|
if (x == 0 && m_posX - cx >= 0 &&
|
|
world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
|
|
world->ChunkAt((m_posX - cx - 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
|
|
else if (x == CHUNK_SIZE_X - 1 && m_posX - cx < WORLD_SIZE_X &&
|
|
world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z))
|
|
world->ChunkAt((m_posX - cx + 1) * CHUNK_SIZE_X, 1, (m_posY - cy) * CHUNK_SIZE_Z)->MakeDirty();
|
|
|
|
if (z == 0 && m_posY - cy >= 0 &&
|
|
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z))
|
|
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy - 1) * CHUNK_SIZE_Z)->MakeDirty();
|
|
else if (z == CHUNK_SIZE_X - 1 && m_posY - cy < WORLD_SIZE_Y &&
|
|
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z))
|
|
world->ChunkAt((m_posX - cx) * CHUNK_SIZE_X, 1, (m_posY - cy + 1) * CHUNK_SIZE_Z)->MakeDirty();
|
|
}
|
|
|
|
void Chunk::GetPosition(unsigned int& x, unsigned int& y) const { x = m_posX; y = m_posY; }
|
|
|
|
bool Chunk::IsDirty() const { return m_isDirty; }
|
|
|
|
void Chunk::MakeDirty() { m_isDirty = true; }
|
|
|
|
void Chunk::MakeClean() { m_isDirty = false; }
|
|
|
|
void Chunk::MakeModified() { m_isModified = true; }
|
|
|
|
|
|
void Chunk::Structure(int x, int y, int z,int height)
|
|
{
|
|
|
|
|
|
|
|
for (int i = 0; i < height; i++)
|
|
{
|
|
SetBlock(x, i + y, z, BTYPE_GRASS, nullptr);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|