150 lines
4.3 KiB
C++
150 lines
4.3 KiB
C++
#include "BlocksController.h"
|
|
|
|
#include "../voxels/voxel.h"
|
|
#include "../voxels/Block.h"
|
|
#include "../voxels/Chunk.h"
|
|
#include "../voxels/Chunks.h"
|
|
#include "../world/Level.h"
|
|
#include "../world/World.h"
|
|
#include "../content/Content.h"
|
|
#include "../lighting/Lighting.h"
|
|
#include "../util/timeutil.h"
|
|
#include "../maths/fastmaths.h"
|
|
#include "../items/Inventory.h"
|
|
|
|
#include "scripting/scripting.h"
|
|
|
|
Clock::Clock(int tickRate, int tickParts)
|
|
: tickRate(tickRate),
|
|
tickParts(tickParts) {
|
|
}
|
|
|
|
bool Clock::update(float delta) {
|
|
tickTimer += delta;
|
|
float delay = 1.0f / float(tickRate);
|
|
if (tickTimer > delay || tickPartsUndone) {
|
|
if (tickPartsUndone) {
|
|
tickPartsUndone--;
|
|
} else {
|
|
tickTimer = fmod(tickTimer, delay);
|
|
tickPartsUndone = tickParts-1;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int Clock::getParts() const {
|
|
return tickParts;
|
|
}
|
|
|
|
int Clock::getPart() const {
|
|
return tickParts-tickPartsUndone-1;
|
|
}
|
|
|
|
int Clock::getTickRate() const {
|
|
return tickRate;
|
|
}
|
|
|
|
int Clock::getTickId() const {
|
|
return tickId;
|
|
}
|
|
|
|
BlocksController::BlocksController(Level* level, uint padding)
|
|
: level(level),
|
|
chunks(level->chunks),
|
|
lighting(level->lighting),
|
|
randTickClock(20, 3),
|
|
blocksTickClock(20, 1),
|
|
padding(padding) {
|
|
}
|
|
|
|
void BlocksController::updateSides(int x, int y, int z) {
|
|
updateBlock(x-1, y, z);
|
|
updateBlock(x+1, y, z);
|
|
updateBlock(x, y-1, z);
|
|
updateBlock(x, y+1, z);
|
|
updateBlock(x, y, z-1);
|
|
updateBlock(x, y, z+1);
|
|
}
|
|
|
|
void BlocksController::breakBlock(Player* player, const Block* def, int x, int y, int z) {
|
|
chunks->set(x,y,z, 0, 0);
|
|
lighting->onBlockSet(x,y,z, 0);
|
|
if (def->rt.funcsset.onbroken) {
|
|
scripting::on_block_broken(player, def, x, y, z);
|
|
}
|
|
updateSides(x, y, z);
|
|
}
|
|
|
|
void BlocksController::updateBlock(int x, int y, int z) {
|
|
voxel* vox = chunks->get(x, y, z);
|
|
if (vox == nullptr)
|
|
return;
|
|
const Block* def = level->content->getIndices()->getBlockDef(vox->id);
|
|
if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) {
|
|
breakBlock(nullptr, def, x, y, z);
|
|
return;
|
|
}
|
|
if (def->rt.funcsset.update) {
|
|
scripting::update_block(def, x, y, z);
|
|
}
|
|
}
|
|
|
|
void BlocksController::update(float delta) {
|
|
if (randTickClock.update(delta)) {
|
|
randomTick(randTickClock.getPart(), randTickClock.getParts());
|
|
}
|
|
if (blocksTickClock.update(delta)) {
|
|
onBlocksTick(blocksTickClock.getPart(), blocksTickClock.getParts());
|
|
}
|
|
}
|
|
|
|
void BlocksController::onBlocksTick(int tickid, int parts) {
|
|
auto content = level->content;
|
|
auto indices = content->getIndices();
|
|
int tickRate = blocksTickClock.getTickRate();
|
|
for (size_t id = 0; id < indices->countBlockDefs(); id++) {
|
|
if ((id + tickid) % parts != 0)
|
|
continue;
|
|
auto def = indices->getBlockDef(id);
|
|
if (def->rt.funcsset.onblockstick) {
|
|
scripting::on_blocks_tick(def, tickRate);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlocksController::randomTick(int tickid, int parts) {
|
|
const int w = chunks->w;
|
|
const int d = chunks->d;
|
|
int segments = 4;
|
|
int segheight = CHUNK_H / segments;
|
|
auto indices = level->content->getIndices();
|
|
|
|
for (uint z = padding; z < d-padding; z++){
|
|
for (uint x = padding; x < w-padding; x++){
|
|
int index = z * w + x;
|
|
if ((index + tickid) % parts != 0)
|
|
continue;
|
|
auto chunk = chunks->chunks[index];
|
|
if (chunk == nullptr || !chunk->isLighted())
|
|
continue;
|
|
for (int s = 0; s < segments; s++) {
|
|
for (int i = 0; i < 4; i++) {
|
|
int bx = random.rand() % CHUNK_W;
|
|
int by = random.rand() % segheight + s * segheight;
|
|
int bz = random.rand() % CHUNK_D;
|
|
const voxel& vox = chunk->voxels[(by * CHUNK_D + bz) * CHUNK_W + bx];
|
|
Block* block = indices->getBlockDef(vox.id);
|
|
if (block->rt.funcsset.randupdate) {
|
|
scripting::random_update_block(
|
|
block,
|
|
chunk->x * CHUNK_W + bx, by,
|
|
chunk->z * CHUNK_D + bz);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|