CONFIG_IS_ENABLED = 0,

CONFIG_SILK_IDX = 1,

CONFIG_CLOTH_IDX = 2,

CONFIG_YARN_IDX = 3,

CONFIG_LEATHER_IDX = 4,

CONFIG_ADAMANTINE_IDX = 5,

CONFIG_CONFISCATE = 6

const std::string name;

const df::job_material_category job_material;

const df::armor_general_flags armor_flag;

bool operator==(const MatType& m) const {

return name == m.name;

}

// operator< is required to use this as a std::map key

bool operator<(const MatType& m) const {

return name < m.name;

}

MatType(std::string& n, df::job_material_category jm, df::armor_general_flags af)

: name(n), job_material(jm), armor_flag(af) {};

MatType(const char* n, df::job_material_category jm, df::armor_general_flags af)

: name(std::string(n)), job_material(jm), armor_flag(af) {};

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

F(removed); F(encased); F(spider_web);

#undef F

whole = flags.whole;

}

std::map<int, int> sizes; // this maps body size to races

std::map<std::pair<df::item_type, int>, int> available;

std::map<std::pair<df::item_type, int>, int> needed;

std::map<std::tuple<df::job_type, int, int>, int> orders;

std::map<MatType, int> supply;

std::map<MatType, int> reserves;

std::list<MatType> material_order = default_materials;

int default_reserve = 10;

bool confiscate = true;

void set_confiscate(bool f){ confiscate = f; }

bool get_confiscate() { return confiscate; }

void sync_material_order()

{

material_order.clear();

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

if (i == (size_t)config.get_int(CONFIG_SILK_IDX))

material_order.push_back(M_SILK);

else if (i == (size_t)config.get_int(CONFIG_CLOTH_IDX))

material_order.push_back(M_CLOTH);

else if (i == (size_t)config.get_int(CONFIG_YARN_IDX))

material_order.push_back(M_YARN);

else if (i == (size_t)config.get_int(CONFIG_LEATHER_IDX))

material_order.push_back(M_LEATHER);

else if (i == (size_t)config.get_int(CONFIG_ADAMANTINE_IDX))

material_order.push_back(M_ADAMANTINE);

}

if (!material_order.size())

std::copy(default_materials.begin(), default_materials.end(), std::back_inserter(material_order));

}

std::list<MatType> get_material_order() {

return material_order;

}

void reset()

{

available.clear();

needed.clear();

sizes.clear();

supply.clear();

orders.clear();

}

void scan_clothing()

{

for (auto i : world->items.other[df::items_other_id::ANY_GOES_IN_CABINET])

{

if (i->flags.whole & badFlags.whole)

{

continue;

}

if (i->getWear() >= 1)

continue;

if (i->getMakerRace() < 0) // sometimes we get borked items with no valid maker race

continue;

df::item_type t = i->getType();

int size = world->raws.creatures.all[i->getMakerRace()]->adultsize;

available[std::make_pair(t, size)] += 1;

}

if (DBG_NAME(cycle).isEnabled(DebugCategory::LDEBUG))

{

for (auto& i : available)

{

df::item_type t;

int size;

std::tie(t, size) = i.first;

DEBUG(cycle).print("tailor: %d %s of size %d found\n",

i.second, ENUM_KEY_STR(item_type, t).c_str(), size);

}

}

}

void scan_materials()

