{

using namespace df::enums::item_type;

df::world_raws::T_itemdefs &defs = df::global::world->raws.itemdefs;

switch (itype) {

#define ITEM(type,vec,tclass) \

case type: \

return defs.vec.size();

#undef ITEM

default:

return -1;

}

{

type = type_;

subtype = subtype_;

custom = Items::getSubtypeDef(type_, subtype_);

return isValid();

{

if (!ptr)

return decode(item_type::NONE);

else

return decode(ptr->getType(), ptr->getSubtype());

{

std::string rv = ENUM_KEY_STR(item_type, type);

if (custom)

rv += ":" + custom->id;

else if (subtype != -1)

rv += stl_sprintf(":%d", subtype);

return rv;

{

using namespace df::enums::item_type;

switch (type) {

#define ITEM(type,vec,tclass) \

case type: \

if (VIRTUAL_CAST_VAR(cv, df::tclass, custom)) \

return cv->name;

#undef ITEM

default:

break;

}

const char *name = ENUM_ATTR(item_type, caption, type);

if (name)

return name;

return toLower(ENUM_KEY_STR(item_type, type));

{

using namespace df::enums::item_type;

std::vector<std::string> items;

split_string(&items, token, ":");

type = NONE;

subtype = -1;

custom = NULL;

if (items.size() < 1 || items.size() > 2)

return false;

if (items[0] == "NONE")

return true;

if (!find_enum_item(&type, items[0]))

return false;

if (type == NONE)

return false;

if (items.size() == 1)

return true;

df::world_raws::T_itemdefs &defs = df::global::world->raws.itemdefs;

switch (type) {

#define ITEM(type,vec,tclass) \

case type: \

for (size_t i = 0; i < defs.vec.size(); i++) { \

if (defs.vec[i]->id == items[1]) { \

subtype = i; custom = defs.vec[i]; return true; \

} \

} \

break;

#undef ITEM

default:

if (items[1] == "NONE")

return true;

break;

}

return (subtype >= 0);

{

auto other_id = ENUM_ATTR(job_item_vector_id, other, vec_id);

auto explicit_item = ENUM_ATTR(items_other_id, item, other_id);

if (explicit_item != item_type::NONE && type != explicit_item)

return false;

auto generic_item = ENUM_ATTR(items_other_id, generic_item, other_id);

if (generic_item.size > 0)

{

for (size_t i = 0; i < generic_item.size; i++)

if (generic_item.items[i] == type)

return true;

return false;

}

return true;

{

using namespace df::enums::item_type;

if (!isValid())

return mat ? mat->matches(item) : false;

if (Items::isCasteMaterial(type) && mat && !mat->isNone())

return false;

if (!skip_vector && !matches(item.vector_id))

return false;

df::job_item_flags1 ok1, mask1, item_ok1, item_mask1, xmask1;

df::job_item_flags2 ok2, mask2, item_ok2, item_mask2, xmask2;

df::job_item_flags3 ok3, mask3, item_ok3, item_mask3;

ok1.whole = mask1.whole = item_ok1.whole = item_mask1.whole = xmask1.whole = 0;

ok2.whole = mask2.whole = item_ok2.whole = item_mask2.whole = xmask2.whole = 0;

ok3.whole = mask3.whole = item_ok3.whole = item_mask3.whole = 0;

if (mat) {

mat->getMatchBits(ok1, mask1);

mat->getMatchBits(ok2, mask2);

mat->getMatchBits(ok3, mask3);

}

#define OK(id,name) item_ok##id.bits.name = true

#define RQ(id,name) item_mask##id.bits.name = true

// Set up the flag mask

RQ(1,millable); RQ(1,sharpenable); RQ(1,distillable); RQ(1,processable); RQ(1,bag);

RQ(1,extract_bearing_plant); RQ(1,extract_bearing_fish); RQ(1,extract_bearing_vermin);

RQ(1,processable_to_vial); RQ(1,processable_to_bag); RQ(1,processable_to_barrel);

RQ(1,solid); RQ(1,tameable_vermin); RQ(1,sand_bearing); RQ(1,milk); RQ(1,milkable);

RQ(1,not_bin); RQ(1,lye_bearing);

RQ(2,dye); RQ(2,dyeable); RQ(2,dyed); RQ(2,glass_making); RQ(2,screw);

RQ(2,building_material); RQ(2,fire_safe); RQ(2,magma_safe);

RQ(2,totemable); RQ(2,plaster_containing); RQ(2,body_part); RQ(2,lye_milk_free);

RQ(2,blunt); RQ(2,unengraved); RQ(2,hair_wool);

RQ(3,any_raw_material); RQ(3,non_pressed); RQ(3,food_storage);

// only checked if boulder

xmask2.bits.non_economic = true;

// Compute the ok mask

OK(1,solid);

OK(1,not_bin);

// TODO: furniture, ammo, finished good, craft

switch (type) {

case PLANT:

OK(1,millable); OK(1,processable);

OK(1,distillable);

OK(1,extract_bearing_plant);

OK(1,processable_to_vial);

OK(1,processable_to_bag);

OK(1,processable_to_barrel);

break;

case BOULDER:

OK(1,sharpenable);

xmask2.bits.non_economic = false;

case BAR:

OK(3,any_raw_material);

case BLOCKS:

case WOOD:

OK(2,building_material);

OK(2,fire_safe); OK(2,magma_safe);

break;

case VERMIN:

OK(1,extract_bearing_fish);

OK(1,extract_bearing_vermin);

OK(1,tameable_vermin);

OK(1,milkable);

break;

case DRINK:

item_ok1.bits.solid = false;

break;

case ROUGH:

OK(2,glass_making);

break;

case ANIMALTRAP:

case CAGE:

OK(1,milk);

OK(1,milkable);

xmask1.bits.cookable = true;

break;

case BUCKET:

case FLASK:

OK(1,milk);

xmask1.bits.cookable = true;

break;

case TOOL:

OK(1,lye_bearing);

OK(1,milk);

OK(2,lye_milk_free);

OK(2,blunt);

xmask1.bits.cookable = true;

if (VIRTUAL_CAST_VAR(def, df::itemdef_toolst, custom)) {

df::tool_uses key(tool_uses::FOOD_STORAGE);

if (linear_index(def->tool_use, key) >= 0)

OK(3,food_storage);

} else {

OK(3,food_storage);

}

break;

case BARREL:

OK(1,lye_bearing);

OK(1,milk);

OK(2,lye_milk_free);

OK(3,food_storage);

xmask1.bits.cookable = true;

break;

case BOX:

OK(1,bag); OK(1,sand_bearing); OK(1,milk);

OK(2,dye); OK(2,plaster_containing);

xmask1.bits.cookable = true;

break;

case BIN:

item_ok1.bits.not_bin = false;

break;

case LIQUID_MISC:

item_ok1.bits.solid = false;

OK(1,milk);

break;

case POWDER_MISC:

OK(2,dye);

case GLOB:

OK(3,any_raw_material);

OK(3,non_pressed);

break;

case THREAD:

case CLOTH:

OK(2,dyeable); OK(2,dyed);

break;

case WEAPON:

case AMMO:

case ROCK:

OK(2,blunt);

break;

case TRAPCOMP:

if (VIRTUAL_CAST_VAR(def, df::itemdef_trapcompst, custom)) {

if (def->flags.is_set(trapcomp_flags::IS_SCREW))

OK(2,screw);

} else {

OK(2,screw);

}

OK(2,blunt);

break;

case CORPSE:

case CORPSEPIECE:

OK(2,totemable);

OK(2,body_part);

OK(2,hair_wool);

break;

case SLAB:

OK(2,unengraved);

break;

case ANVIL:

OK(2,fire_safe); OK(2,magma_safe);

break;

default:

break;

}

if ((item_ok1.whole & ~item_mask1.whole) ||

(item_ok2.whole & ~item_mask2.whole) ||

(item_ok3.whole & ~item_mask3.whole))

Core::printerr("ItemTypeInfo.matches inconsistent\n");

#undef OK

#undef RQ

mask1.whole &= ~xmask1.whole;

mask2.whole &= ~xmask2.whole;

return bits_match(item.flags1.whole, ok1.whole, mask1.whole) &&

bits_match(item.flags2.whole, ok2.whole, mask2.whole) &&

bits_match(item.flags3.whole, ok3.whole, mask3.whole) &&

bits_match(item.flags1.whole, item_ok1.whole, item_mask1.whole) &&

bits_match(item.flags2.whole, item_ok2.whole, item_mask2.whole) &&

bits_match(item.flags3.whole, item_ok3.whole, item_mask3.whole);

{

if(!itembase)

return false;

df::item * itreal = (df::item *) itembase;

item.origin = itembase;

item.x = itreal->pos.x;

item.y = itreal->pos.y;

item.z = itreal->pos.z;

item.id = itreal->id;

item.age = itreal->age;

item.flags = itreal->flags;

item.matdesc.item_type = itreal->getType();

item.matdesc.item_subtype = itreal->getSubtype();

item.matdesc.mat_type = itreal->getMaterial();

item.matdesc.mat_index = itreal->getMaterialIndex();

item.wear_level = itreal->getWear();

item.quality = itreal->getQuality();

item.quantity = itreal->getStackSize();

return true;

{

CHECK_NULL_POINTER(item);

for (int i = item->general_refs.size()-1; i >= 0; i--)

{

df::general_ref *ref = item->general_refs[i];

if (ref->getType() != general_ref_type::UNIT_ITEMOWNER)

continue;

if (auto cur = ref->getUnit())

{

if (cur == unit)

return true;

erase_from_vector(cur->owned_items, item->id);

}

delete ref;

vector_erase_at(item->general_refs, i);

}

item->flags.bits.owned = false;

if (unit)

{

auto ref = df::allocate<df::general_ref_unit_itemownerst>();

if (!ref)

return false;

item->flags.bits.owned = true;

ref->unit_id = unit->id;

insert_into_vector(unit->owned_items, item->id);

item->general_refs.push_back(ref);

}

return true;

{

CHECK_NULL_POINTER(item);

items->clear();

for (size_t i = 0; i < item->general_refs.size(); i++)

{

df::general_ref *ref = item->general_refs[i];

if (ref->getType() != general_ref_type::CONTAINS_ITEM)

continue;

auto child = ref->getItem();

if (child)

items->push_back(child);

}

{

CHECK_NULL_POINTER(item);

/* Function reverse-engineered from DF code. */

if (item->flags.bits.removed)

return df::coord();

if (item->flags.bits.in_inventory)

{

for (size_t i = 0; i < item->general_refs.size(); i++)

{

df::general_ref *ref = item->general_refs[i];

switch (ref->getType())

{

case general_ref_type::CONTAINED_IN_ITEM:

if (auto item2 = ref->getItem())

return getPosition(item2);

break;

case general_ref_type::UNIT_HOLDER:

if (auto unit = ref->getUnit())

return Units::getPosition(unit);

break;

/*case general_ref_type::BUILDING_HOLDER:

default:

break;

}

}

for (size_t i = 0; i < item->specific_refs.size(); i++)

{

df::specific_ref *ref = item->specific_refs[i];

switch (ref->type)

{

case specific_ref_type::VERMIN_ESCAPED_PET:

return ref->vermin->pos;

default:

break;

}

}

return df::coord();

}

return item->pos;

{

if (quality > 0 && quality <= 5) {

char c = quality_table[quality];

tmp = c + tmp + c;

}

{

CHECK_NULL_POINTER(item);

std::string tmp;

item->getItemDescription(&tmp, type);

if (decorate) {

if (item->flags.bits.foreign)

tmp = "(" + tmp + ")";

addQuality(tmp, item->getQuality());

if (item->isImproved()) {

tmp = "<" + tmp + ">";

addQuality(tmp, item->getImprovementQuality());

}

}

return tmp;

{

if (inv_item->mode == df::unit_inventory_item::Worn ||

inv_item->mode == df::unit_inventory_item::WrappedAround)

{

unit->flags2.bits.calculated_inventory = false;

unit->flags2.bits.calculated_insulation = false;

}

else if (inv_item->mode == df::unit_inventory_item::StuckIn)

{

unit->flags3.bits.stuck_weapon_computed = false;

}

{

if (!item->specific_refs.empty())

return false;

if (item->world_data_id != -1)

return false;

for (size_t i = 0; i < item->general_refs.size(); i++)

{

df::general_ref *ref = item->general_refs[i];

switch (ref->getType())

{

case general_ref_type::PROJECTILE:

case general_ref_type::BUILDING_HOLDER:

case general_ref_type::BUILDING_CAGED:

case general_ref_type::BUILDING_TRIGGER:

case general_ref_type::BUILDING_TRIGGERTARGET:

case general_ref_type::BUILDING_CIVZONE_ASSIGNED:

return false;

default:

continue;

}

}

if (item->flags.bits.on_ground)

{

if (!mc.removeItemOnGround(item))

Core::printerr("Item was marked on_ground, but not in block: %d (%d,%d,%d)\n",

item->id, item->pos.x, item->pos.y, item->pos.z);

item->flags.bits.on_ground = false;

return true;

}

else if (item->flags.bits.in_inventory)

{

bool found = false;

for (int i = item->general_refs.size()-1; i >= 0; i--)

{

df::general_ref *ref = item->general_refs[i];

switch (ref->getType())

{

case general_ref_type::CONTAINED_IN_ITEM:

if (auto item2 = ref->getItem())

{

// Viewscreens hold general_ref_contains_itemst pointers

for (auto screen = Core::getTopViewscreen(); screen; screen = screen->parent)

{

auto vsitem = strict_virtual_cast<df::viewscreen_itemst>(screen);

if (vsitem && vsitem->item == item2)

return false;

}

item2->flags.bits.weight_computed = false;

removeRef(item2->general_refs, general_ref_type::CONTAINS_ITEM, item->id);

}

break;

case general_ref_type::UNIT_HOLDER:

if (auto unit = ref->getUnit())

{

// Unit view sidebar holds inventory item pointers

if (ui->main.mode == ui_sidebar_mode::ViewUnits &&

(!ui_selected_unit ||

vector_get(world->units.active, *ui_selected_unit) == unit))

return false;

for (int i = unit->inventory.size()-1; i >= 0; i--)

{

df::unit_inventory_item *inv_item = unit->inventory[i];

if (inv_item->item != item)

continue;

resetUnitInvFlags(unit, inv_item);

vector_erase_at(unit->inventory, i);

delete inv_item;

}

}

break;

default:

continue;

}

found = true;

vector_erase_at(item->general_refs, i);

delete ref;

}

if (!found)

return false;

item->flags.bits.in_inventory = false;

return true;

}

else if (item->flags.bits.removed)

{

item->flags.bits.removed = false;

if (item->flags.bits.garbage_collect)

{

item->flags.bits.garbage_collect = false;

item->categorize(true);

}

return true;

}

else

return false;

{

item->pos = pos;

item->flags.bits.on_ground = true;

if (!mc.addItemOnGround(item))

Core::printerr("Could not add item %d to ground at (%d,%d,%d)\n",

item->id, pos.x, pos.y, pos.z);

{

CHECK_NULL_POINTER(item);

auto pos = getPosition(item);

if (!detachItem(mc, item))

return false;

if (pos.isValid())

item->pos = pos;

if (!no_uncat)

item->uncategorize();

item->flags.bits.removed = true;

item->flags.bits.garbage_collect = !no_uncat;

return true;