FactoryCraft-Client/FactoryCraft/Dimension.cpp

#include "Dimension.h"

#include "Constants.h"
#include "Datei.h"
#include "Game.h"
#include "Globals.h"
#include "World.h"

using namespace Framework;

Dimension::Dimension()
    : chunks(new Trie<Chunk>()),
      entities(new RCArray<Entity>())
{}

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

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);
}

void Dimension::api(char* message)
{
    switch (message[0])
    {
    case 1: // chunck
        {
            int cX = *(int*)(message + 1);
            int cY = *(int*)(message + 5);
            cs.lock();
            Chunk* ch = zChunk(Punkt(cX, cY));
            if (ch) ch->api(message + 9);
            cs.unlock();
            break;
        }
    case 2: // entity
        {
            int eId = *(int*)(message + 1);
            cs.lock();
            Entity* e = zEntity(eId);
            if (e) e->api(message + 5);
            cs.unlock();
            break;
        }
    case 3: // block
        {
            int px = *(int*)(message + 1);
            int py = *(int*)(message + 5);
            int pz = *(int*)(message + 9);
            cs.lock();
            Block* b = zBlock(Framework::Vec3<int>(px, py, pz));
            if (b) b->api(message + 13);
            cs.unlock();
            break;
        }
    case 4: // add new chunck
        {
            Punkt center;
            center.x = *(int*)(message + 1);
            center.y = *(int*)(message + 5);
            ByteArrayReader reader(message + 9, INT_MAX, 0);
            std::cout << "downloading chunk " << center.x << ", " << center.y
                      << "\n";
            ZeitMesser zm;
            zm.messungStart();
            cs.lock();
            Chunk* chunk = new Chunk(center);
            chunk->load(&reader);
            zm.messungEnde();
            std::cout << "chunk loading took " << zm.getSekunden()
                      << " seconds\n";
            setChunk(chunk, center);
            cs.unlock();
            World::INSTANCE->onChunkAdded(center);
            break;
        }
    }
}

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

Block* Dimension::zBlock(Vec3<int> location)
{
    Chunk* c = zChunk(World::INSTANCE->getChunkCenter(location.x, location.y));
    if (c) return c->zBlockAt(location);
    return 0;
}

Block* Dimension::getBlock(Vec3<int> location)
{
    cs.lock();
    Chunk* c = zChunk(World::INSTANCE->getChunkCenter(location.x, location.y));
    if (c)
    {
        Block* b = c->zBlockAt(location);
        b = b ? dynamic_cast<Block*>(b->getThis()) : 0;
        cs.unlock();
        return b;
    }
    cs.unlock();
    return 0;
}

void Dimension::addEntity(Entity* entity)
{
    entities->add(entity);
    World::INSTANCE->setVisibility(entity, 1);
}

void Dimension::setChunk(Chunk* chunk, Punkt center)
{
    char addr[8];
    getAddrOfWorld(center, addr);
    Chunk* old = chunks->z(addr, 8);
    cs.lock();
    if (old)
    {
        World::INSTANCE->setVisibility(old, 0);
        int index = 0;
        for (auto iterator = chunkList.begin(); iterator; ++iterator, ++index)
        {
            if ((Chunk*)iterator == old)
            {
                if (chunk)
                    iterator.set(chunk);
                else
                    chunkList.remove(index);
                break;
            }
        }
    }
    else if (chunk)
        chunkList.add(chunk);
    chunks->set(addr, 8, chunk);
    if (chunk) chunk->getThis();
    cs.unlock();
    if (chunk)
    {
        World::INSTANCE->setVisibility(chunk, 1);
        chunk->release();
    }
}

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

void Dimension::removeDistantChunks(Punkt wPos)
{
    Array<int> removed;
    int index = 0;
    for (Chunk* chunk : chunkList)
    {
        if ((chunk->getCenter() - wPos).getLength() > MAX_VIEW_DISTANCE * 3)
            removed.add(index, 0);
        index++;
    }
    for (int i : removed)
    {
        cs.lock();
        Chunk* chunk = chunkList.get(i);
        World::INSTANCE->setVisibility(chunk, 0);
        setChunk(0, chunk->getCenter());
        cs.unlock();
    }
}

void Dimension::setBlock(Block* block)
{
    cs.lock();
    Chunk* c = zChunk(World::INSTANCE->getChunkCenter(
        (int)floor(block->getPos().x), (int)floor(block->getPos().y)));
    if (c)
        c->setBlock(block);
    else
        block->release();
    cs.unlock();
}

void Dimension::removeBlock(Block* zBlock)
{
    cs.lock();
    Chunk* c = zChunk(World::INSTANCE->getChunkCenter(
        (int)floor(zBlock->getPos().x), (int)floor(zBlock->getPos().y)));
    if (c) c->removeBlock(zBlock);
    cs.unlock();
}

Entity* Dimension::zEntity(int id)
{
    cs.lock();
    for (Entity* e : *entities)
    {
        if (e->getId() == id)
        {
            cs.unlock();
            return e;
        }
    }
    cs.unlock();
    return 0;
}

Entity* Dimension::getEntity(int id)
{
    cs.lock();
    for (Entity* e : *entities)
    {
        if (e->getId() == id)
        {
            Entity* result = dynamic_cast<Entity*>(e->getThis());
            cs.unlock();
            return result;
        }
    }
    cs.unlock();
    return 0;
}

void Dimension::removeEntity(int id)
{
    World::INSTANCE->lockWorld();
    cs.lock();
    int index = 0;
    for (Entity* e : *entities)
    {
        if (e->getId() == id)
        {
            World::INSTANCE->setVisibility(e, 0);
            entities->remove(index);
            cs.unlock();
            World::INSTANCE->unlockWorld();
            return;
        }
        index++;
    }
    cs.unlock();
    World::INSTANCE->unlockWorld();
}