FactoryCraft-Server/FactoryCraft/FluidBlock.cpp

#include "FluidBlock.h"

#include "Game.h"

FluidBlock::FluidBlock(int typeId, Framework::Vec3<int> pos)
    : Block(typeId, 0, pos, 0)
{
    transparent = 1;
    passable = 1;
    hp = 1;
    maxHP = 1;
    hardness = -1.f;
    speedModifier = 0.5f;
    tickSource = 1;
    interactable = 0;
    fluidAmount = 0;
    lastBroadcastedAmount = fluidAmount;
}

FluidBlock::~FluidBlock() {}

bool FluidBlock::onTick(TickQueue* zQueue, int numTicks, bool& blocked)
{
    nextFlow = 0;
    int bottom = neighbourTypes[getDirectionIndex(Direction::BOTTOM)];
    if (bottom != zBlockType()->getId())
    {
        if (bottom == BlockTypeEnum::AIR)
        {
            nextFlow |= 1 << getDirectionIndex(Direction::BOTTOM);
        }
        else
        {
            if (zNeighbours[getDirectionIndex(Direction::BOTTOM)]
                && zNeighbours[getDirectionIndex(Direction::BOTTOM)]
                           ->zBlockType()
                           ->getId()
                       == typeId)
            {
                Inventory* array[2]
                    = {zNeighbours[getDirectionIndex(Direction::BOTTOM)], this};
                MultipleInventoryLock lock(array, 2);
                FluidBlock* below = dynamic_cast<FluidBlock*>(
                    zNeighbours[getDirectionIndex(Direction::BOTTOM)]);
                if (below->fluidAmount < 1000)
                {
                    short transferAmount
                        = (short)MIN(this->fluidAmount, (short)1000 - below->fluidAmount);
                    below->fluidAmount = (short)(below->fluidAmount + transferAmount);
                    this->fluidAmount = (short)(this->fluidAmount - transferAmount);
                }
            }
            short neighborCount = 0;
            Inventory* others[4];
            for (int i = 1; i < 5; i++)
            {
                if (neighbourTypes[i] == typeId && zNeighbours[i])
                {
                    others[neighborCount] = zNeighbours[i];
                    neighborCount++;
                }
            }
            if (neighborCount > 0)
            {
                Inventory* array[5]
                    = {this, others[0], others[1], others[2], others[3]};
                MultipleInventoryLock lock(array, neighborCount + 1);
                // all neighbot fluid blocks are locked now
                FluidBlock* otherFluids[4];
                for (int i = 0; i < neighborCount; i++)
                {
                    otherFluids[i] = dynamic_cast<FluidBlock*>(others[i]);
                }
                // order other fluids increasing by fluid amount
                sortByAmound(otherFluids, neighborCount);
                short distCount = 0;
                short targetAmount = 0;
                for (int i = 1; i <= neighborCount; i++)
                {
                    int fluidAmount = this->fluidAmount;
                    for (int j = 0; j < i; j++)
                    {
                        fluidAmount += otherFluids[j]->fluidAmount;
                    }
                    if (fluidAmount / (i + 1) > this->fluidAmount)
                    {
                        targetAmount = (short)(fluidAmount / (i + 1));
                        distCount = (short)i;
                    }
                    else
                    {
                        break;
                    }
                }
                for (int i = 0; i < distCount; i++)
                {
                    short transferAmount
                        = (short)(targetAmount - otherFluids[i]->fluidAmount);
                    otherFluids[i]->fluidAmount
                        = (short)(otherFluids[i]->fluidAmount + transferAmount);
                    this->fluidAmount = (short)(this->fluidAmount - transferAmount);
                }
            } // unlock
            neighborCount = 0;
            for (int i = 0; i < 6; i++)
            {
                if (getDirectionFromIndex(i) != Direction::BOTTOM
                    && getDirectionFromIndex(i) != Direction::TOP)
                {
                    int neighbor = neighbourTypes[i];
                    if (neighbor == BlockTypeEnum::AIR
                        && fluidAmount > neighborCount + 1)
                    {
                        nextFlow |= 1 << i;
                        neighborCount++;
                    }
                }
            }
        }
    }
    return 1;
}

