4jcraft/Minecraft.World/Containers/MerchantRecipe.cpp

#include "../Platform/stdafx.h"

#include "MerchantRecipe.h"

void MerchantRecipe::_init(std::shared_ptr<ItemInstance> buyA,
                           std::shared_ptr<ItemInstance> buyB,
                           std::shared_ptr<ItemInstance> sell) {
    this->buyA = buyA;
    this->buyB = buyB;
    this->sell = sell;
    uses = 0;
    maxUses = 7;
}

MerchantRecipe::MerchantRecipe(CompoundTag* tag) {
    buyA = nullptr;
    buyB = nullptr;
    sell = nullptr;
    uses = 0;
    load(tag);
}

MerchantRecipe::MerchantRecipe(std::shared_ptr<ItemInstance> buyA,
                               std::shared_ptr<ItemInstance> buyB,
                               std::shared_ptr<ItemInstance> sell, int uses,
                               int maxUses) {
    _init(buyA, buyB, sell);
    this->uses = uses;
    this->maxUses = maxUses;
}

MerchantRecipe::MerchantRecipe(std::shared_ptr<ItemInstance> buy,
                               std::shared_ptr<ItemInstance> sell) {
    _init(buy, nullptr, sell);
}

MerchantRecipe::MerchantRecipe(std::shared_ptr<ItemInstance> buy, Item* sell) {
    _init(buy, nullptr, std::shared_ptr<ItemInstance>(new ItemInstance(sell)));
}

MerchantRecipe::MerchantRecipe(std::shared_ptr<ItemInstance> buy, Tile* sell) {
    _init(buy, nullptr, std::shared_ptr<ItemInstance>(new ItemInstance(sell)));
}

std::shared_ptr<ItemInstance> MerchantRecipe::getBuyAItem() { return buyA; }

std::shared_ptr<ItemInstance> MerchantRecipe::getBuyBItem() { return buyB; }

bool MerchantRecipe::hasSecondaryBuyItem() { return buyB != NULL; }

std::shared_ptr<ItemInstance> MerchantRecipe::getSellItem() { return sell; }

bool MerchantRecipe::isSame(MerchantRecipe* other) {
    if (buyA->id != other->buyA->id || sell->id != other->sell->id) {
        return false;
    }
    return (buyB == NULL && other->buyB == NULL) ||
           (buyB != NULL && other->buyB != NULL && buyB->id == other->buyB->id);
}

bool MerchantRecipe::isSameSameButBetter(MerchantRecipe* other) {
    // same deal, but cheaper
    return isSame(other) &&
           (buyA->count < other->buyA->count ||
            (buyB != NULL && buyB->count < other->buyB->count));
}

int MerchantRecipe::getUses() { return uses; }

int MerchantRecipe::getMaxUses() { return maxUses; }

void MerchantRecipe::increaseUses() { uses++; }

void MerchantRecipe::increaseMaxUses(int amount) { maxUses += amount; }

bool MerchantRecipe::isDeprecated() { return uses >= maxUses; }

void MerchantRecipe::enforceDeprecated() { uses = maxUses; }

void MerchantRecipe::load(CompoundTag* tag) {
    CompoundTag* buyTag = tag->getCompound(L"buy");
    buyA = ItemInstance::fromTag(buyTag);
    CompoundTag* sellTag = tag->getCompound(L"sell");
    sell = ItemInstance::fromTag(sellTag);
    if (tag->contains(L"buyB")) {
        buyB = ItemInstance::fromTag(tag->getCompound(L"buyB"));
    }
    if (tag->contains(L"uses")) {
        uses = tag->getInt(L"uses");
    }
    if (tag->contains(L"maxUses")) {
        maxUses = tag->getInt(L"maxUses");
    } else {
        maxUses = 7;
    }
}

CompoundTag* MerchantRecipe::createTag() {
    CompoundTag* tag = new CompoundTag();
    tag->putCompound(L"buy", buyA->save(new CompoundTag(L"buy")));
    tag->putCompound(L"sell", sell->save(new CompoundTag(L"sell")));
    if (buyB != NULL) {
        tag->putCompound(L"buyB", buyB->save(new CompoundTag(L"buyB")));
    }
    tag->putInt(L"uses", uses);
    tag->putInt(L"maxUses", maxUses);
    return tag;
}