{

bool require_dyed = df::global::standing_orders_use_dyed_cloth ? (*df::global::standing_orders_use_dyed_cloth) : false;

for (auto i : world->items.other[df::items_other_id::CLOTH])

{

if (i->flags.whole & badFlags.whole)

continue;

if (require_dyed && (!i->isDyed()))

{

// only count dyed

std::string d;

i->getItemDescription(&d, 0);

TRACE(cycle).print("tailor: skipping undyed %s\n", DF2CONSOLE(d).c_str());

continue;

}

MaterialInfo mat(i);

int ss = i->getStackSize();

if (mat.material)

{

if (mat.material->flags.is_set(df::material_flags::SILK))

supply[M_SILK] += ss;

else if (mat.material->flags.is_set(df::material_flags::THREAD_PLANT))

supply[M_CLOTH] += ss;

else if (mat.material->flags.is_set(df::material_flags::YARN))

supply[M_YARN] += ss;

else if (mat.material->flags.is_set(df::material_flags::STOCKPILE_THREAD_METAL))

supply[M_ADAMANTINE] += ss;

else

{

std::string d;

i->getItemDescription(&d, 0);

DEBUG(cycle).print("tailor: weird cloth item found: %s (%d)\n", DF2CONSOLE(d).c_str(), i->id);

}

}

}

for (auto i : world->items.other[df::items_other_id::SKIN_TANNED])

{

if (i->flags.whole & badFlags.whole)

continue;

supply[M_LEATHER] += i->getStackSize();

}

DEBUG(cycle).print("tailor: available silk %d yarn %d cloth %d leather %d adamantine %d\n",

supply[M_SILK], supply[M_YARN], supply[M_CLOTH], supply[M_LEATHER], supply[M_ADAMANTINE]);

}

void scan_replacements()

{

for (auto u : Units::citizensRange(world->units.active)) {

if (Units::isBaby(u) ||

!Units::casteFlagSet(u->race, u->caste, df::enums::caste_raw_flags::EQUIPS))

continue; // skip units we don't control or that can't wear clothes

std::set <df::item_type> equipped;

std::set <df::item_type> ordered;

std::deque<df::item*> damaged;

for (auto inv : u->inventory)

{

if (inv->mode != df::inv_item_role_type::Worn)

continue;

// skip non-clothing

if (!inv->item->isClothing())

continue;

if (inv->item->getWear() > 0)

damaged.push_back(inv->item);

else

equipped.insert(inv->item->getType());

}

int usize = world->raws.creatures.all[u->race]->adultsize;

sizes[usize] = u->race;

for (auto w : damaged)

{

// skip armor

if (w->getEffectiveArmorLevel() > 0)

continue;

auto ty = w->getType();

auto makerRace = w->getMakerRace();

if (makerRace < 0 || makerRace >= (int16_t) world->raws.creatures.all.size())

continue;

int isize = world->raws.creatures.all[makerRace]->adultsize;

std::string description;

w->getItemDescription(&description, 0);

if (equipped.count(ty) == 0)

{

if (ordered.count(ty) == 0)

{

DEBUG(cycle).print ("tailor: %s (size %d) worn by %s (size %d) needs replacement\n",

DF2CONSOLE(description).c_str(), isize,

DF2CONSOLE(Units::getReadableName(u)).c_str(), usize);

needed[std::make_pair(ty, usize)] += 1;

ordered.insert(ty);

}

}

if (confiscate && equipped.count(ty) > 0)

{

if (w->flags.bits.owned)

{

bool confiscated = Items::setOwner(w, NULL);

INFO(cycle).print(

"tailor: %s %s from %s.\n",

(confiscated ? "confiscated" : "could not confiscate"),

DF2CONSOLE(description).c_str(),

DF2CONSOLE(Units::getReadableName(u)).c_str()

);

}

if (w->getWear() > 1)

w->flags.bits.dump = true;

}

}

for (auto ty : std::set<df::item_type>{ df::item_type::ARMOR, df::item_type::PANTS, df::item_type::SHOES })

{

if (equipped.count(ty) == 0 && ordered.count(ty) == 0)

{

TRACE(cycle).print("tailor: one %s of size %d needed to cover %s\n",

ENUM_KEY_STR(item_type, ty).c_str(),

usize,

DF2CONSOLE(Units::getReadableName(u)).c_str());

needed[std::make_pair(ty, usize)] += 1;

}

}

}

}

void create_orders()

