FactoryCraft-Server/FactoryCraft/Item.cpp

#include "Item.h"

#include <Text.h>

#include "Game.h"

Item::Item(int itemTypeId, const char* name)
    : ReferenceCounter(),
      itemTypeId(itemTypeId),
      blockTypeId(0),
      hp(1),
      maxHp(1),
      durability(1),
      maxDurability(1),
      eatable(0),
      placeable(0),
      equippable(0),
      solid(1),
      usable(0),
      maxStackSize(50),
      name(name)
{
    foodEffect = [](Entity* e) {};
}

void Item::setHp(float hp)
{
    this->hp = hp;
}

void Item::setDurability(float durability)
{
    this->durability = durability;
}

void Item::tick() {}

void Item::setFoodEffect(std::function<void(Entity*)> foodEffect)
{
    this->foodEffect = foodEffect;
}

const ItemType* Item::zItemType() const
{
    return StaticRegistry<ItemType>::INSTANCE.zElement(itemTypeId);
}

int Item::getTypeId() const
{
    return itemTypeId;
}

const BlockType* Item::zPlacedBlockType() const
{
    return StaticRegistry<BlockType>::INSTANCE.zElement(blockTypeId);
}

float Item::getHp() const
{
    return hp;
}

float Item::getDurability() const
{
    return durability;
}

bool Item::isUsable() const
{
    return usable;
}

bool Item::isEatable() const
{
    return eatable;
}

bool Item::isPlaceable() const
{
    return placeable;
}

bool Item::isEquippable() const
{
    return equippable;
}

bool Item::isSolid() const
{
    return solid;
}

float Item::getMaxDurability() const
{
    return maxDurability;
}

int Item::getMaxStackSize() const
{
    return maxStackSize;
}

float Item::getMaxHp() const
{
    return maxHp;
}

const Framework::Text& Item::getName() const
{
    return name;
}

bool Item::canBeStackedWith(const Item* zItem) const
{
    return itemTypeId == zItem->itemTypeId && durability == maxDurability
        && zItem->durability == zItem->durability && maxHp == zItem->maxHp
        && eatable == zItem->eatable && placeable == zItem->placeable
        && equippable == zItem->eatable && solid == zItem->solid
        && usable == zItem->usable && maxStackSize == zItem->maxStackSize
        && name.istGleich(zItem->name);
}

bool Item::canBePlacedAt(int dimensionId, Vec3<int> worldPos) const
{
    auto b = Game::INSTANCE->zBlockAt(worldPos, dimensionId);
    return (b.isA() && b.getA()->zBlockType()->getId() == BlockTypeEnum::AIR)
        || (b.isB() && b.getB() == BlockTypeEnum::AIR);
}

void Item::onPlaced()
{
    hp = 0;
}

Framework::Text Item::getTooltipUIML() const
{
    return Framework::Text("<tip><text width=\"auto\" height=\"auto\">") + name
         + "</text></tip>";
}

void Item::applyInventoryEffects(Entity* zTarget)
{
    foodEffect(zTarget);
}

void Item::removeInventoryEffects(Entity* zTarget) {}

void Item::applyEquippedEffects(Entity* zTarget) {}

void Item::removeEquippedEffects(Entity* zTarget) {}

void Item::applyFoodEffects(Entity* zTarget) {}