FactoryCraft-Server/FactoryCraft/Animal.cpp

#include "Animal.h"

#include "Dimension.h"
#include "Game.h"
#include "TypeRegistry.h"

Animal::Animal(
    int typeId, Framework::Vec3<float> location, int dimensionId, int entityId)
    : Entity(typeId, location, dimensionId, entityId)
{}

Animal::~Animal()
{
    if (ai)
    {
        ai->release();
    }
}

void Animal::setAI(AnimalAI* ai)
{
    if (this->ai)
    {
        this->ai->release();
    }
    this->ai = ai;
}

bool Animal::interact(Item* zItem, Entity* zActor)
{
    return false;
}

void Animal::takeDamage(Entity* zSource, float damage)
{
    if (damage > 0)
    {
        ai->onDamage(zSource, damage);
    }
    Entity::takeDamage(zSource, damage);
}

void Animal::tick(const Dimension* zDimension)
{
    Entity::tick(zDimension);
}

AnimalEntityType::AnimalEntityType()
    : EntityType()
{}

AnimalEntityType::~AnimalEntityType()
{
    if (ai)
    {
        ai->release();
    }
}

void AnimalEntityType::loadSuperEntity(
    Entity* zEntity, Framework::StreamReader* zReader) const
{
    EntityType::loadSuperEntity(zEntity, zReader);
}

void AnimalEntityType::saveSuperEntity(
    Entity* zEntity, Framework::StreamWriter* zWriter) const
{
    EntityType::saveSuperEntity(zEntity, zWriter);
}

Entity* AnimalEntityType::createEntity(
    Framework::Vec3<float> position, int dimensionId, int entityId) const
{
    Animal* result = new Animal(getId(), position, dimensionId, entityId);
    //result->setAI(Game::INSTANCE->zTypeRegistry()->fromJson<AnimalAI>(ai));
    return result;
}

AnimalEntityTypeFactory::AnimalEntityTypeFactory()
    : EntityTypeFactoryBase()
{}

AnimalEntityType* AnimalEntityTypeFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    AnimalEntityType* result = new AnimalEntityType();
    result->ai = zJson->getValue("ai")->asObject();
    return result;
}

void AnimalEntityTypeFactory::addToJson(
    Framework::JSON::JSONObject* zJson, AnimalEntityType* zObject) const
{
    zJson->addValue("ai", zObject->ai->clone());
}

const char* AnimalEntityTypeFactory::getTypeToken() const
{
    return "animal";
}

JSONObjectValidationBuilder* AnimalEntityTypeFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return EntityTypeFactoryBase::addToValidator(builder)
        /* TODO: write AnimalAI factories
        ->withRequiredAttribute(
        "ai", Game::INSTANCE->zTypeRegistry()->getValidator<AnimalAI>())*/
        ;
}