FactoryCraft-Server/FactoryCraft/Chunk.cpp

#include <InMemoryBuffer.h>

#include "Chunk.h"
#include "Constants.h"
#include "Game.h"
#include "NoBlock.h"


Chunk::Chunk(Framework::Punkt location, int dimensionId)
	: ReferenceCounter(),
	dimensionId(dimensionId),
	location(location),
	added(0)
{
	blocks = new Block * [CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT];
	blockIds = new unsigned short[CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT];
	memset(blocks, 0, CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT * sizeof(Block*));
	memset(blockIds, 0, CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT * sizeof(unsigned short));
	zNeighbours[0] = 0;
	zNeighbours[1] = 0;
	zNeighbours[2] = 0;
	zNeighbours[3] = 0;
}

Chunk::Chunk(Framework::Punkt location, int dimensionId, Framework::StreamReader* zReader)
	: Chunk(location, dimensionId)
{
	load(zReader);
}

Chunk::~Chunk()
{
	for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT; i++)
	{
		if (blocks[i])
			blocks[i]->release();
	}
	delete[] blocks;
	delete[] blockIds;
}

Framework::Either<Block*, int> Chunk::zBlockNeighbor(Framework::Vec3<int> location)
{
	if (location.x >= 0 && location.x < CHUNK_SIZE && location.y >= 0 && location.y < CHUNK_SIZE && location.z >= 0 && location.z < WORLD_HEIGHT)
	{
		int index = (location.x * CHUNK_SIZE + location.y) * WORLD_HEIGHT + location.z;
		if (blocks[index])
			return blocks[index];
		else
			return (int)blockIds[index];
	}
	if (added && location.z >= 0 && location.z < WORLD_HEIGHT)
		return Game::INSTANCE->zBlockAt({ location.x + this->location.x - CHUNK_SIZE / 2, location.y + this->location.y - CHUNK_SIZE / 2, location.z }, dimensionId);
	return 0;
}

void Chunk::notifyObservers(NetworkMessage& msg)
{
	Array<int> remove;
	int index = 0;
	for (int id : observers)
	{
		Entity* zE = Game::INSTANCE->zEntity(id);
		if (!zE)
			remove.add(index, 0);
		else
			Game::INSTANCE->sendMessage(&msg, zE);
		index++;
	}
	for (int i : remove)
		observers.remove(i);
}

void Chunk::addObserver(Entity* zEntity)
{
	for (int id : observers)
	{
		if (id == zEntity->getId())
			return;
	}
	observers.add(zEntity->getId());
	InMemoryBuffer buffer;
	buffer.schreibe("\4", 1);
	buffer.schreibe((char*)&location.x, 4);
	buffer.schreibe((char*)&location.y, 4);
	sendToClient(&buffer);
	NetworkMessage msg;
	msg.addressDimension();
	char* message = new char[buffer.getSize()];
	buffer.lese(message, (int)buffer.getSize());
	msg.setMessage(message, (int)buffer.getSize(), 1);
	msg.setUseBackground();
	Game::INSTANCE->sendMessage(&msg, zEntity);
}

void Chunk::removeObserver(Entity* zEntity)
{
	int index = 0;
	for (int id : observers)
	{
		if (id == zEntity->getId())
		{
			observers.remove(index);
			return;
		}
		index++;
	}
}

void Chunk::api(Framework::StreamReader* zRequest, Entity* zSource)
{
	// TODO: answer api messages
	char type;
	zRequest->lese(&type, 1);
	switch (type)
	{
	case 0:
		// register observer
		addObserver(zSource);
		break;
	case 1:
		// unsubscribe
		removeObserver(zSource);
		break;
	}
}

Framework::Either<Block*, int> Chunk::zBlockAt(Framework::Vec3<int> location) const
{
	int index = (location.x * CHUNK_SIZE + location.y) * WORLD_HEIGHT + location.z;
	assert(index < CHUNK_SIZE* CHUNK_SIZE* WORLD_HEIGHT);
	if (blocks[index])
		return blocks[index];
	else
		return (int)blockIds[index];
}

const Block* Chunk::zBlockConst(Framework::Vec3<int> location) const
{
	auto b = zBlockAt(location);
	if (b.isA())
		return b;
	if (b.getB())
		return StaticRegistry<BlockType>::INSTANCE.zElement(b.getB())->zDefault();
	return 0;
}

