FactoryCraft-Server/FactoryCraft/Dimension.cpp

#include "Dimension.h"
#include "Constants.h"
#include "Datei.h"
#include "Game.h"

using namespace Framework;


Dimension::Dimension(int id)
	: dimensionId(id),
	gravity(9.8f),
	chunks(new Trie<Chunk>()),
	entities(new RCArray<Entity>())
{}

Dimension::~Dimension()
{
	entities->release();
	chunks->release();
}

void Dimension::api(Framework::InMemoryBuffer* zRequest, NetworkMessage* zResponse, Entity* zSource)
{
	char type;
	zRequest->lese(&type, 1);
	switch (type)
	{
	case 0: // chunk message
	{
		Punkt center;
		zRequest->lese((char*)&center.x, 4);
		zRequest->lese((char*)&center.y, 4);
		cs.lock();
		Chunk* cC = zChunk(center);
		if (!cC)
		{
			// TODO: have a max amount of waiting requests per player
			waitingRequests.add({ dynamic_cast<InMemoryBuffer*>(zRequest->getThis()), center, zSource->getId() });
			Game::INSTANCE->requestArea({ center.x - CHUNK_SIZE / 2, center.y - CHUNK_SIZE / 2, center.x + CHUNK_SIZE / 2 - 1, center.y + CHUNK_SIZE / 2 - 1, dimensionId });
		}
		else
		{
			cC->api(zRequest, zSource);
		}
		cs.unlock();
		break;
	}
	}
}

void Dimension::tickEntities()
{
	for (auto entity : *entities)
	{
		if (!entity->isRemoved() && zChunk(Punkt((int)entity->getPosition().x, (int)entity->getPosition().y)))
			entity->prepareTick(this);
	}
	int index = 0;
	for (auto entity : *entities)
	{
		if (!entity->isRemoved() && zChunk(Punkt((int)entity->getPosition().x, (int)entity->getPosition().y)))
			entity->tick(this);
		index++;
	}
}

void Dimension::getAddrOf(Punkt cPos, char* addr) const
{
	*(int*)addr = cPos.x;
	*((int*)addr + 1) = cPos.y;
}

void Dimension::getAddrOfWorld(Punkt wPos, char* addr) const
{
	if (wPos.x < 0)
		wPos.x -= CHUNK_SIZE;
	if (wPos.y < 0) // needed because otherwise would (-8, -8) have the same adress as (8, 8)
		wPos.y -= CHUNK_SIZE;
	wPos /= CHUNK_SIZE;
	getAddrOf(wPos, addr);
}

Chunk* Dimension::zChunk(Punkt wPos) const
{
	char addr[8];
	getAddrOfWorld(wPos, addr);
	return chunks->z(addr, 8);
}

Framework::Either<Block*, int> Dimension::zBlock(Vec3<int> location)
{
	Chunk* c = zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
	if (c)
	{
		int x = location.x % CHUNK_SIZE;
		int y = location.y % CHUNK_SIZE;
		if (x < 0)
			x += CHUNK_SIZE;
		if (y < 0)
			y += CHUNK_SIZE;
		return c->zBlockAt(Vec3<int>(x, y, location.z));
	}
	return 0;
}

Block* Dimension::zRealBlockInstance(Framework::Vec3<int> location)
{
	Chunk* c = zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
	if (c)
	{
		int x = location.x % CHUNK_SIZE;
		int y = location.y % CHUNK_SIZE;
		if (x < 0)
			x += CHUNK_SIZE;
		if (y < 0)
			y += CHUNK_SIZE;
		c->instantiateBlock(Vec3<int>(x, y, location.z));
		auto result = c->zBlockAt(Vec3<int>(x, y, location.z));
		return result.isA() ? result.getA() : 0;
	}
	return 0;
}

void Dimension::placeBlock(Framework::Vec3<int> location, Framework::Either<Block*, int> block)
{
	Chunk* c = zChunk(Game::getChunkCenter(location.x, location.y));
	if (c)
	{
		int x = location.x % CHUNK_SIZE;
		int y = location.y % CHUNK_SIZE;
		if (x < 0)
			x += CHUNK_SIZE;
		if (y < 0)
			y += CHUNK_SIZE;
		if (block.isA())
			c->putBlockAt(Vec3<int>(x, y, location.z), block);
		else
		{
			c->putBlockAt(Vec3<int>(x, y, location.z), 0);
			c->putBlockTypeAt(Vec3<int>(x, y, location.z), block);
		}
	}
	else if (block.isA())
		block.getA()->release();
}

void Dimension::addEntity(Entity* entity)
{
	entities->add(entity);
}

