FactoryCraft-Server/FactoryCraft/ItemType.cpp

#include "ItemType.h"

#include <InMemoryBuffer.h>
#include <Logging.h>

#include "Game.h"
#include "ItemSkill.h"
#include "ItemStack.h"
#include "UIMLBuilder.h"

ItemType::ItemType()
    : ReferenceCounter(),
      name(""),
      tooltipUIML(0),
      model(0),
      maxStackSize(0),
      groups()
{}

ItemType::~ItemType()
{
    if (model) model->release();
    if (tooltipUIML) tooltipUIML->release();
}

void ItemType::loadSuperItem(
    Item* zItem, Framework::StreamReader* zReader) const
{
    zReader->lese((char*)&zItem->hp, 4);
    zReader->lese((char*)&zItem->maxHp, 4);
    zReader->lese((char*)&zItem->durability, 4);
    zReader->lese((char*)&zItem->maxDurability, 4);
    unsigned char flags = 0;
    zReader->lese((char*)&flags, 1);
    zItem->eatable = (flags | 1) == flags;
    zItem->placeable = (flags | 2) == flags;
    zItem->equippable = (flags | 4) == flags;
    zItem->solid = (flags | 8) == flags;
    zItem->usable = (flags | 16) == flags;
    unsigned char len = 0;
    zReader->lese((char*)&len, 1);
    zItem->name.fillText(' ', len);
    zReader->lese((char*)zItem->name.getText(), len);
}

void ItemType::saveSuperItem(
    const Item* zItem, Framework::StreamWriter* zWriter) const
{
    zWriter->schreibe((char*)&zItem->hp, 4);
    zWriter->schreibe((char*)&zItem->maxHp, 4);
    zWriter->schreibe((char*)&zItem->durability, 4);
    zWriter->schreibe((char*)&zItem->maxDurability, 4);
    unsigned char flags
        = (unsigned char)((zItem->usable << 4) | (zItem->solid << 3)
                          | (zItem->equippable << 2) | (zItem->placeable << 1)
                          | (int)zItem->eatable);
    zWriter->schreibe((char*)&flags, 1);
    unsigned char len = (unsigned char)zItem->name.getLength();
    zWriter->schreibe((char*)&len, 1);
    zWriter->schreibe(zItem->name, len);
}

bool ItemType::initialize(Game* zGame)
{
    return true;
}

const ItemType* ItemType::zBrokenItemType() const
{
    return 0;
}

ItemStack* ItemType::createItemStack(int size) const
{
    Item* item = createItem();
    if (!item) return 0;
    return new ItemStack(item, MIN(size, item->getMaxStackSize()));
}

ItemSkill* ItemType::createDefaultItemSkill() const
{
    return 0;
}

void ItemType::levelUpItemSkill(ItemSkill* zSkill) const {}

Item* ItemType::cloneItem(const Item* zItem) const
{
    Framework::InMemoryBuffer buffer;
    saveItem(zItem, &buffer);
    return loadItem(&buffer);
}

Item* ItemType::breakItem(const Item* zItem) const
{
    return 0;
}

Item* ItemType::loadItem(Framework::StreamReader* zReader) const
{
    Item* item = createItem();
    loadSuperItem(item, zReader);
    return item;
}

void ItemType::saveItem(
    const Item* zItem, Framework::StreamWriter* zWriter) const
{
    saveSuperItem(zItem, zWriter);
}

void ItemType::setItemAttribute(
    Item* zItem, Framework::Text name, Framework::JSON::JSONValue* zValue) const
{
    bool ok = true;
    if (zValue->getType() == Framework::AbstractType::NUMBER)
    {
        if (name.istGleich("hp"))
            zItem->hp = (float)zValue->asNumber()->getNumber();
        else if (name.istGleich("maxHp"))
            zItem->maxHp = (float)zValue->asNumber()->getNumber();
        else if (name.istGleich("durability"))
            zItem->durability = (float)zValue->asNumber()->getNumber();
        else if (name.istGleich("maxDurability"))
            zItem->maxDurability = (float)zValue->asNumber()->getNumber();
        else
            ok = false;
    }
    else if (zValue->getType() == Framework::AbstractType::STRING)
    {
        if (name.istGleich("name"))
            zItem->name = zValue->asString()->getString();
        else
            ok = false;
    }
    if (!ok)
    {
        Framework::Logging::warning()
            << "Invalid Item Attribute '" << name << "' for item type '"
            << getName() << "'\n";
    }
}

void ItemType::addItemAttributes(
    Item* zItem, Framework::JSON::JSONObject* zItemObjet) const
{
    zItemObjet->addValue(
        "hp", new Framework::JSON::JSONNumber((double)zItem->hp));
    zItemObjet->addValue(
        "maxHp", new Framework::JSON::JSONNumber((double)zItem->maxHp));
    zItemObjet->addValue("durability",
        new Framework::JSON::JSONNumber((double)zItem->durability));
    zItemObjet->addValue("maxDurability",
        new Framework::JSON::JSONNumber((double)zItem->maxDurability));
    zItemObjet->addValue("name", new Framework::JSON::JSONString(zItem->name));
}

void ItemType::setTypeId(int id)
{
    this->id = id;
}

int ItemType::getId() const
{
    return id;
}

void ItemType::setName(Framework::Text name)
{
    this->name = name;
    if (!tooltipUIML)
    {
        tooltipUIML
            = UIMLBuilder::createTooltip()
                  ->addElement(UIMLBuilder::createTextAuto(name)->build())
                  ->build();
    }
}

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

void ItemType::setTooltipUIML(Framework::Text tooltipUIML)
{
    if (this->tooltipUIML)
    {
        this->tooltipUIML->release();
    }
    this->tooltipUIML = new Framework::XML::Element(tooltipUIML);
}

Framework::XML::Element* ItemType::getTooltipUIML() const
{
    return dynamic_cast<Framework::XML::Element*>(tooltipUIML->getThis());
}

void ItemType::setModel(ModelInfo* model)
{
    if (this->model) this->model->release();
    this->model = model;
}

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

void ItemType::setMaxStackSize(int maxStackSize)
{
    this->maxStackSize = maxStackSize;
}

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

void ItemType::addGroup(Framework::Text group)
{
    groups.add(new Framework::Text(group));
}

const Framework::RCArray<Framework::Text>& ItemType::getGroups() const
{
    return groups;
}

Item* ItemType::createBasicItem(int id,
    const char* name,
    float hp,
    float maxHp,
    float durability,
    float maxDurability,
    bool eatable,
    bool placeable,
    bool equippable,
    bool solid,
    bool usable)
{
    Item* item = new Item(id, name);
    item->hp = hp;
    item->maxHp = maxHp;
    item->durability = durability;
    item->maxDurability = maxDurability;
    item->eatable = eatable;
    item->placeable = placeable;
    item->equippable = equippable;
    item->solid = solid;
    item->usable = usable;
    return item;
}

int ItemType::getTypeId(const char* name)
{
    for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
    {
        if (Game::INSTANCE->zItemType(i)
            && Game::INSTANCE->zItemType(i)->getName().istGleich(name))
            return Game::INSTANCE->zItemType(i)->getId();
    }
    return 0;
}

const ItemType* ItemType::zByName(const char* name)
{
    for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
    {
        if (Game::INSTANCE->zItemType(i)
            && Game::INSTANCE->zItemType(i)->getName().istGleich(name))
            return Game::INSTANCE->zItemType(i);
    }
    return 0;
}