type = type_;

subtype = subtype_;

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

return isValid();

if (ptr)

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

return decode(item_type::NONE);

string rv = ENUM_KEY_STR(item_type, type);

if (custom)

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

else if (subtype != -1 && type != item_type::PLANT_GROWTH)

rv += fmt::format(":{}", 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;

}

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

return name;

return toLower_cp437(ENUM_KEY_STR(item_type, type));

{ using namespace df::enums::item_type;

vector<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]) || type == NONE)

return false;

if (items.size() == 1)

return true;

auto &defs = 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;

bool skip_vector, df::item_type itype)

{ using namespace df::enums::item_type;

if (!isValid())

return mat ? mat->matches(jitem, itype) : false;

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

return false;

if (!skip_vector && !matches(jitem.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;

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,processable);

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

RQ(1,processable_to_vial); 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(1, undisturbed);

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,plant); RQ(2,silk); RQ(2,yarn);

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,extract_bearing_plant);

OK(1,processable_to_vial);

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:

OK(2,lye_milk_free);

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)) {

if (linear_index(def->tool_use, tool_uses::FOOD_STORAGE) >= 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 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:

if ((!jitem.flags2.bits.plant && ok2.bits.plant) ||

(!jitem.flags2.bits.silk && ok2.bits.silk) ||

(!jitem.flags2.bits.yarn && ok2.bits.yarn))

{ // Material flags must match exactly

return false;

}

OK(1,undisturbed);

OK(2,plant);

OK(2,silk);

OK(2,yarn);

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(jitem.flags1.whole, ok1.whole, mask1.whole)

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

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

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

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

&& bits_match(jitem.flags3.whole, item_ok3.whole, item_mask3.whole);

{ using namespace df::enums::item_type;

auto &defs = world->raws.itemdefs;

switch (itype)

{

#define ITEM(type,vec,tclass) \

case type: \

return defs.vec.size();

#undef ITEM

default:

return -1;

}

CHECK_NULL_POINTER(item);

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

{

auto 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);

}

vector_erase_at(item->general_refs, i);

delete ref;

}

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;

{ // Reverse-engineered from ambushing unit code.

CHECK_NULL_POINTER(item);

if (init_ref) {

spec_ref.type = specific_ref_type::ITEM_GENERAL;

spec_ref.data.object = item;

}

if (item->flags.bits.removed || !item->flags.bits.in_inventory)

return;

for (auto gref : item->general_refs)

{

switch (gref->getType())

{

case general_ref_type::CONTAINED_IN_ITEM:

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

return Items::getOuterContainerRef(spec_ref, item2);

break;

case general_ref_type::UNIT_HOLDER:

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

return Units::getOuterContainerRef(spec_ref, unit);

break;

default:

break;

}

}

if (auto sref = getSpecificRef(item, specific_ref_type::VERMIN_ESCAPED_PET)) {

spec_ref.type = specific_ref_type::VERMIN_EVENT;

spec_ref.data.vermin = sref->data.vermin;

}

return;

CHECK_NULL_POINTER(item);

CHECK_NULL_POINTER(items);

items->clear();

for (auto gref : item->general_refs) {

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

continue;

else if (auto child = gref->getItem())

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 (auto gref : item->general_refs)

{

switch (gref->getType())

{

case general_ref_type::CONTAINED_IN_ITEM:

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

return getPosition(item2);

break;

case general_ref_type::UNIT_HOLDER:

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

return Units::getPosition(unit);

break;

/*case general_ref_type::BUILDING_HOLDER: // Note: Not "in_inventory"

default:

break;

}

}

if (auto sref = getSpecificRef(item, specific_ref_type::VERMIN_ESCAPED_PET))

return sref->data.vermin->pos;

return df::coord();

}

return item->pos;

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

char c = quality_table[quality];

tmp = c + tmp + c;

}

for (auto content : vec)

{

auto w_contents = df::written_content::find(content);

if (w_contents && !w_contents->title.empty()) {

result = w_contents->title;

return true;

}

}

return false;

string result;

for (auto imp : vec) {

if (auto page = virtual_cast<df::itemimprovement_pagesst>(imp))

if (title_from_content(result, page->contents))

break;

if (auto writing = virtual_cast<df::itemimprovement_writingst>(imp))

if (title_from_content(result, writing->contents))

break;

}

return result;

CHECK_NULL_POINTER(item);

if (auto book = virtual_cast<df::item_bookst>(item))

return book->title.empty() ? title_from_imps(book->improvements) : book->title;

if (auto tool = virtual_cast<df::item_toolst>(item))

if (tool->hasToolUse(tool_uses::CONTAIN_WRITING))

return title_from_imps(tool->improvements);

return "";

CHECK_NULL_POINTER(item);

string tmp;

item->getItemDescription(&tmp, type);

if (decorate) {

// Special indicators get added in a specific order

// Innermost is at the top, and outermost is at the bottom

// First, figure out the quality levels we're going to display

int craftquality = item->getQuality();

int craftquality_only_imps = item->getImprovementQuality();

bool has_displayed_item_improvements = item->isImproved();

if (!has_displayed_item_improvements && (craftquality < craftquality_only_imps))

craftquality = craftquality_only_imps;

// First, actual item quality

addQuality(tmp, craftquality);

// Next, magic enchants

if (item->getMagic() != NULL)

tmp = '\x11' + tmp + '\x10'; // <| |>

// Next, improvements

if (has_displayed_item_improvements) {

tmp = '\xAE' + tmp + '\xAF'; // («) + tmp + (»)

if (df::global::d_init->display.flags.is_set(d_init_flags1::SHOW_IMP_QUALITY))

addQuality(tmp, craftquality_only_imps);

}

// Dwarf mode only, forbid/foreign

if (*df::global::gamemode == game_mode::DWARF) {

if (item->flags.bits.forbid)

tmp = '{' + tmp + '}';

if (item->flags.bits.foreign)

tmp = '(' + tmp + ')';

}

// Wear

switch (item->getWear())

{

case 1: tmp = 'x' + tmp + 'x'; break;

case 2: tmp = 'X' + tmp + 'X'; break;

case 3: tmp = "XX" + tmp + "XX"; break;

}

// Fire

if (item->flags.bits.on_fire)

tmp = '\x13' + tmp + '\x13'; // !! !!

// Finally, Adventure civzone

if ((*df::global::gamemode == game_mode::ADVENTURE) &&

Items::getGeneralRef(item, general_ref_type::BUILDING_CIVZONE_ASSIGNED) != NULL)

tmp = '$' + tmp + '$';

}

return tmp;

ItemTypeInfo iti;

iti.decode(item);

auto str = capitalize_string_words(iti.toString());

if (str == "Trapparts")

str = "Mechanism";

return str;

if (auto name = Items::getBookTitle(item); !name.empty())

return name;

if (auto artifact = get_artifact(item); artifact && artifact->name.has_name)

return Translation::translateName(&artifact->name) +

", " + Translation::translateName(&artifact->name, true) +

" (" + get_item_type_str(item) + ")";

return Items::getDescription(item, 0, true);

CHECK_NULL_POINTER(item);

auto desc = get_base_desc(item);

if (auto gref = Items::getGeneralRef(item, general_ref_type::CONTAINS_UNIT)) {

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

{

auto str = " [" + Units::getReadableName(unit);

if (Units::isInvader(unit) || Units::isOpposedToLife(unit))

str += " (hostile)";

return desc + str + "]";

}

}

return desc;

{ // Replaces the MapCache fn

auto block = Maps::getTileBlock(item->pos);

if (!block)

return false;

erase_from_vector(block->items, item->id);

for (auto b_item : block->items)

{

auto other_item = df::item::find(b_item);

if (other_item && other_item->pos == item->pos)

return true; // Don't touch occupancy

}

auto &occ = index_tile(block->occupancy, item->pos);

occ.bits.item = false;

if (occ.bits.building == tile_building_occ::Planned)

if (auto bld = Buildings::findAtTile(item->pos))

{ // TODO: Maybe recheck other tiles like the game does.

bld->flags.bits.site_blocked = false;

}

return true;

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

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

{

unit->flags2.bits.calculated_inventory = false;

unit->flags2.bits.calculated_insulation = false;

}

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

unit->flags3.bits.stuck_weapon_computed = false;

{ // Remove item from any inventory or map block

if (!item->specific_refs.empty() || item->world_data_id != -1)

return false;

bool building_clutter = false;

for (auto ref : item->general_refs) {

switch (ref->getType())

{

case general_ref_type::BUILDING_HOLDER:

if (item->flags.bits.in_building)

return false; // Construction mat

building_clutter = true;

break;

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:

break;

}

}

if (building_clutter) {

if (auto building = virtual_cast<df::building_actual>(Items::getHolderBuilding(item))) {

for (size_t i = 0; i < building->contained_items.size(); i++)

{

auto ci = building->contained_items[i];

if (ci->item == item) {

removeRef(item->general_refs, general_ref_type::BUILDING_HOLDER, building->id);

vector_erase_at(building->contained_items, i);

delete ci;

return true;

}

}

}

}

if (auto ref = virtual_cast<df::general_ref_projectile>(Items::getGeneralRef(item, general_ref_type::PROJECTILE))) {

auto proj_id = ref->projectile_id;

bool isRefRemoved = removeRef(item->general_refs, general_ref_type::PROJECTILE, proj_id);

bool isLinkRemoved = linked_list_remove(&world->projectiles.all, proj_id);

return isRefRemoved && isLinkRemoved;

}

if (item->flags.bits.on_ground) {

if (!removeItemOnGround(item))

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

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

item->flags.bits.on_ground = false;

return true;

}

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

bool found = false;

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

auto ref = item->general_refs[i];

switch (ref->getType())

{

case general_ref_type::CONTAINED_IN_ITEM:

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

{

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())

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

auto inv_item = unit->inventory[i];

if (inv_item->item != item)

continue; // Next inventory item

resetUnitInvFlags(unit, inv_item);

vector_erase_at(unit->inventory, i);

delete inv_item;

}

break;

default:

continue; // Next ref

}

found = true;

vector_erase_at(item->general_refs, i);

delete ref;

}

if (!found)

return false;

item->flags.bits.in_inventory = false;

return true;

}

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;

}

return false;