void Chunk::instantiateBlock(Framework::Vec3<int> location)
{
	auto b = zBlockAt(location);
	if (b.isA())
		return;
	if (!b.getB())
		generateBlock(location);
	b = zBlockAt(location);
	if (b.isB())
		putBlockAt(location, StaticRegistry<BlockType>::INSTANCE.zElement(b.getB())->createBlockAt({ location.x + this->location.x - CHUNK_SIZE / 2, location.y + this->location.y - CHUNK_SIZE / 2, location.z }, 0));
}

void Chunk::generateBlock(Framework::Vec3<int> location)
{
	int index = (location.x * CHUNK_SIZE + location.y) * WORLD_HEIGHT + location.z;
	if (blockIds[index])
		return;
	auto generated = Game::INSTANCE->zGenerator()->generateSingleBlock({ location.x + this->location.x - CHUNK_SIZE / 2, location.y + this->location.y - CHUNK_SIZE / 2, location.z }, dimensionId);
	if (generated.isA())
		putBlockAt(location, generated);
	else
		putBlockTypeAt(location, generated);
}

void Chunk::putBlockAt(Framework::Vec3<int> location, Block* block)
{
	int index = (location.x * CHUNK_SIZE + location.y) * WORLD_HEIGHT + location.z;
	assert(index < CHUNK_SIZE* CHUNK_SIZE* WORLD_HEIGHT&& index >= 0);
	Block* old = blocks[index];
	bool change = 0;
	if (block)
	{
		change = blockIds[index] != (unsigned short)block->zBlockType()->getId();
		blockIds[index] = (unsigned short)block->zBlockType()->getId();
	}
	else
	{
		change = blocks[index] != 0;
	}
	blocks[index] = block;
	Either<Block*, int> neighbor = zBlockNeighbor(location + getDirection(NORTH));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(SOUTH, block);
	if (block)
		block->setNeighbour(NORTH, neighbor);
	neighbor = zBlockNeighbor(location + getDirection(EAST));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(WEST, block);
	if (block)
		block->setNeighbour(EAST, neighbor);
	neighbor = zBlockNeighbor(location + getDirection(SOUTH));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(NORTH, block);
	if (block)
		block->setNeighbour(SOUTH, neighbor);
	neighbor = zBlockNeighbor(location + getDirection(WEST));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(EAST, block);
	if (block)
		block->setNeighbour(WEST, neighbor);
	neighbor = zBlockNeighbor(location + getDirection(TOP));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(BOTTOM, block);
	if (block)
		block->setNeighbour(TOP, neighbor);
	neighbor = zBlockNeighbor(location + getDirection(BOTTOM));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbour(TOP, block);
	if (block)
		block->setNeighbour(BOTTOM, neighbor);
	if (old)
		old->release();
	if (change)
	{
		char msg[9];
		msg[0] = 0; // set block
		*(int*)(msg + 1) = index;
		*(int*)(msg + 5) = block ? block->zBlockType()->getId() : NoBlockBlockType::ID;
		NetworkMessage message;
		message.addressChunck(this);
		message.setMessage(msg, 9, 0);
		notifyObservers(message);
	}
}

void Chunk::putBlockTypeAt(Framework::Vec3<int> location, int type)
{
	int index = (location.x * CHUNK_SIZE + location.y) * WORLD_HEIGHT + location.z;
	assert(index < CHUNK_SIZE* CHUNK_SIZE* WORLD_HEIGHT);
	blockIds[index] = (unsigned short)type;
	Either<Block*, int> neighbor = zBlockNeighbor(location + getDirection(NORTH));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(SOUTH, type);
	neighbor = zBlockNeighbor(location + getDirection(EAST));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(WEST, type);
	neighbor = zBlockNeighbor(location + getDirection(SOUTH));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(NORTH, type);
	neighbor = zBlockNeighbor(location + getDirection(WEST));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(EAST, type);
	neighbor = zBlockNeighbor(location + getDirection(TOP));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(BOTTOM, type);
	neighbor = zBlockNeighbor(location + getDirection(BOTTOM));
	if (neighbor.isA())
		((Block*)neighbor)->setNeighbourType(TOP, type);
	char msg[9];
	msg[0] = 0; // set block
	*(int*)(msg + 1) = index;
	*(int*)(msg + 5) = type;
	NetworkMessage message;
	message.addressChunck(this);
	message.setMessage(msg, 9, 0);
	notifyObservers(message);
}

