FactoryCraft-Server/FactoryCraft/GrowingPlant.cpp

#include "GrowingPlant.h"

#include "Dimension.h"
#include "Game.h"
#include "Recipie.h"

GrowthState::GrowthState(float percentage, ModelInfo* model)
    : ReferenceCounter(),
      percentage(percentage),
      model(model)
{}

GrowthState::~GrowthState()
{
    model->release();
}

float GrowthState::getPercentage() const
{
    return percentage;
}

ModelInfo* GrowthState::zModel() const
{
    return model;
}

GrowingPlantBlock::GrowingPlantBlock(int typeId,
    Framework::Vec3<int> pos,
    int dimensionId,
    int maxTicks,
    Framework::Text name,
    int blockTypeAfterGrowth)
    : Block(typeId, pos, dimensionId, 0),
      seblingTicks(0),
      seblingTicksMax(maxTicks),
      name(name),
      states(),
      blockTypeAfterGrowth(blockTypeAfterGrowth),
      plantSpawned(0),
      lastSendState(-1)
{}

bool GrowingPlantBlock::onTick(TickQueue* zQueue, int numTicks, bool& blocked)
{
    float beforePercentage = seblingTicks / (float)seblingTicksMax;
    seblingTicks += (float)numTicks;
    if ((int)(seblingTicks / (float)seblingTicksMax * 100.f)
        != (int)(beforePercentage * 100.f))
    {
        Game::INSTANCE->blockTargetChanged(this);
    }
    int index = 0;
    int currentIndex = 0;
    for (GrowthState* state : states)
    {
        if (state->getPercentage() <= seblingTicks / (float)seblingTicksMax)
        {
            currentIndex = index;
        }
        else
        {
            break;
        }
        index++;
    }
    if (lastSendState != currentIndex)
    {
        updateModel(states.z(currentIndex)->zModel());
        lastSendState = currentIndex;
    }
    return 1;
}

void GrowingPlantBlock::onPostTick()
{
    if (seblingTicks >= (float)seblingTicksMax && !plantSpawned)
    {
        plantSpawned = 1;
        Game::INSTANCE->doLater([this]() {
            Game::INSTANCE->zDimension(getDimensionId())
                ->placeBlock(getPos(), blockTypeAfterGrowth);
        });
    }
}

void GrowingPlantBlock::sendModelInfo(NetworkMessage* zMessage)
{
    GrowthState* current = 0;
    for (GrowthState* state : states)
    {
        if (state->getPercentage() <= seblingTicks / (float)seblingTicksMax)
        {
            current = state;
        }
    }
    if (current)
    {
        zMessage->addressBlock(this);
        Framework::InMemoryBuffer buffer;
        current->zModel()->writeTo(&buffer);
        char* msg = new char[(int)buffer.getSize() + 1];
        msg[0] = 1; // hmodel change
        buffer.lese(msg + 1, (int)buffer.getSize());
        zMessage->setMessage(msg, (int)buffer.getSize() + 1);
    }
}

TickSourceType GrowingPlantBlock::isTickSource() const
{
    return TickSourceType::EACH_TICK;
}

Framework::Text GrowingPlantBlock::getTargetUIML()
{
    return Framework::Text("<targetInfo><text width=\"auto\" height=\"auto\">")
         + name + "\n" + "Growth: "
         + Framework::Text((int)(seblingTicks / (float)seblingTicksMax * 100.f))
         + "%</text></targetInfo>";
}

GrowingPlantBlock* GrowingPlantBlock::addGrowthState(GrowthState* state)
{
    int index = 0;
    for (GrowthState* s : states)
    {
        if (s->getPercentage() > state->getPercentage())
        {
            states.add(state, index);
            return this;
        }
        index++;
    }
    states.add(state);
    return this;
}

GrowingPlantBlockType::GrowingPlantBlockType()
    : BlockType(),
      transparent(1),
      passable(1),
      speedModifier(0.3f),
      interactable(1),
      ticksNeeded(0)
{}