void Dimension::setChunk(Chunk* chunk, Punkt center)
{
	char addr[8];
	getAddrOfWorld(center, addr);
	Chunk* old = chunks->z(addr, 8);
	if (old)
	{
		for (int i = 0; i < chunkList.getEintragAnzahl(); i++)
		{
			if (chunkList.get(i) == old)
			{
				chunkList.remove(i);
				break;
			}
		}
	}
	chunks->set(addr, 8, chunk);
	if (chunk)
	{
		chunkList.add(chunk);
		chunk->setAdded();
	}
	getAddrOfWorld(center + Punkt(CHUNK_SIZE, 0), addr);
	Chunk* zChunk = chunks->z(addr, 8);
	if (zChunk)
	{
		zChunk->setNeighbor(WEST, chunk);
		if (chunk)
			chunk->setNeighbor(EAST, zChunk);
	}
	getAddrOfWorld(center + Punkt(-CHUNK_SIZE, 0), addr);
	zChunk = chunks->z(addr, 8);
	if (zChunk)
	{
		zChunk->setNeighbor(EAST, chunk);
		if (chunk)
			chunk->setNeighbor(WEST, zChunk);
	}
	getAddrOfWorld(center + Punkt(0, CHUNK_SIZE), addr);
	zChunk = chunks->z(addr, 8);
	if (zChunk)
	{
		zChunk->setNeighbor(NORTH, chunk);
		if (chunk)
			chunk->setNeighbor(SOUTH, zChunk);
	}
	getAddrOfWorld(center + Punkt(0, -CHUNK_SIZE), addr);
	zChunk = chunks->z(addr, 8);
	if (zChunk)
	{
		zChunk->setNeighbor(SOUTH, chunk);
		if (chunk)
			chunk->setNeighbor(NORTH, zChunk);
	}
	if (chunk)
	{
		cs.lock();
		int index = 0;
		for (Iterator<RequestQueue> iterator = waitingRequests.begin(); iterator; )
		{
			Entity* zE = Game::INSTANCE->zEntity(iterator.val().sourceId);
			if (zE)
			{
				if (iterator.val().chunkCenter == chunk->getCenter())
				{
					chunk->api(iterator.val().request, zE);
					iterator.val().request->release();
					iterator.remove();
					continue;
				}
			}
			else
			{
				iterator.val().request->release();
				iterator.remove();
				continue;
			}
			iterator++;
			index++;
		}
		cs.unlock();
	}
}

void Dimension::save(Text worldDir) const
{
	for (auto chunk = chunks->getIterator(); chunk; chunk++)
	{
		if (!chunk._)
			continue;
		Datei* file = new Datei();
		Text filePath = worldDir + "/dim/" + dimensionId + "/";
		filePath.appendHex(chunk->getCenter().x);
		filePath += "_";
		filePath.appendHex(chunk->getCenter().y);
		filePath += ".chunk";
		file->setDatei(filePath);
		if (file->open(Datei::Style::schreiben))
			chunk->save(file);
		file->close();
		file->release();
	}
	Text filePath = worldDir + "/dim/" + dimensionId + "/entities";
	Datei* file = new Datei();
	file->setDatei(filePath);
	if (file->open(Datei::Style::schreiben))
	{
		for (Entity* entity : *entities)
		{
			if (entity->zType()->getId() != PlayerEntityType::ID)
			{
				if (!entity->isRemoved())
				{
					int type = entity->zType()->getId();
					file->schreibe((char*)&type, 4);
					StaticRegistry<EntityType>::INSTANCE.zElement(type)->saveEntity(entity, file);
				}
			}
			else
			{
				Datei pFile;
				pFile.setDatei(worldDir + "/player/" + ((Player*)entity)->getName());
				if (pFile.open(Datei::Style::schreiben))
					PlayerEntityType::INSTANCE->saveEntity(entity, &pFile);
			}
		}
		file->close();
	}
}

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

bool Dimension::hasChunck(int x, int y) const
{
	return zChunk(Punkt(x, y));
}

float Dimension::getGravity() const
{
	return gravity;
}

void Dimension::removeOldChunks()
{
	Array<int> removed;
	int index = 0;
	for (Chunk* chunk : chunkList)
	{
		if (!chunk->hasObservers())
			removed.add(index, 0);
		index++;
	}
	for (int i : removed)
	{
		Chunk* chunk = chunkList.get(i);
		// TODO: save chunk in a seperate thread?
		Text filePath = Game::INSTANCE->getWorldDirectory() + "/dim/" + getDimensionId() + "/";
		filePath.appendHex(chunk->getCenter().x);
		filePath += "_";
		filePath.appendHex(chunk->getCenter().y);
		filePath += ".chunk";
		Datei d;
		d.setDatei(filePath);
		d.open(Datei::Style::schreiben);
		chunk->save(&d);
		d.close();
		chunk->prepareRemove();
		setChunk(0, chunk->getCenter());
	}
}

Entity* Dimension::zEntity(int id)
{
	for (auto entity : *entities)
	{
		if (!entity->isRemoved() && entity->getId() == id)
			return entity;
	}
	return 0;
}

Entity* Dimension::zNearestEntity(Framework::Vec3<float> pos, std::function<bool(Entity*)> filter)
{
	Entity* result = 0;
	float sqDist = 0;
	for (auto entity : *entities)
	{
		if (!entity->isRemoved() && filter(entity))
		{
			float d = pos.abstandSq(entity->getPosition());
			if (!result || d < sqDist)
			{
				result = entity;
				sqDist = d;
			}
		}
	}
	return result;
}

void Dimension::removeEntity(int id)
{
	int index = 0;
	for (auto entity : *entities)
	{
		if (entity->getId() == id)
		{
			entities->remove(index);
			return;
		}
		index++;
	}
}

void Dimension::removeSubscriptions(Entity* zEntity)
{
	for (Chunk* chunk : chunkList)
		chunk->removeObserver(zEntity);
}