void Chunk::setNeighbor(Direction dir, Chunk* zChunk)
{
	zNeighbours[getDirectionIndex(dir)] = zChunk;
	for (int i = 0; i < CHUNK_SIZE; i++)
	{
		for (int z = 0; z < WORLD_HEIGHT; z++)
		{
			if (dir == NORTH)
			{
				int index = i * CHUNK_SIZE * WORLD_HEIGHT + z;
				if (blocks[index])
				{
					int j = (i * CHUNK_SIZE + CHUNK_SIZE - 1) * WORLD_HEIGHT + z;
					if (zChunk && zChunk->blocks[j])
						blocks[index]->setNeighbour(NORTH, zChunk->blocks[j]);
					else
					{
						blocks[index]->setNeighbour(NORTH, 0);
						blocks[index]->setNeighbourType(NORTH, zChunk ? zChunk->blockIds[j] : 0);
					}
				}
			}
			else if (dir == EAST)
			{
				int index = ((CHUNK_SIZE - 1) * CHUNK_SIZE + i) * WORLD_HEIGHT + z;
				if (blocks[index])
				{
					int j = i * WORLD_HEIGHT + z;
					if (zChunk && zChunk->blocks[j])
						blocks[index]->setNeighbour(EAST, zChunk->blocks[j]);
					else
					{
						blocks[index]->setNeighbour(EAST, 0);
						blocks[index]->setNeighbourType(EAST, zChunk ? zChunk->blockIds[j] : 0);
					}
				}
			}
			else if (dir == SOUTH)
			{
				int index = (i * CHUNK_SIZE + CHUNK_SIZE - 1) * WORLD_HEIGHT + z;
				if (blocks[index])
				{
					int j = i * CHUNK_SIZE * WORLD_HEIGHT + z;
					if (zChunk && zChunk->blocks[j])
						blocks[index]->setNeighbour(SOUTH, zChunk->blocks[j]);
					else
					{
						blocks[index]->setNeighbour(SOUTH, 0);
						blocks[index]->setNeighbourType(SOUTH, zChunk ? zChunk->blockIds[j] : 0);
					}
				}
			}
			else if (dir == WEST)
			{
				int index = i * WORLD_HEIGHT + z;
				if (blocks[index])
				{
					int j = ((CHUNK_SIZE - 1) * CHUNK_SIZE + i) * WORLD_HEIGHT + z;
					if (zChunk && zChunk->blocks[j])
						blocks[index]->setNeighbour(WEST, zChunk->blocks[j]);
					else
					{
						blocks[index]->setNeighbour(WEST, 0);
						blocks[index]->setNeighbourType(WEST, zChunk ? zChunk->blockIds[j] : 0);
					}
				}
			}
		}
	}
}

void Chunk::load(Framework::StreamReader* zReader)
{
	unsigned short id = 0;
	zReader->lese((char*)&id, 2);
	Framework::Vec3<int> pos;
	bool d = 0;
	while (id)
	{
		zReader->lese((char*)&pos.x, 4);
		zReader->lese((char*)&pos.y, 4);
		zReader->lese((char*)&pos.z, 4);
		zReader->lese((char*)&d, 1);
		if (d)
			putBlockAt(pos, StaticRegistry<BlockType>::INSTANCE.zElement(id)->loadBlock(Framework::Vec3<int>(pos.x + location.x - CHUNK_SIZE / 2, pos.y + location.y - CHUNK_SIZE / 2, pos.z), zReader));
		else
			putBlockTypeAt(pos, id);

		zReader->lese((char*)&id, 2);
	}
}

void Chunk::save(Framework::StreamWriter* zWriter)
{
	for (int x = 0; x < CHUNK_SIZE; x++)
	{
		for (int y = 0; y < CHUNK_SIZE; y++)
		{
			for (int z = 0; z < WORLD_HEIGHT; z++)
			{
				int index = (x * CHUNK_SIZE + y) * WORLD_HEIGHT + z;
				unsigned short blockType = blocks[index] ? (unsigned short)blocks[index]->zBlockType()->getId() : blockIds[index];
				if (blockType)
				{
					zWriter->schreibe((char*)&blockType, 2);
					zWriter->schreibe((char*)&x, 4);
					zWriter->schreibe((char*)&y, 4);
					zWriter->schreibe((char*)&z, 4);
					if (blocks[index])
					{
						bool d = 1;
						zWriter->schreibe((char*)&d, 1);
						StaticRegistry<BlockType>::INSTANCE.zElement(blockType)->saveBlock(blocks[index], zWriter);
					}
					else
					{
						bool d = 0;
						zWriter->schreibe((char*)&d, 1);
					}
				}
			}
		}
	}
	unsigned short end = 0;
	zWriter->schreibe((char*)&end, 2);
}