{

auto entity = world->entities.all[plotinfo->civ_id];

for (auto& a : needed)

{

df::item_type ty = a.first.first;

int size = a.first.second;

int count = a.second;

// decrease "need" by "available"

count -= available[std::make_pair(ty, size)];

if (count <= 0)

continue;

int sub = 0;

std::vector<int16_t> v;

switch (ty) {

case df::item_type::ARMOR: v = entity->resources.armor_type; break;

case df::item_type::GLOVES: v = entity->resources.gloves_type; break;

case df::item_type::HELM: v = entity->resources.helm_type; break;

case df::item_type::PANTS: v = entity->resources.pants_type; break;

case df::item_type::SHOES: v = entity->resources.shoes_type; break;

default: break;

}

for (auto vv : v) {

bool isClothing = false;

switch (ty) {

case df::item_type::ARMOR: isClothing = world->raws.itemdefs.armor[vv]->armorlevel == 0; break;

case df::item_type::GLOVES: isClothing = world->raws.itemdefs.gloves[vv]->armorlevel == 0; break;

case df::item_type::HELM: isClothing = world->raws.itemdefs.helms[vv]->armorlevel == 0; break;

case df::item_type::PANTS: isClothing = world->raws.itemdefs.pants[vv]->armorlevel == 0; break;

case df::item_type::SHOES: isClothing = world->raws.itemdefs.shoes[vv]->armorlevel == 0; break;

default: break;

}

if (isClothing)

{

sub = vv;

break;

}

}

auto jj = itemTypeMap.find(ty);

if (jj != itemTypeMap.end())

{

const df::job_type j = jj->second;

orders[std::make_tuple(j, sub, size)] += count;

DEBUG(cycle).print("tailor: %s times %d of size %d ordered\n", ENUM_KEY_STR(job_type, j).c_str(), count, size);

}

}

}

void scan_existing_orders()

{

for (auto o : world->manager_orders.all)

{

auto f = jobTypeMap.find(o->job_type);

if (f == jobTypeMap.end())

continue;

int race = o->specdata.hist_figure_id;

for (auto& m : all_materials)

{

if (o->material_category.whole == m.job_material.whole)

{

supply[m] -= o->amount_left;

TRACE(cycle).print("tailor: supply of %s reduced by %d due to being required for an existing order\n",

DF2CONSOLE(m.name).c_str(), o->amount_left);

}

}

if (race == -1)

continue; // -1 means that the race of the worker will determine the size made; we must ignore these jobs

int size = world->raws.creatures.all[race]->adultsize;

auto tt = jobTypeMap.find(o->job_type);

if (tt == jobTypeMap.end())

{

continue;

}

needed[std::make_pair(tt->second, size)] -= o->amount_left;

TRACE(cycle).print("tailor: existing order for %d %s of size %d detected\n",

o->amount_left,

ENUM_KEY_STR(job_type, o->job_type).c_str(),

size);

}

}

static df::manager_order * get_existing_order(df::job_type ty, int16_t sub, int32_t hfid, df::job_material_category mcat) {

for (auto order : world->manager_orders.all) {

if (order->job_type == ty &&

order->item_type == df::item_type::NONE &&

order->item_subtype == sub &&

order->mat_type == -1 &&

order->mat_index == -1 &&

order->specdata.hist_figure_id == hfid &&

order->material_category.whole == mcat.whole &&

order->frequency == df::workquota_frequency_type::OneTime)

return order;

}

return NULL;

}

int place_orders()

