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;

bool automate_dye = false;

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

bool get_confiscate() { return confiscate; }

void set_automate_dye(bool f) { automate_dye = f; }

bool get_automate_dye() { return automate_dye; }

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: {} {} of size {} found\n",

i.second, ENUM_KEY_STR(item_type, t), 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 {}\n", DF2CONSOLE(d));

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: {} ({})\n", DF2CONSOLE(d), 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 {} yarn {} cloth {} leather {} adamantine {}\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: {} (size {}) worn by {} (size {}) needs replacement\n",

DF2CONSOLE(description), isize,

DF2CONSOLE(Units::getReadableName(u)), 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: {} {} from {}.\n",

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

DF2CONSOLE(description),

DF2CONSOLE(Units::getReadableName(u))

);

}

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 {} of size {} needed to cover {}\n",

ENUM_KEY_STR(item_type, ty),

usize,

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

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: {} times {} of size {} ordered\n", ENUM_KEY_STR(job_type, j), 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;

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 {} reduced by {} due to being required for an existing order\n",

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

}

}

}

}

using jiqt = decltype(df::reaction_reagent_itemst::quantity);

int get_reaction_max_count(df::reaction* r, jiqt lim = std::numeric_limits<jiqt>::max())

{

jiqt max = lim;

for (auto rr : r->reagents)

{

if (rr->getType() == df::reaction_reagent_type::item)

{

max = std::min(get_reagent_max_count(virtual_cast<df::reaction_reagent_itemst>(rr), max), max);

}

}

return max;

}

int get_reagent_max_count(df::reaction_reagent_itemst* r, jiqt lim = std::numeric_limits<jiqt>::max())

{

df::reaction_reagent_itemst* t = df::allocate<df::reaction_reagent_itemst>();

*t = *r;

jiqt orig = t->quantity;

std::vector<int32_t> tbc;

std::vector<int32_t> toc;

std::vector<std::string*> trc;

std::vector<int32_t> tcc;

auto test = [&] (jiqt m) {

t->quantity = orig * m;

return t->have_enough_from_precalc_info(NULL, &tbc, &toc, &trc, &tcc, -1);

};

jiqt max = lim / orig;

jiqt lo = 0;

jiqt hi = max;

// exit fast when 0

if (test(1))

{

lo = 1;

while (hi > lo + 1)

{

// can't do (hi+lo)/2 because hi+lo may overflow!

jiqt mult = hi / 2 + lo / 2;

if (mult == lo) mult += 1;

if (test(mult))

lo = mult;

else

hi = mult;

}

}

delete t;

return lo;

}

int count_dyeables(df::item_type ty)

{

auto reagent = df::allocate<df::reaction_reagent_itemst>();

reagent->item_subtype = -1;

reagent->mat_type = -1;

reagent->mat_index = -1;

reagent->flags2.bits.dyeable = true;

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

if (ty == df::item_type::SKIN_TANNED)

{

reagent->quantity = 1;

reagent->min_dimension = 1;

}

else

{

reagent->quantity = 10000;

reagent->min_dimension = 10000;

}

reagent->item_type = ty;

return get_reagent_max_count(reagent);

}

int count_dyes()

{

auto reagent = df::allocate<df::reaction_reagent_itemst>();

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

reagent->item_subtype = -1;

reagent->mat_type = -1;

reagent->mat_index = -1;

reagent->flags1.bits.unrotten = true;

reagent->flags2.bits.dye = true;

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

reagent->quantity = 1;

int count = get_reagent_max_count(reagent);

delete reagent;

return count;

}

using oqt = decltype(df::manager_order::amount_total);

using color_type = decltype(MaterialInfo::material->powder_dye);

static auto product_is_dye (df::reaction_product* r) -> bool

{

if (r->getType() == df::reaction_product_type::item)

{

auto rr = virtual_cast<df::reaction_product_itemst> (r);

auto mat = MaterialInfo(rr->mat_type, rr->mat_index);

return mat.material && mat.material->flags.is_set(df::enums::material_flags::IS_DYE);

}

return false;

};

oqt order_dye_from_reaction(df::reaction* r, int c = 1)

{

std::string descr;

auto dye = std::ranges::find_if(r->products, product_is_dye);

assert(dye != r->products.end());

auto pp = virtual_cast<df::reaction_product_itemst>(*dye);

assert(pp != nullptr);

pp->getDescription(&descr);

auto [_, n] = get_or_create_order(c, df::job_type::CustomReaction, -1, -1, 0, r->code);

if (n > 0)

{

INFO(cycle).print("tailor: ordered {} {}\n", c, DF2CONSOLE(descr));

}

return n;

}

oqt order_dye_cloth(int c = 1)

{

auto [_, n] = get_or_create_order(c, df::job_type::DyeCloth, -1, -1, 0);

return n;

}

void make_dyes(int count)

{

auto reaction_produces_dye = [] (df::reaction* r) {

return std::ranges::any_of(r->products, product_is_dye);

};

for (auto r : std::ranges::views::filter(world->raws.reactions.reactions, reaction_produces_dye))

{

int max = get_reaction_max_count(r,1);

if (max > 0)

{

max = order_dye_from_reaction(r, max);

}

count = std::max(0, count - max);

if (count <= 0)

break;

}

}