void Chunk::sendToClient(Framework::StreamWriter* zWriter)
{
	for (int x = 0; x < CHUNK_SIZE; x++)
	{
		for (int y = 0; y < CHUNK_SIZE; y++)
		{
			for (int z = 0; z < WORLD_HEIGHT; z++)
			{
				int index = (x * CHUNK_SIZE + y) * WORLD_HEIGHT + z;
				unsigned short blockType = blocks[index] ? (unsigned short)blocks[index]->zBlockType()->getId() : blockIds[index];
				if (blockType)
				{
					bool visible = 0;
					if (!visible)
					{
						if (!blocks[index])
						{
							if (CONST_BLOCK(0, blockIds[index])->isTransparent() || CONST_BLOCK(0, blockIds[index])->isPassable())
								visible = 1;
							else
							{
								for (int d = 0; d < 6 && !visible; d++)
								{
									auto n = zBlockNeighbor(getDirection((Directions)getDirectionFromIndex(d)) + Framework::Vec3<int>(x, y, z));
									if (n.isA() && (((Block*)n)->isPassable() || ((Block*)n)->isTransparent()))
										visible = 1;
									if (n.isB() && (CONST_BLOCK(0, n)->isTransparent() || CONST_BLOCK(0, n)->isPassable()))
										visible = 1;
								}
							}
						}
						else
							visible = blocks[index]->isVisible();
					}
					if (visible && (blocks[index] || blockType != AirBlockBlockType::ID))
					{
						zWriter->schreibe((char*)&blockType, 2);
						zWriter->schreibe((char*)&x, 4);
						zWriter->schreibe((char*)&y, 4);
						zWriter->schreibe((char*)&z, 4);
					}
				}
			}
		}
	}
	unsigned short end = 0;
	zWriter->schreibe((char*)&end, 2);
}

void Chunk::removeUnusedBlocks()
{
	for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT; i++)
	{
		if (blocks[i])
		{
			if (!blocks[i]->isVisible())
			{
				int x = (i / WORLD_HEIGHT) / CHUNK_SIZE;
				int y = (i / WORLD_HEIGHT) % CHUNK_SIZE;
				int z = i % WORLD_HEIGHT;
				putBlockAt({ x,y,z }, 0);
				putBlockTypeAt({ x, y, z }, NoBlockBlockType::ID);
			}
		}
		else if (blockIds[i])
		{
			int x = (i / WORLD_HEIGHT) / CHUNK_SIZE;
			int y = (i / WORLD_HEIGHT) % CHUNK_SIZE;
			int z = i % WORLD_HEIGHT;
			bool visible = 0;
			if (CONST_BLOCK(0, blockIds[i])->isTransparent() || CONST_BLOCK(0, blockIds[i])->isPassable())
				visible = 1;
			else
			{
				for (int d = 0; d < 6 && !visible; d++)
				{
					auto n = zBlockNeighbor(getDirection((Directions)getDirectionFromIndex(d)) + Framework::Vec3<int>(x, y, z));
					if (n.isA() && (((Block*)n)->isPassable() || ((Block*)n)->isTransparent()))
						visible = 1;
					if (n.isB() && (CONST_BLOCK(0, n)->isTransparent() || CONST_BLOCK(0, n)->isPassable()))
						visible = 1;
				}
			}
			if (!visible)
			{
				putBlockAt({ x,y,z }, 0);
				putBlockTypeAt({ x, y, z }, NoBlockBlockType::ID);
			}
		}
	}
	int count = 0;
	for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE * WORLD_HEIGHT; i++)
	{
		if (blockIds[i] && blockIds[i] != AirBlockBlockType::ID)
			count++;
	}
	std::cout << "chunk " << location.x << ", " << location.y << " was generated with " << count << " blocks.\n";
}

int Chunk::getDimensionId() const
{
	return dimensionId;
}

Framework::Punkt Chunk::getCenter() const
{
	return location;
}

Framework::Vec3<int> Chunk::getMin() const
{
	return { location.x - CHUNK_SIZE / 2, location.y - CHUNK_SIZE / 2, 0 };
}

Framework::Vec3<int> Chunk::getMax() const
{
	return { location.x + CHUNK_SIZE / 2, location.y + CHUNK_SIZE / 2, WORLD_HEIGHT };
}

void Chunk::prepareRemove()
{
	added = 0;
	for (int i = 0; i < 4; i++)
	{
		if (zNeighbours[i])
		{
			zNeighbours[i]->setNeighbor(getOppositeDirection(getDirectionFromIndex(i)), 0);
			zNeighbours[i] = 0;
		}
	}
}

void Chunk::setAdded()
{
	added = 1;
}

bool Chunk::hasObservers() const
{
	return observers.getEintragAnzahl() > 0;
}