void FluidBlock::broadcastAmount()
{
    if (lastBroadcastedAmount != fluidAmount)
    {
        lastBroadcastedAmount = fluidAmount;
        NetworkMessage* changeMsg = new NetworkMessage();
        changeMsg->addressBlock(this);
        char* msg = new char[3];
        msg[0] = 2; // fluid amount change
        *(short*)(msg + 1) = fluidAmount;
        changeMsg->setMessage(msg, 3);
        Game::INSTANCE->broadcastMessage(changeMsg);
    }
}

void FluidBlock::onPostTick()
{
    if (nextFlow != 0)
    {
        Game::INSTANCE->doLater([this]() {
            for (int i = 0; i < 6; i++)
            {
                if ((nextFlow | (1 << i)) == nextFlow)
                {
                    Vec3<int> pos
                        = getPos() + getDirection(getDirectionFromIndex(i));
                    if (neighbourTypes[i] == BlockTypeEnum::AIR)
                    {
                        FluidBlock* spawn = new FluidBlock(typeId, pos);
                        spawn->fluidAmount = 1;
                        Game::INSTANCE->zDimension(getDimensionId())
                            ->placeBlock(pos, spawn);
                        fluidAmount--;
                    }
                }
            }
            if (fluidAmount == 0)
            {
                Game::INSTANCE->zDimension(getDimensionId())
                    ->placeBlock(getPos(),
                        StaticRegistry<BlockType>::INSTANCE
                            .zElement(BlockTypeEnum::AIR)
                            ->createBlockAt(getPos(), 0));
            }
            else
            {
                broadcastAmount();
            }
        });
    }
}

void FluidBlock::sortByAmound(FluidBlock** array, int count)
{
    if (count == 2)
    {
        if (array[0]->fluidAmount > array[1]->fluidAmount)
        {
            FluidBlock* tmp = array[0];
            array[0] = array[1];
            array[1] = tmp;
        }
    }
    else if (count == 3)
    {
        if (array[0]->fluidAmount > array[1]->fluidAmount)
        {
            FluidBlock* tmp = array[0];
            array[0] = array[1];
            array[1] = tmp;
        }
        if (array[1]->fluidAmount > array[2]->fluidAmount)
        {
            FluidBlock* tmp = array[1];
            array[1] = array[2];
            array[2] = tmp;
        }
        if (array[0]->fluidAmount > array[1]->fluidAmount)
        {
            FluidBlock* tmp = array[0];
            array[0] = array[1];
            array[1] = tmp;
        }
    }
    else if (count == 4)
    {
        if (array[0]->fluidAmount > array[1]->fluidAmount)
        {
            FluidBlock* tmp = array[0];
            array[0] = array[1];
            array[1] = tmp;
        }
        if (array[2]->fluidAmount > array[3]->fluidAmount)
        {
            FluidBlock* tmp = array[2];
            array[2] = array[3];
            array[3] = tmp;
        }
        if (array[0]->fluidAmount > array[2]->fluidAmount)
        {
            FluidBlock* tmp = array[0];
            array[0] = array[2];
            array[2] = tmp;
        }
        if (array[1]->fluidAmount > array[3]->fluidAmount)
        {
            FluidBlock* tmp = array[1];
            array[1] = array[3];
            array[3] = tmp;
        }
        if (array[1]->fluidAmount > array[2]->fluidAmount)
        {
            FluidBlock* tmp = array[1];
            array[1] = array[2];
            array[2] = tmp;
        }
    }
}

FluidBlockType::FluidBlockType(int id, ModelInfo model, const char* name)
    : BlockType(id, 0, model, 1, 10, 0, name, true)
{}

void FluidBlockType::loadSuperBlock(
    Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
{
    FluidBlock* block = dynamic_cast<FluidBlock*>(zBlock);
    zReader->lese((char*)&block->fluidAmount, 2);
    BlockType::loadSuperBlock(zBlock, zReader, dimensionId);
}

void FluidBlockType::saveSuperBlock(
    Block* zBlock, Framework::StreamWriter* zWriter) const
{
    FluidBlock* block = dynamic_cast<FluidBlock*>(zBlock);
    zWriter->schreibe((char*)&block->fluidAmount, 2);
    BlockType::saveSuperBlock(zBlock, zWriter);
}

Item* FluidBlockType::createItem() const
{
    return 0;
}

Block* FluidBlockType::createBlock(Framework::Vec3<int> position) const
{
    FluidBlock* result = new FluidBlock(getId(), position);
    result->fluidAmount = 1000;
    return result;
}