void GrowingPlantBlockType::createSuperBlock(Block* zBlock, Item* zItem) const
{
    GrowingPlantBlock* block = dynamic_cast<GrowingPlantBlock*>(zBlock);
    block->transparent = transparent;
    block->passable = passable;
    block->hardness = getHardness();
    block->speedModifier = speedModifier;
    block->interactable = interactable;
    BlockType::createSuperBlock(zBlock, zItem);
}

void GrowingPlantBlockType::loadSuperBlock(
    Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
{
    BlockType::loadSuperBlock(zBlock, zReader, dimensionId);
    GrowingPlantBlock* block = dynamic_cast<GrowingPlantBlock*>(zBlock);
    zReader->lese((char*)&block->seblingTicks, 4);
}

void GrowingPlantBlockType::saveSuperBlock(
    Block* zBlock, Framework::StreamWriter* zWriter) const
{
    BlockType::saveSuperBlock(zBlock, zWriter);
    GrowingPlantBlock* block = dynamic_cast<GrowingPlantBlock*>(zBlock);
    zWriter->schreibe((char*)&block->seblingTicks, 4);
}

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

Block* GrowingPlantBlockType::createBlock(
    Framework::Vec3<int> position, int dimensionId) const
{
    GrowingPlantBlock* block = new GrowingPlantBlock(getId(),
        position,
        dimensionId,
        ticksNeeded,
        readableName,
        blockTypeIdAfterGrowth);
    for (GrowthState* state : states)
    {
        block->addGrowthState(dynamic_cast<GrowthState*>(state->getThis()));
    }
    return block;
}

GrowingPlantBlockType* GrowingPlantBlockType::addGrowthState(
    float growthPercentage, ModelInfo* model)
{
    states.add(new GrowthState(growthPercentage, model));
    return this;
}

Framework::Text GrowingPlantBlockType::getBlockTypeNameAfterGrowth() const
{
    return blockTypeNameAfterGrowth;
}

void GrowingPlantBlockType::setReadableName(Framework::Text readableName)
{
    this->readableName = readableName;
}

Framework::Text GrowingPlantBlockType::getReadableName() const
{
    return readableName;
}

void GrowingPlantBlockType::setTicksNeeded(int ticksNeeded)
{
    this->ticksNeeded = ticksNeeded;
}

int GrowingPlantBlockType::getTicksNeeded() const
{
    return ticksNeeded;
}

void GrowingPlantBlockType::setTransparent(bool transparent)
{
    this->transparent = transparent;
}

bool GrowingPlantBlockType::isTransparent() const
{
    return transparent;
}

void GrowingPlantBlockType::setPassable(bool passable)
{
    this->passable = passable;
}

bool GrowingPlantBlockType::isPassable() const
{
    return passable;
}

void GrowingPlantBlockType::setSpeedModifier(float speedModifier)
{
    this->speedModifier = speedModifier;
}

float GrowingPlantBlockType::getSpeedModifier() const
{
    return speedModifier;
}

void GrowingPlantBlockType::setInteractable(bool interactable)
{
    this->interactable = interactable;
}

bool GrowingPlantBlockType::isInteractable() const
{
    return interactable;
}

const Framework::RCArray<GrowthState>& GrowingPlantBlockType::getStates() const
{
    return states;
}

void GrowingPlantBlockType::setBlockTypeNameAfterGrowth(
    Framework::Text blockTypeIdAfterGrowth)
{}

ItemType* GrowingPlantBlockType::createItemType() const
{
    return 0;
}

GrowingPlantBlockTypeFactory::GrowingPlantBlockTypeFactory()
    : BlockTypeFactoryBase()
{}

GrowingPlantBlockType* GrowingPlantBlockTypeFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new GrowingPlantBlockType();
}