{

int ordered = 0;

auto entity = world->entities.all[plotinfo->civ_id];

for (auto& o : orders)

{

df::job_type ty;

int sub;

int size;

std::tie(ty, sub, size) = o.first;

int count = o.second;

if (sizes.count(size) == 0)

{

WARN(cycle).print("tailor: cannot determine race for clothing of size %d, skipped\n",

size);

continue;

}

if (count > 0)

{

std::vector<int16_t> v;

BitArray<df::armor_general_flags>* fl;

std::string name_s, name_p;

switch (ty) {

case df::job_type::MakeArmor:

v = entity->resources.armor_type;

name_s = world->raws.itemdefs.armor[sub]->name;

name_p = world->raws.itemdefs.armor[sub]->name_plural;

fl = &world->raws.itemdefs.armor[sub]->props.flags;

break;

case df::job_type::MakeGloves:

name_s = world->raws.itemdefs.gloves[sub]->name;

name_p = world->raws.itemdefs.gloves[sub]->name_plural;

v = entity->resources.gloves_type;

fl = &world->raws.itemdefs.gloves[sub]->props.flags;

break;

case df::job_type::MakeHelm:

name_s = world->raws.itemdefs.helms[sub]->name;

name_p = world->raws.itemdefs.helms[sub]->name_plural;

v = entity->resources.helm_type;

fl = &world->raws.itemdefs.helms[sub]->props.flags;

break;

case df::job_type::MakePants:

name_s = world->raws.itemdefs.pants[sub]->name;

name_p = world->raws.itemdefs.pants[sub]->name_plural;

v = entity->resources.pants_type;

fl = &world->raws.itemdefs.pants[sub]->props.flags;

break;

case df::job_type::MakeShoes:

name_s = world->raws.itemdefs.shoes[sub]->name;

name_p = world->raws.itemdefs.shoes[sub]->name_plural;

v = entity->resources.shoes_type;

fl = &world->raws.itemdefs.shoes[sub]->props.flags;

break;

default:

break;

}

bool can_make = std::find(v.begin(), v.end(), sub) != v.end();

if (!can_make)

{

INFO(cycle).print("tailor: civilization cannot make %s, skipped\n", DF2CONSOLE(name_p).c_str());

continue;

}

DEBUG(cycle).print("tailor: ordering %d %s\n", count, DF2CONSOLE(name_p).c_str());

for (auto& m : material_order)

{

if (count <= 0)

break;

auto r = reserves.find(m);

int res = (r == reserves.end()) ? default_reserve : r->second;

if (supply[m] > res && fl->is_set(m.armor_flag)) {

int c = count;

if (supply[m] < count + res)

{

c = supply[m] - res;

TRACE(cycle).print("tailor: order reduced from %d to %d to protect reserves of %s\n",

count, c, DF2CONSOLE(m.name).c_str());

}

supply[m] -= c;

auto order = get_existing_order(ty, sub, sizes[size], m.job_material);

if (order) {

if (order->amount_total > 0) {

order->amount_left += c;

order->amount_total += c;

}

} else {

order = new df::manager_order;

order->job_type = ty;

order->item_type = df::item_type::NONE;

order->item_subtype = sub;

order->mat_type = -1;

order->mat_index = -1;

order->amount_left = c;

order->amount_total = c;

order->status.bits.validated = false;

order->status.bits.active = false;

order->id = world->manager_orders.manager_order_next_id++;

order->specdata.hist_figure_id = sizes[size];

order->material_category = m.job_material;

world->manager_orders.all.push_back(order);

}

INFO(cycle).print("tailor: added order #%d for %d %s %s, sized for %s\n",

order->id,

c,

bitfield_to_string(order->material_category).c_str(),

DF2CONSOLE((c > 1) ? name_p : name_s).c_str(),

DF2CONSOLE(world->raws.creatures.all[order->specdata.hist_figure_id]->name[1]).c_str()

);

count -= c;

ordered += c;

}

else

{

TRACE(cycle).print("tailor: material %s skipped due to lack of reserves, %d available\n", DF2CONSOLE(m.name).c_str(), supply[m]);

}

}

}

}

return ordered;

}

int do_cycle()

{

reset();

scan_clothing();

scan_materials();

scan_replacements();

scan_existing_orders();

create_orders();

return place_orders();

}

DEBUG(control,out).print("initializing %s\n", plugin_name);

tailor_instance = std::make_unique<Tailor>();

// provide a configuration interface for the plugin

commands.push_back(PluginCommand(

plugin_name,

"Automatically keep your dwarves in fresh clothing.",

do_command));

return CR_OK;