int count_dye_cloth_orders()

{

auto f = [] (df::manager_order* o) {

return o->job_type == df::job_type::DyeCloth;

};

int sum = 0;

for (auto o : std::ranges::views::filter(world->manager_orders.all, f))

{

sum += o->amount_left;

}

return sum;

}

static std::pair<df::manager_order*,oqt> get_or_create_order(oqt c, df::job_type ty, int16_t sub, int32_t hfid, df::job_material_category mcat, std::string custom_reaction = "")

{

auto f = [&] (df::manager_order* order) {

return 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.race == hfid &&

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

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

order->reaction_name == custom_reaction;

};

auto orderIt = std::ranges::find_if(world->manager_orders.all, f);

if (orderIt != world->manager_orders.all.end())

{

auto o = *orderIt;

int chg = 0;

if (o->amount_left > 0)

{

int prev = o->amount_left;

o->amount_left = std::max(c, o->amount_left);

o->amount_total = std::max(c, o->amount_total);

chg = o->amount_left - prev;

}

return {o, chg};

}

auto order = new df::manager_order;

order->job_type = ty;

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

order->item_subtype = sub;

order->reaction_name = custom_reaction;

order->specdata.race = hfid;

order->material_category = mcat;

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->frequency = df::workquota_frequency_type::OneTime;

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

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

return {order, c};

}

int place_orders()

{

int ordered = 0;

int skipped = 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 {}, 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 {}, skipped\n", DF2CONSOLE(name_p));

continue;

}

DEBUG(cycle).print("tailor: ordering {} {}\n", count, DF2CONSOLE(name_p));

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 {} to {} to protect reserves of {}\n",

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

skipped += (count - c);

}

supply[m] -= c;

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

if (n > 0)

{

INFO(cycle).print("tailor: added order #{} for {} {} {}, sized for {}\n",

order->id,

n,

bitfield_to_string(order->material_category),

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

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

count -= n;

ordered += n;

}

}

else

{

skipped += count;

DEBUG(cycle).print("tailor: material {} skipped due to lack of reserves, {} available\n", DF2CONSOLE(m.name), supply[m]);

}

}

}

}

if (skipped > 0)

{

INFO(cycle).print("tailor: {} item{} not ordered due to a lack of materials\n", skipped, skipped != 1 ? "s" : "");

if (automate_dye)

{

int available_dyes = count_dyes();

int available_dyeable_cloth = count_dyeables(df::item_type::CLOTH);

int dye_cloth_orders = count_dye_cloth_orders();

DEBUG(cycle).print("tailor: available dyes = {}, available dyeable cloth = {}, dye cloth orders = {}\n",

available_dyes, available_dyeable_cloth, dye_cloth_orders);

int to_dye = std::min(skipped, std::min(available_dyes, available_dyeable_cloth) - dye_cloth_orders);

DEBUG(cycle).print("tailor: to dye = {}\n", to_dye);

if (to_dye > 0)

{

int dyed = order_dye_cloth(to_dye);

if (dyed > 0)

{

INFO(cycle).print("tailor: dyeing {} cloth\n", to_dye);

}

}

int dyes_to_make = available_dyes - to_dye;

if (dyes_to_make > 0)

{

INFO(cycle).print("tailor: ordering up to {} dyes\n", dyes_to_make);

make_dyes(dyes_to_make);

}

}

}

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 {}\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 {} without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

if (enable != is_enabled) {

is_enabled = enable;

DEBUG(control,out).print("{} 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("{} from the API, but already {} ; no action\n",

is_enabled ? "enabled" : "disabled",

is_enabled ? "enabled" : "disabled");

}

return CR_OK;

DEBUG(control,out).print("shutting down {}\n", plugin_name);

tailor_instance.release();

return CR_OK;

cycle_timestamp = 0;

config = World::GetPersistentSiteData(CONFIG_KEY);

config2 = World::GetPersistentSiteData(CONFIG_KEY_2);

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

}

if (!config2.isValid())

{

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

config2 = World::AddPersistentSiteData(CONFIG_KEY_2);

config2.set_bool(CONFIG_AUTOMATE_DYE, false);

}

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

}

// transition existing saves to CONFIG_AUTOMATE_DYE=false

if (config2.get_int(CONFIG_AUTOMATE_DYE) < 0)

{

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

config2.set_bool(CONFIG_AUTOMATE_DYE, false);

}

is_enabled = config.get_bool(CONFIG_IS_ENABLED);

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

is_enabled ? "true" : "false");

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

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

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

tailor_instance->set_automate_dye(config2.get_bool(CONFIG_AUTOMATE_DYE));

DEBUG(control, out).print("loading persisted dye automation state: {}\n",

tailor_instance->get_automate_dye() ? "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 {}\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 {} items of clothing\n", ordered);

}

return CR_OK;

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

out.printerr("Cannot run {} 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 {} 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);