GrowingPlantBlockType* GrowingPlantBlockTypeFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    GrowingPlantBlockType* result = BlockTypeFactoryBase::fromJson(zJson);
    result->setBlockTypeNameAfterGrowth(
        zJson->zValue("blockTypeAfterGrowth")->asString()->getString());
    result->setReadableName(
        zJson->zValue("readableName")->asString()->getString());
    result->setTicksNeeded(
        (int)zJson->zValue("ticksNeeded")->asNumber()->getNumber());
    result->setTransparent(zJson->zValue("transparent")->asBool()->getBool());
    result->setPassable(zJson->zValue("passable")->asBool()->getBool());
    result->setSpeedModifier(
        (float)zJson->zValue("speedModifier")->asNumber()->getNumber());
    result->setInteractable(zJson->zValue("interactable")->asBool()->getBool());
    for (Framework::JSON::JSONValue* state :
        *zJson->zValue("states")->asArray())
    {
        result->addGrowthState((float)state->asObject()
                                   ->zValue("percentage")
                                   ->asNumber()
                                   ->getNumber(),
            Game::INSTANCE->zTypeRegistry()->fromJson<ModelInfo>(
                state->asObject()->zValue("model")));
    }
    return result;
}

Framework::JSON::JSONObject* GrowingPlantBlockTypeFactory::toJsonObject(
    GrowingPlantBlockType* zObject) const
{
    Framework::JSON::JSONObject* result
        = BlockTypeFactoryBase::toJsonObject(zObject);
    result->addValue("readableName",
        new Framework::JSON::JSONString(zObject->getReadableName()));
    result->addValue(
        "model", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zModel()));
    result->addValue(
        "name", new Framework::JSON::JSONString(zObject->getName()));
    result->addValue(
        "hardness", new Framework::JSON::JSONNumber(zObject->getHardness()));
    result->addValue(
        "mapColor", new Framework::JSON::JSONString(zObject->getMapColor()));
    result->addValue("blockTypeAfterGrowth",
        new Framework::JSON::JSONString(
            zObject->getBlockTypeNameAfterGrowth()));
    result->addValue("ticksNeeded",
        new Framework::JSON::JSONNumber((double)zObject->getTicksNeeded()));
    Framework::JSON::JSONArray* states = new Framework::JSON::JSONArray();
    for (GrowthState* state : zObject->getStates())
    {
        Framework::JSON::JSONObject* stateObj
            = new Framework::JSON::JSONObject();
        stateObj->addValue(
            "model", Game::INSTANCE->zTypeRegistry()->toJson(state->zModel()));
        stateObj->addValue("percentage",
            new Framework::JSON::JSONNumber(state->getPercentage()));
        states->addValue(stateObj);
    }
    result->addValue("states", states);
    Framework::JSON::JSONArray* groupNames = new Framework::JSON::JSONArray();
    for (Framework::Text* groupName : zObject->getGroupNames())
    {
        groupNames->addValue(new Framework::JSON::JSONString(*groupName));
    }
    result->addValue("groupNames", groupNames);
    return result;
}

JSONObjectValidationBuilder* GrowingPlantBlockTypeFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return BlockTypeFactoryBase::addToValidator(
        builder->withRequiredString("readableName")
            ->finishString()
            ->withRequiredNumber("ticksNeeded")
            ->finishNumber()
            ->withRequiredAttribute("blockTypeAfterGrowth",
                Game::INSTANCE->zTypeRegistry()->getValidator<Framework::Text>(
                    BlockTypeNameFactory::TYPE_ID))
            ->withRequiredArray("states")
            ->addAcceptedObjectInArray()
            ->withRequiredNumber("percentage")
            ->whichIsGreaterOrEqual(0.0)
            ->whichIsLessOrEqual(1.0)
            ->finishNumber()
            ->withRequiredAttribute("model",
                Game::INSTANCE->zTypeRegistry()->getValidator<ModelInfo>())
            ->finishObject()
            ->finishArray()
            ->withRequiredBool("transparent")
            ->withDefault(true)
            ->finishBool()
            ->withRequiredBool("passable")
            ->withDefault(true)
            ->finishBool()
            ->withRequiredNumber("speedModifier")
            ->withDefault(0.5)
            ->finishNumber()
            ->withRequiredBool("interactable")
            ->withDefault(true)
            ->finishBool());
}

const char* GrowingPlantBlockTypeFactory::getTypeToken() const
{
    return "growingPlant";
}