if (!Core::getInstance().isMapLoaded() || !World::isFortressMode()) {

out.printerr("Cannot enable %s without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

if (enable != is_enabled) {

is_enabled = enable;

DEBUG(control,out).print("%s from the API; persisting\n",

is_enabled ? "enabled" : "disabled");

config.set_bool(CONFIG_IS_ENABLED, is_enabled);

if (enable)

do_cycle(out);

} else {

DEBUG(control,out).print("%s from the API, but already %s; no action\n",

is_enabled ? "enabled" : "disabled",

is_enabled ? "enabled" : "disabled");

}

return CR_OK;

DEBUG(control,out).print("shutting down %s\n", plugin_name);

tailor_instance.release();

return CR_OK;

cycle_timestamp = 0;

config = World::GetPersistentSiteData(CONFIG_KEY);

if (!config.isValid()) {

DEBUG(control,out).print("no config found in this save; initializing\n");

config = World::AddPersistentSiteData(CONFIG_KEY);

config.set_bool(CONFIG_IS_ENABLED, is_enabled);

config.set_bool(CONFIG_CONFISCATE, true);

}

// transition existing saves to CONFIG_CONFISCATE=true

if (config.get_int(CONFIG_CONFISCATE) < 0) {

DEBUG(control,out).print("found existing configuration with CONFIG_CONFISCATE unset, initializing to true\n");

config.set_bool(CONFIG_CONFISCATE, true);

}

is_enabled = config.get_bool(CONFIG_IS_ENABLED);

DEBUG(control,out).print("loading persisted enabled state: %s\n",

is_enabled ? "true" : "false");

tailor_instance->set_confiscate(config.get_bool(CONFIG_CONFISCATE));

DEBUG(control,out).print("loading persisted confiscation state: %s\n",

tailor_instance->get_confiscate() ? "true" : "false");

tailor_instance->sync_material_order();

return CR_OK;

if (event == DFHack::SC_WORLD_UNLOADED) {

if (is_enabled) {

DEBUG(control,out).print("world unloaded; disabling %s\n",

plugin_name);

is_enabled = false;

}

}

return CR_OK;

if (world->frame_counter - cycle_timestamp >= CYCLE_TICKS) {

int ordered = do_cycle(out);

if (0 < ordered)

out.print("tailor: ordered %d items of clothing\n", ordered);

}

return CR_OK;

if (!Core::getInstance().isMapLoaded() || !World::isFortressMode()) {

out.printerr("Cannot run %s without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

bool show_help = false;

if (!Lua::CallLuaModuleFunction(out, "plugins.tailor", "parse_commandline", parameters, 1,

[&](lua_State *L) {

show_help = !lua_toboolean(L, -1);

})) {

return CR_FAILURE;

}

return show_help ? CR_WRONG_USAGE : CR_OK;

// mark that we have recently run

cycle_timestamp = world->frame_counter;

DEBUG(cycle,out).print("running %s cycle\n", plugin_name);

return tailor_instance->do_cycle();

int32_t clothIdx, int32_t yarnIdx, int32_t leatherIdx,

int32_t adamantineIdx) {

DEBUG(control,out).print("entering tailor_setMaterialPreferences\n");

// it doesn't really matter if these are invalid. set_material_order will do

// the right thing.

config.set_int(CONFIG_SILK_IDX, silkIdx - 1);

config.set_int(CONFIG_CLOTH_IDX, clothIdx - 1);

config.set_int(CONFIG_YARN_IDX, yarnIdx - 1);

config.set_int(CONFIG_LEATHER_IDX, leatherIdx - 1);

config.set_int(CONFIG_ADAMANTINE_IDX, adamantineIdx - 1);

tailor_instance->sync_material_order();

{

DEBUG(control,out).print("%s confiscation of tattered clothing \n", enable ? "enabling" : "disabling");

config.set_bool(CONFIG_CONFISCATE, enable);

tailor_instance->set_confiscate(enable);

color_ostream *out = Lua::GetOutput(L);

if (!out)

out = &Core::getInstance().getConsole();

DEBUG(control,*out).print("entering tailor_getMaterialPreferences\n");

vector<string> names;

for (const auto& m : tailor_instance->get_material_order())

names.emplace_back(m.name);

Lua::PushVector(L, names);

return 1;