{

min_quality = df::item_quality::Ordinary;

max_quality = df::item_quality::Masterful;

decorated_only = false;

clearMaterialMask();

materials.clear();

{

clear();

std::vector<std::string> tokens;

split_string(&tokens, ser, "/");

if (tokens.size() != 5)

{

debug("invalid ItemFilter serialization: '%s'", ser.c_str());

return false;

}

if (!deserializeMaterialMask(tokens[0]) || !deserializeMaterials(tokens[1]))

return false;

setMinQuality(atoi(tokens[2].c_str()));

setMaxQuality(atoi(tokens[3].c_str()));

decorated_only = static_cast<bool>(atoi(tokens[4].c_str()));

return true;

{

if (ser.empty())

return true;

if (!parseJobMaterialCategory(&mat_mask, ser))

{

debug("invalid job material category serialization: '%s'", ser.c_str());

return false;

}

return true;

{

if (ser.empty())

return true;

std::vector<std::string> mat_names;

split_string(&mat_names, ser, ",");

for (auto m = mat_names.begin(); m != mat_names.end(); m++)

{

DFHack::MaterialInfo material;

if (!material.find(*m) || !material.isValid())

{

debug("invalid material name serialization: '%s'", ser.c_str());

return false;

}

materials.push_back(material);

}

return true;

{

std::ostringstream ser;

ser << bitfield_to_string(mat_mask, ",") << "/";

if (!materials.empty())

{

ser << materials[0].getToken();

for (size_t i = 1; i < materials.size(); ++i)

ser << "," << materials[i].getToken();

}

ser << "/" << static_cast<int>(min_quality);

ser << "/" << static_cast<int>(max_quality);

ser << "/" << static_cast<int>(decorated_only);

return ser.str();

{

if (*quality > item_quality::Artifact)

{

debug("clamping quality to Artifact");

*quality = item_quality::Artifact;

}

if (*quality < item_quality::Ordinary)

{

debug("clamping quality to Ordinary");

*quality = item_quality::Ordinary;

}

{

min_quality = static_cast<df::item_quality>(quality);

clampItemQuality(&min_quality);

if (max_quality < min_quality)

max_quality = min_quality;

{

max_quality = static_cast<df::item_quality>(quality);

clampItemQuality(&max_quality);

if (max_quality < min_quality)

min_quality = max_quality;

{

std::vector<std::string> descriptions;

transform_(materials, descriptions, material_to_string_fn);

if (descriptions.size() == 0)

bitfield_to_string(&descriptions, mat_mask);

if (descriptions.size() == 0)

descriptions.push_back("any");

return descriptions;

{

for (auto it = materials.begin(); it != materials.end(); ++it)

if (material.matches(*it))

return true;

return false;

{

if (item->getQuality() < min_quality || item->getQuality() > max_quality)

return false;

if (decorated_only && !item->hasImprovements())

return false;

auto imattype = item->getActualMaterial();

auto imatindex = item->getActualMaterialIndex();

auto item_mat = DFHack::MaterialInfo(imattype, imatindex);

return (materials.size() == 0) ? matchesMask(item_mat) : matches(item_mat);

{

std::ostringstream ser;

if (!filters.empty())

{

ser << filters[0].serialize();

for (size_t i = 1; i < filters.size(); ++i)

ser << "|" << filters[i].serialize();

}

return ser.str();

{

std::vector<std::string> isers;

split_string(&isers, ser, "|");

std::vector<ItemFilter> ret;

for (auto & iser : isers)

{

ItemFilter filter;

if (filter.deserialize(iser))

ret.push_back(filter);

}

return ret;

{

auto L = Lua::Core::State;

color_ostream_proxy out(Core::getInstance().getConsole());

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 4) || !Lua::PushModulePublic(

out, L, "plugins.buildingplan", "get_num_filters"))

{

debug("failed to push the lua method on the stack");

return 0;

}

Lua::Push(L, std::get<0>(key));

Lua::Push(L, std::get<1>(key));

Lua::Push(L, std::get<2>(key));

if (!Lua::SafeCall(out, L, 3, 1))

{

debug("lua call failed");

return 0;

}

int num_filters = lua_tonumber(L, -1);

lua_pop(L, 1);

return num_filters;

: building(building),

building_id(building->id),

filters(filters)

{

config = DFHack::World::AddPersistentData(planned_building_persistence_key_v2);

config.ival(0) = building_id;

config.val() = serializeFilters(filters);

: config(config),

building(df::building::find(config.ival(0))),

building_id(config.ival(0)),

filters(deserializeFilters(config.val()))

{

if (building)

{

if (filters.size() !=

getNumFilters(toBuildingTypeKey(building)))

{

debug("invalid ItemFilter vector serialization: '%s'",

config.val().c_str());

building = NULL;

}

}

{

return building && df::building::find(building_id)

&& building->getBuildStage() == 0;

{

DFHack::World::DeletePersistentData(config);

building = NULL;

df::building_type btype, int16_t subtype, int32_t custom)

{

return std::make_tuple(btype, subtype, custom);

{

return std::make_tuple(

bld->getType(), bld->getSubtype(), bld->getCustomType());

{

return std::make_tuple(

uibs->building_type, uibs->building_subtype, uibs->custom_type);

{

static const int size_t_bits = CHAR_BIT * sizeof(std::size_t);

return val << count | val >> (size_t_bits - count);

{

std::vector<PersistentDataItem> configs;

DFHack::World::GetPersistentData(&configs, planned_building_persistence_key_v1);

if (configs.empty())

return;

debug("migrating %zu persisted configs to new format", configs.size());

for (auto config : configs)

{

df::building *bld = df::building::find(config.ival(1));

if (!bld)

{

debug("buliding no longer exists; removing config");

DFHack::World::DeletePersistentData(config);

continue;

}

if (bld->getBuildStage() != 0 || bld->jobs.size() != 1

|| bld->jobs[0]->job_items.size() != 1)

{

debug("building in invalid state; removing config");

DFHack::World::DeletePersistentData(config);

continue;

}

// fix up the building so we can set the material properties later

bld->mat_type = -1;

bld->mat_index = -1;

// the v1 filters are not initialized correctly and will match any item.

// we need to fix them up a bit.

auto filter = bld->jobs[0]->job_items[0];

df::item_type type;

switch (bld->getType())

{

case df::building_type::Armorstand: type = df::item_type::ARMORSTAND; break;

case df::building_type::Bed: type = df::item_type::BED; break;

case df::building_type::Chair: type = df::item_type::CHAIR; break;

case df::building_type::Coffin: type = df::item_type::COFFIN; break;

case df::building_type::Door: type = df::item_type::DOOR; break;

case df::building_type::Floodgate: type = df::item_type::FLOODGATE; break;

case df::building_type::Hatch: type = df::item_type::HATCH_COVER; break;

case df::building_type::GrateWall: type = df::item_type::GRATE; break;

case df::building_type::GrateFloor: type = df::item_type::GRATE; break;

case df::building_type::BarsVertical: type = df::item_type::BAR; break;

case df::building_type::BarsFloor: type = df::item_type::BAR; break;

case df::building_type::Cabinet: type = df::item_type::CABINET; break;

case df::building_type::Box: type = df::item_type::BOX; break;

case df::building_type::Weaponrack: type = df::item_type::WEAPONRACK; break;

case df::building_type::Statue: type = df::item_type::STATUE; break;

case df::building_type::Slab: type = df::item_type::SLAB; break;

case df::building_type::Table: type = df::item_type::TABLE; break;

case df::building_type::WindowGlass: type = df::item_type::WINDOW; break;

case df::building_type::AnimalTrap: type = df::item_type::ANIMALTRAP; break;

case df::building_type::Chain: type = df::item_type::CHAIN; break;

case df::building_type::Cage: type = df::item_type::CAGE; break;

case df::building_type::TractionBench: type = df::item_type::TRACTION_BENCH; break;

default:

debug("building has unhandled type; removing config");

DFHack::World::DeletePersistentData(config);

continue;

}

filter->item_type = type;

filter->item_subtype = -1;

filter->mat_type = -1;

filter->mat_index = -1;

filter->flags1.whole = 0;

filter->flags2.whole = 0;

filter->flags2.bits.allow_artifact = true;

filter->flags3.whole = 0;

filter->flags4 = 0;

filter->flags5 = 0;

filter->metal_ore = -1;

filter->min_dimension = -1;

filter->has_tool_use = df::tool_uses::NONE;

filter->quantity = 1;

std::vector<std::string> tokens;

split_string(&tokens, config.val(), "/");

if (tokens.size() != 2)

{

debug("invalid v1 format; removing config");

DFHack::World::DeletePersistentData(config);

continue;

}

ItemFilter item_filter;

item_filter.deserializeMaterialMask(tokens[0]);

item_filter.deserializeMaterials(tokens[1]);

item_filter.setMinQuality(config.ival(2) - 1);

item_filter.setMaxQuality(config.ival(4) - 1);

if (config.ival(3) - 1)

item_filter.toggleDecoratedOnly();

// create the v2 record

std::vector<ItemFilter> item_filters;

item_filters.push_back(item_filter);

PlannedBuilding pb(bld, item_filters);

// remove the v1 record

DFHack::World::DeletePersistentData(config);

debug("v1 %s(%d) record successfully migrated",

ENUM_KEY_STR(building_type, bld->getType()).c_str(),

bld->id);

}

{

std::ostringstream ser;

for (auto & entry : settings)

{

ser << entry.first << "=" << (entry.second ? "1" : "0") << "|";

}

return ser.str();

std::string ser)

{

std::vector<std::string> tokens;

split_string(&tokens, ser, "|");

for (auto token : tokens)

{

if (token.empty())

continue;

std::vector<std::string> parts;

split_string(&parts, token, "=");

if (parts.size() != 2)

{

debug("invalid serialized setting format: '%s'", token.c_str());

continue;

}

std::string key = parts[0];

if (settings.count(key) == 0)

{

debug("unknown serialized setting: '%s", key.c_str());

continue;

}

settings[key] = static_cast<bool>(atoi(parts[1].c_str()));

debug("deserialized setting: %s = %d", key.c_str(), settings[key]);

}

std::map<std::string, bool> & settings)

{

settings.clear();

settings["blocks"] = true;

settings["boulders"] = true;

settings["logs"] = true;

settings["bars"] = false;

// load persistent global settings if they exist; otherwise create them

std::vector<PersistentDataItem> items;

DFHack::World::GetPersistentData(&items, global_settings_persistence_key);

if (items.size() == 1)

{

DFHack::PersistentDataItem & config = items[0];

deserialize_settings(settings, config.val());

return config;

}

debug("initializing persistent global settings");

DFHack::PersistentDataItem config =

DFHack::World::AddPersistentData(global_settings_persistence_key);

config.val() = serialize_settings(settings);

return config;

{

if (global_settings.count(name) == 0)

{

debug("attempted to set invalid setting: '%s'", name.c_str());

return false;

}

debug("global setting '%s' %d -> %d",

name.c_str(), global_settings[name], value);

global_settings[name] = value;

if (config.isValid())

config.val() = serialize_settings(global_settings);

return true;

{

debug("resetting Planner state");

default_item_filters.clear();

planned_buildings.clear();

tasks.clear();

config = init_global_settings(global_settings);

migrateV1ToV2();

std::vector<PersistentDataItem> items;

DFHack::World::GetPersistentData(&items, planned_building_persistence_key_v2);

debug("found data for %zu planned building(s)", items.size());

for (auto i = items.begin(); i != items.end(); i++)

{

PlannedBuilding pb(*i);

if (!pb.isValid())

{

debug("discarding invalid planned building");

pb.remove();

continue;

}

if (registerTasks(pb))

planned_buildings.insert(std::make_pair(pb.getBuilding()->id, pb));

}

{

auto item_filters = getItemFilters(toBuildingTypeKey(bld)).get();

// not a supported type

if (item_filters.empty())

{

debug("failed to add building: unsupported type");

return;

}

// protect against multiple registrations

if (planned_buildings.count(bld->id) != 0)

{

debug("failed to add building: already registered");

return;

}

PlannedBuilding pb(bld, item_filters);

if (pb.isValid() && registerTasks(pb))

{

for (auto job : bld->jobs)

job->flags.bits.suspend = true;

planned_buildings.insert(std::make_pair(bld->id, pb));

}

else

{

pb.remove();

}

const std::vector<ItemFilter> & item_filters)

{

std::ostringstream ser;

// pull out and serialize only known relevant fields. if we miss a few, then

// the filter bucket will be slighly less specific than it could be, but

// that's probably ok. we'll just end up bucketing slightly different items

// together. this is only a problem if the different filter at the front of

// the queue doesn't match any available items and blocks filters behind it

// that could be matched.

ser << ji.item_type << ':' << ji.item_subtype << ':' << ji.mat_type << ':'

<< ji.mat_index << ':' << ji.flags1.whole << ':' << ji.flags2.whole

<< ':' << ji.flags3.whole << ':' << ji.flags4 << ':' << ji.flags5 << ':'

<< ji.metal_ore << ':' << ji.has_tool_use;

for (auto & item_filter : item_filters)

{

ser << ':' << item_filter.serialize();

}

return ser.str();

const std::map<std::string, bool> & global_settings)

{

std::vector<df::job_item_vector_id> ret;

// if the filter already has the vector_id set to something specific, use it

if (job_item->vector_id > df::job_item_vector_id::IN_PLAY)

{

debug("using vector_id from job_item: %s",

ENUM_KEY_STR(job_item_vector_id, job_item->vector_id).c_str());

ret.push_back(job_item->vector_id);

return ret;

}

// if the filer is for building material, refer to our global settings for

// which vectors to search

if (job_item->flags2.bits.building_material)

{

if (global_settings.at("blocks"))

ret.push_back(df::job_item_vector_id::BLOCKS);

if (global_settings.at("boulders"))

ret.push_back(df::job_item_vector_id::BOULDER);

if (global_settings.at("logs"))

ret.push_back(df::job_item_vector_id::WOOD);

if (global_settings.at("bars"))

ret.push_back(df::job_item_vector_id::BAR);

}

// fall back to IN_PLAY if no other vector was appropriate

if (ret.empty())

ret.push_back(df::job_item_vector_id::IN_PLAY);

return ret;

{

df::building * bld = pb.getBuilding();

if (bld->jobs.size() != 1)

{

debug("unexpected number of jobs: want 1, got %zu", bld->jobs.size());

return false;

}

auto job_items = bld->jobs[0]->job_items;

int num_job_items = job_items.size();

if (num_job_items < 1)

{

debug("unexpected number of job items: want >0, got %d", num_job_items);

return false;

}

int32_t id = bld->id;

for (int job_item_idx = 0; job_item_idx < num_job_items; ++job_item_idx)

{

auto job_item = job_items[job_item_idx];

auto bucket = getBucket(*job_item, pb.getFilters());

auto vector_ids = getVectorIds(job_item, global_settings);

// if there are multiple vector_ids, schedule duplicate tasks. after

// the correct number of items are matched, the extras will get popped

// as invalid

for (auto vector_id : vector_ids)

{

for (int item_num = 0; item_num < job_item->quantity; ++item_num)

{

tasks[vector_id][bucket].push(std::make_pair(id, job_item_idx));

debug("added task: %s/%s/%d,%d; "

"%zu vector(s), %zu filter bucket(s), %zu task(s) in bucket",

ENUM_KEY_STR(job_item_vector_id, vector_id).c_str(),

bucket.c_str(), id, job_item_idx, tasks.size(),

tasks[vector_id].size(), tasks[vector_id][bucket].size());

}

}

}

return true;

{

static std::vector<ItemFilter> empty_vector;

static const ItemFiltersWrapper empty_ret(empty_vector);

size_t nfilters = getNumFilters(key);

if (nfilters < 1)

return empty_ret;

while (default_item_filters[key].size() < nfilters)

default_item_filters[key].push_back(ItemFilter());

return ItemFiltersWrapper(default_item_filters[key]);

{

uint32_t whole;

BadFlags()

{

df::item_flags flags;

#define F(x) flags.bits.x = true;

F(dump); F(forbid); F(garbage_collect);

F(hostile); F(on_fire); F(rotten); F(trader);

F(in_building); F(construction); F(in_job);

F(owned); F(in_chest); F(removed); F(encased);

#undef F

whole = flags.whole;

}

{

static BadFlags bad_flags;

return !(item->flags.whole & bad_flags.whole)

&& !item->isAssignedToStockpile()

// TODO: make this configurable

&& !(item->getType() == df::item_type::BOX && item->isBag());

df::job_item * job_item,

const ItemFilter & item_filter)

{

// check the properties that are not checked by Job::isSuitableItem()

if (job_item->item_type > -1 && job_item->item_type != item->getType())

return false;

if (job_item->item_subtype > -1 &&

job_item->item_subtype != item->getSubtype())

return false;

if (job_item->flags2.bits.building_material && !item->isBuildMat())

return false;

if (job_item->metal_ore > -1 && !item->isMetalOre(job_item->metal_ore))

return false;

if (job_item->has_tool_use > df::tool_uses::NONE

&& !item->hasToolUse(job_item->has_tool_use))

return false;

return DFHack::Job::isSuitableItem(

job_item, item->getType(), item->getSubtype())

&& DFHack::Job::isSuitableMaterial(

job_item, item->getMaterial(), item->getMaterialIndex(),

item->getType())

&& item_filter.matches(item);

{

if (planned_buildings.count(id) > 0)

{

planned_buildings.at(id).remove();

planned_buildings.erase(id);

}

{

int needed_items = 0;

for (auto job_item : job->job_items) { needed_items += job_item->quantity; }

if (needed_items)

{

debug("building needs %d more item(s)", needed_items);

return false;

}

return true;

{

// we want the items in the opposite order of the filters

return a->job_item_idx > b->job_item_idx;

{

debug("finalizing building %d", bld->id);

auto job = bld->jobs[0];

// sort the items so they get added to the structure in the correct order

std::sort(job->items.begin(), job->items.end(), job_item_idx_lt);

// derive the material properties of the building and job from the first

// applicable item, though if any boulders are involved, it makes the whole

// structure "rough".

bool rough = false;

for (auto attached_item : job->items)

{

df::item *item = attached_item->item;

rough = rough || item->getType() == item_type::BOULDER;

if (bld->mat_type == -1)

{

bld->mat_type = item->getMaterial();

job->mat_type = bld->mat_type;

}

if (bld->mat_index == -1)

{

bld->mat_index = item->getMaterialIndex();

job->mat_index = bld->mat_index;

}

}

if (bld->needsDesign())

{

auto act = (df::building_actual *)bld;

if (!act->design)

act->design = new df::building_design();

act->design->flags.bits.rough = rough;

}

// we're good to go!

job->flags.bits.suspend = false;

Job::checkBuildingsNow();

{

while (!task_queue.empty())

{

auto & task = task_queue.front();

auto id = task.first;

if (planned_buildings.count(id) > 0)

{

PlannedBuilding & pb = planned_buildings.at(id);

if (pb.isValid() &&

pb.getBuilding()->jobs[0]->job_items[task.second]->quantity)

{

break;

}

}

debug("discarding invalid task: bld=%d, job_item_idx=%d",

id, task.second);

task_queue.pop();

unregisterBuilding(id);

}

std::map<std::string, std::queue<std::pair<int32_t, int>>> & buckets)

{

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

auto item_vector = df::global::world->items.other[other_id];

debug("matching %zu item(s) in vector %s against %zu filter bucket(s)",

item_vector.size(),

ENUM_KEY_STR(job_item_vector_id, vector_id).c_str(),

buckets.size());

for (auto item_it = item_vector.rbegin();

item_it != item_vector.rend();

++item_it)

{

auto item = *item_it;

if (!itemPassesScreen(item))

continue;

for (auto bucket_it = buckets.begin(); bucket_it != buckets.end();)

{

auto & task_queue = bucket_it->second;

popInvalidTasks(task_queue);

if (task_queue.empty())

{

debug("removing empty bucket: %s/%s; %zu bucket(s) left",

ENUM_KEY_STR(job_item_vector_id, vector_id).c_str(),

bucket_it->first.c_str(),

buckets.size() - 1);

bucket_it = buckets.erase(bucket_it);

continue;

}

auto & task = task_queue.front();

auto id = task.first;

auto & pb = planned_buildings.at(id);

auto building = pb.getBuilding();

auto job = building->jobs[0];

auto filter_idx = task.second;

if (matchesFilters(item, job->job_items[filter_idx],

pb.getFilters()[filter_idx])

&& DFHack::Job::attachJobItem(job, item,

df::job_item_ref::Hauled, filter_idx))

{

MaterialInfo material;

material.decode(item);

ItemTypeInfo item_type;

item_type.decode(item);

debug("attached %s %s to filter %d for %s(%d): %s/%s",

material.toString().c_str(),

item_type.toString().c_str(),

filter_idx,

ENUM_KEY_STR(building_type, building->getType()).c_str(),

id,

ENUM_KEY_STR(job_item_vector_id, vector_id).c_str(),

bucket_it->first.c_str());

// keep quantity aligned with the actual number of remaining

// items so if buildingplan is turned off, the building will

// be completed with the correct number of items.

--job->job_items[filter_idx]->quantity;

task_queue.pop();

if (isJobReady(job))

{

finalizeBuilding(building);

unregisterBuilding(id);

}

if (task_queue.empty())

{

debug(

"removing empty item bucket: %s/%s; %zu left",

ENUM_KEY_STR(job_item_vector_id, vector_id).c_str(),

bucket_it->first.c_str(),

buckets.size() - 1);