{

commands.clear();

if (!world || !ui)

return CR_FAILURE;

if (ui_workshop_job_cursor && job_next_id) {

commands.push_back(

PluginCommand(

"workflow", "Manage control of repeat jobs.",

workflow_cmd, false,

" workflow enable [option...]\n"

" workflow disable [option...]\n"

" If no options are specified, enables or disables the plugin.\n"

" Otherwise, enables or disables any of the following options:\n"

" - drybuckets: Automatically empty abandoned water buckets.\n"

" - auto-melt: Resume melt jobs when there are objects to melt.\n"

" workflow jobs\n"

" List workflow-controlled jobs (if in a workshop, filtered by it).\n"

" workflow list\n"

" List active constraints, and their job counts.\n"

" workflow count <constraint-spec> <cnt-limit> [cnt-gap]\n"

" workflow amount <constraint-spec> <cnt-limit> [cnt-gap]\n"

" Set a constraint. The first form counts each stack as only 1 item.\n"

" workflow unlimit <constraint-spec>\n"

" Delete a constraint.\n"

"Function:\n"

" - When the plugin is enabled, it protects all repeat jobs from removal.\n"

" If they do disappear due to any cause, they are immediately re-added\n"

" to their workshop and suspended.\n"

" - In addition, when any constraints on item amounts are set, repeat jobs\n"

" that produce that kind of item are automatically suspended and resumed\n"

" as the item amount goes above or below the limit. The gap specifies how\n"

" much below the limit the amount has to drop before jobs are resumed;\n"

" this is intended to reduce the frequency of jobs being toggled.\n"

"Constraint examples:\n"

" workflow amount AMMO:ITEM_AMMO_BOLTS/METAL 1000 100\n"

" workflow amount AMMO:ITEM_AMMO_BOLTS/WOOD,BONE 200 50\n"

" Keep metal bolts within 900-1000, and wood/bone within 150-200.\n"

" workflow count FOOD 120 30\n"

" workflow count DRINK 120 30\n"

" Keep the number of prepared food & drink stacks between 90 and 120\n"

" workflow count BIN 30\n"

" workflow count BARREL 30\n"

" workflow count BOX/CLOTH,SILK,YARN 30\n"

" Make sure there are always 25-30 empty bins/barrels/bags.\n"

" workflow count BAR//COAL 20\n"

" workflow count BAR//COPPER 30\n"

" Make sure there are always 15-20 coal and 25-30 copper bars.\n"

" workflow count POWDER_MISC/SAND 20\n"

" workflow count BOULDER/CLAY 20\n"

" Collect 15-20 sand bags and clay boulders.\n"

" workflow amount POWDER_MISC//MUSHROOM_CUP_DIMPLE:MILL 100 20\n"

" Make sure there are always 80-100 units of dimple dye.\n"

" In order for this to work, you have to set the material of\n"

" the PLANT input on the Mill Plants job to MUSHROOM_CUP_DIMPLE\n"

" using the 'job item-material' command.\n"

)

);

}

init_state(c);

return CR_OK;

{

cleanup_state(c);

return CR_OK;

{

switch (event) {

case SC_GAME_LOADED:

cleanup_state(c);

init_state(c);

break;

case SC_GAME_UNLOADED:

cleanup_state(c);

break;

default:

break;

}

return CR_OK;

int id;

int building_id;

int tick_idx;

static int cur_tick_idx;

df::building *holder;

df::job *job_copy;

int reaction_id;

df::job *actual_job;

bool want_resumed;

int resume_time, resume_delay;

std::vector<ItemConstraint*> constraints;

ProtectedJob(df::job *job) : id(job->id)

{

tick_idx = cur_tick_idx;

holder = getJobHolder(job);

building_id = holder ? holder->id : -1;

job_copy = cloneJobStruct(job);

actual_job = job;

reaction_id = -1;

want_resumed = false;

resume_time = 0; resume_delay = DAY_TICKS;

}

~ProtectedJob()

{

deleteJobStruct(job_copy);

}

bool isActuallyResumed() {

return actual_job && !actual_job->flags.bits.suspend;

}

bool isResumed() {

return want_resumed || isActuallyResumed();

}

bool isLive() { return actual_job != NULL; }

void update(df::job *job)

{

actual_job = job;

if (*job == *job_copy)

return;

reaction_id = -1;

deleteJobStruct(job_copy);

job_copy = cloneJobStruct(job);

}

void tick_job(df::job *job, int ticks)

{

tick_idx = cur_tick_idx;

actual_job = job;

if (isActuallyResumed())

{

resume_time = 0;

resume_delay = std::max(DAY_TICKS, resume_delay - ticks);

}

else if (want_resumed)

{

if (!resume_time)

want_resumed = false;

else if (world->frame_counter >= resume_time)

actual_job->flags.bits.suspend = false;

}

}

void recover(df::job *job)

{

actual_job = job;

job->flags.bits.repeat = true;

job->flags.bits.suspend = true;

resume_delay = std::min(DAY_TICKS*MONTH_DAYS, 5*resume_delay/3);

resume_time = world->frame_counter + resume_delay;

}

void set_resumed(bool resume)

{

if (resume)

{

if (world->frame_counter >= resume_time)

actual_job->flags.bits.suspend = false;

}

else

{

resume_time = 0;

if (isActuallyResumed())

resume_delay = DAY_TICKS;

actual_job->flags.bits.suspend = true;

}

want_resumed = resume;

}

PersistentDataItem config;

ItemTypeInfo item;

MaterialInfo material;

df::dfhack_material_category mat_mask;

int weight;

std::vector<ProtectedJob*> jobs;

int item_amount, item_count, item_inuse;

bool request_suspend, request_resume;

bool is_active, cant_resume_reported;

TMaterialCache material_cache;

ItemConstraint()

: weight(0), item_amount(0), item_count(0), item_inuse(0)

, is_active(false), cant_resume_reported(false)

{}

int goalCount() { return config.ival(0); }

void setGoalCount(int v) { config.ival(0) = v; }

int goalGap() {

int gcnt = std::max(1, goalCount()/2);

return std::min(gcnt, config.ival(1) <= 0 ? 5 : config.ival(1));

}

void setGoalGap(int v) { config.ival(1) = v; }

bool goalByCount() { return config.ival(2) & 1; }

void setGoalByCount(bool v) {

if (v)

config.ival(2) |= 1;

else

config.ival(2) &= ~1;

}

void init(const std::string &str)

{

config.val() = str;

config.ival(2) = 0;

}

void computeRequest()

{

int size = goalByCount() ? item_count : item_amount;

request_resume = (size <= goalCount()-goalGap());

request_suspend = (size >= goalCount());

}

CF_ENABLED = 1,

CF_DRYBUCKETS = 2,

CF_AUTOMELT = 4

{

return job->misc_links.empty() &&

getJobHolder(job) &&

(!job->job_items.empty() ||

job->job_type == job_type::CollectClay ||

job->job_type == job_type::CollectSand);

{

df::job_list_link *p = world->job_list.next;

for (; p; p = p->next)

rv[p->item->id] = p->item;

{

if (!config.isValid())

return;

if (on)

config.ival(0) |= flag;

else

config.ival(0) &= ~flag;

{

pending_recover.clear();

if (!known_jobs.empty())

c->con.print("Unprotecting %d jobs.\n", known_jobs.size());

for (TKnownJobs::iterator it = known_jobs.begin(); it != known_jobs.end(); ++it)

delete it->second;

known_jobs.clear();

{

config = PersistentDataItem();

stop_protect(c);

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

delete constraints[i];

constraints.clear();

{

check_lost_jobs(c, 0);

if (!known_jobs.empty())

c->con.print("Protecting %d jobs.\n", known_jobs.size());

{

config = c->getWorld()->GetPersistentData("workflow/config");

if (config.isValid() && config.ival(0) == -1)

config.ival(0) = 0;

enabled = isOptionEnabled(CF_ENABLED);

// Parse constraints

std::vector<PersistentDataItem> items;

c->getWorld()->GetPersistentData(&items, "workflow/constraints");

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

if (get_constraint(c, items[i].val(), &items[i]))

continue;

c->con.printerr("Lost constraint %s\n", items[i].val().c_str());

c->getWorld()->DeletePersistentData(items[i]);

}

last_tick_frame_count = world->frame_counter;

last_frame_count = world->frame_counter;

if (!enabled)

return;

start_protect(c);

{

if (!config.isValid())

{

config = c->getWorld()->AddPersistentData("workflow/config");

config.ival(0) = 0;

}

setOptionEnabled(CF_ENABLED, true);

enabled = true;

c->con << "Enabling the plugin." << endl;

start_protect(c);

{

known_jobs.erase(pj->id);

delete pj;

{

if (pj->isLive())

return true;

// Check that the building exists

pj->holder = df::building::find(pj->building_id);

if (!pj->holder)

{

c->con.printerr("Forgetting job %d (%s): holder building lost.",

pj->id, ENUM_KEY_STR(job_type, pj->job_copy->job_type));

forget_job(c, pj);

return true;

}

// Check its state and postpone or cancel if invalid

if (pj->holder->jobs.size() >= 10)

{

c->con.printerr("Forgetting job %d (%s): holder building has too many jobs.",

pj->id, ENUM_KEY_STR(job_type, pj->job_copy->job_type));

forget_job(c, pj);

return true;

}

if (!pj->holder->jobs.empty())

{

df::job_type ftype = pj->holder->jobs[0]->job_type;

if (ftype == job_type::DestroyBuilding)

return false;

if (ENUM_ATTR(job_type,type,ftype) == job_type_class::StrangeMood)

return false;

}

// Create and link in the actual job structure

df::job *recovered = cloneJobStruct(pj->job_copy);

if (!linkJobIntoWorld(recovered, false)) // reuse same id

{

deleteJobStruct(recovered);

c->con.printerr("Inconsistency: job %d (%s) already in list.",

pj->id, ENUM_KEY_STR(job_type, pj->job_copy->job_type));

return true;

}

pj->holder->jobs.push_back(recovered);

// Done

pj->recover(recovered);

return true;

{

ProtectedJob::cur_tick_idx++;

if (ticks < 0) ticks = 0;

df::job_list_link *p = world->job_list.next;

for (; p; p = p->next)

{

df::job *job = p->item;

ProtectedJob *pj = get_known(job->id);

if (pj)

{

if (!job->flags.bits.repeat)

forget_job(c, pj);

else

pj->tick_job(job, ticks);

}

else if (job->flags.bits.repeat && isSupportedJob(job))

{

pj = new ProtectedJob(job);

assert(pj->holder);

known_jobs[pj->id] = pj;

}

}

for (TKnownJobs::const_iterator it = known_jobs.begin(); it != known_jobs.end(); ++it)

{

if (it->second->tick_idx == ProtectedJob::cur_tick_idx ||

!it->second->isLive())

continue;

it->second->actual_job = NULL;

pending_recover.push_back(it->second);

}

{

df::job_list_link *p = world->job_list.next;

for (; p; p = p->next)

{

ProtectedJob *pj = get_known(p->item->id);

if (!pj)

continue;

pj->update(p->item);

}

{

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

if (recover_job(c, pending_recover[i]))

vector_erase_at(pending_recover, i);

{

if (!enabled)

return CR_OK;

// Every 5 frames check the jobs for disappearance

static unsigned cnt = 0;

if ((++cnt % 5) != 0)

return CR_OK;

check_lost_jobs(c, world->frame_counter - last_tick_frame_count);

last_tick_frame_count = world->frame_counter;

// Proceed every in-game half-day, or when jobs to recover changed

static unsigned last_rlen = 0;

bool check_time = (world->frame_counter - last_frame_count) >= DAY_TICKS/2;

if (pending_recover.size() != last_rlen || check_time)

{

recover_jobs(c);

last_rlen = pending_recover.size();

// If the half-day passed, proceed to update

if (check_time)

{

last_frame_count = world->frame_counter;

update_job_data(c);

process_constraints(c);

}

}

return CR_OK;

{

int idx = linear_index(constraints, cv);

if (idx >= 0)

vector_erase_at(constraints, idx);

c->getWorld()->DeletePersistentData(cv->config);

delete cv;

df::dfhack_material_category mat_mask,

int16_t mat_type, int32_t mat_index)

{

MaterialInfo mat(mat_type, mat_index);

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

{

ItemConstraint *ct = constraints[i];

if (ct->item.type != itype ||

(ct->item.subtype != -1 && ct->item.subtype != isubtype))

continue;

if (!mat.matches(ct->material))

continue;

if (ct->mat_mask.whole)

{

if (mat.isValid())

{

if (!mat.matches(ct->mat_mask))

continue;

}

else

{

if (!(mat_mask.whole & ct->mat_mask.whole))

continue;

}

}

if (linear_index(pj->constraints, ct) >= 0)

continue;

ct->jobs.push_back(pj);

pj->constraints.push_back(ct);

if (!ct->is_active && pj->isResumed())

ct->is_active = true;

}

{

if (pj->reaction_id < 0)

pj->reaction_id = linear_index(df::reaction::get_vector(),

&df::reaction::code, job->reaction_name);

df::reaction *r = df::reaction::find(pj->reaction_id);

if (!r)

return;

for (size_t i = 0; i < r->products.size(); i++)

{

using namespace df::enums::reaction_product_item_flags;

VIRTUAL_CAST_VAR(prod, df::reaction_product_itemst, r->products[i]);

if (!prod || prod->item_type < 0)

continue;

MaterialInfo mat(prod);

df::dfhack_material_category mat_mask(0);

bool get_mat_prod = prod->flags.is_set(GET_MATERIAL_PRODUCT);

if (get_mat_prod || prod->flags.is_set(GET_MATERIAL_SAME))

{

int reagent_idx = linear_index(r->reagents, &df::reaction_reagent::code,

prod->get_material.reagent_code);

if (reagent_idx < 0)

continue;

int item_idx = linear_index(job->job_items, &df::job_item::reagent_index, reagent_idx);

if (item_idx >= 0)

mat.decode(job->job_items[item_idx]);

else

{

VIRTUAL_CAST_VAR(src, df::reaction_reagent_itemst, r->reagents[reagent_idx]);

if (!src)

continue;

mat.decode(src);

}

if (get_mat_prod)

{

std::string code = prod->get_material.product_code;

if (mat.isValid())

{

int idx = linear_index(mat.material->reaction_product.id, code);

if (idx < 0)

continue;

mat.decode(mat.material->reaction_product.material, idx);

}

else

{

if (code == "SOAP_MAT")

mat_mask.bits.soap = true;

}

}

}

link_job_constraint(pj, prod->item_type, prod->item_subtype,

mat_mask, mat.type, mat.index);

}

{

using namespace df::enums::job_type;

if (job->job_type == PrepareMeal)

mat.decode(-1);

else

mat.decode(job);

mat_mask.whole = job->material_category.whole;

// Material from the job enum

const char *job_material = ENUM_ATTR(job_type, material, job->job_type);

if (job_material)

{

MaterialInfo info;

if (info.findBuiltin(job_material))

mat = info;

else

parseJobMaterialCategory(&mat_mask, job_material);

}

// Material from the job reagent

if (!mat.isValid() && !job->job_items.empty() &&

(job->job_items.size() == 1 ||

job->job_items[0]->item_type == item_type::PLANT))

{

mat.decode(job->job_items[0]);

switch (job->job_items[0]->item_type)

{

case item_type::WOOD:

mat_mask.bits.wood = mat_mask.bits.wood2 = true;

break;

}

}

{

using namespace df::enums::job_type;

// Custom reactions handled in another function

df::job *job = pj->job_copy;

if (job->job_type == CustomReaction)

{

compute_custom_job(pj, job);

return;

}

// Item type & subtype

df::item_type itype = ENUM_ATTR(job_type, item, job->job_type);

int16_t isubtype = job->item_subtype;

if (itype == item_type::NONE)

return;

// Item material & material category

MaterialInfo mat;

df::dfhack_material_category mat_mask;

guess_job_material(job, mat, mat_mask);

// Job-specific code

switch (job->job_type)

{

case SmeltOre:

if (mat.inorganic)

{

std::vector<int16_t> &ores = mat.inorganic->metal_ore.mat_index;

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

link_job_constraint(pj, item_type::BAR, -1, 0, 0, ores[i]);

}

return;

case ExtractMetalStrands:

if (mat.inorganic)

{

std::vector<int16_t> &threads = mat.inorganic->thread_metal.mat_index;

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

link_job_constraint(pj, item_type::THREAD, -1, 0, 0, threads[i]);

}

return;

case PrepareMeal:

if (job->mat_type != -1)

{

std::vector<df::itemdef_foodst*> &food = df::itemdef_foodst::get_vector();

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

if (food[i]->level == job->mat_type)

link_job_constraint(pj, item_type::FOOD, i, 0, -1, -1);

return;

}

break;

#define PLANT_PROCESS_MAT(flag, tag) \

if (mat.plant && mat.plant->flags.is_set(plant_raw_flags::flag)) \

mat.decode(mat.plant->material_defs.type_##tag, \

mat.plant->material_defs.idx_##tag); \

else mat.decode(-1);

case MillPlants:

PLANT_PROCESS_MAT(MILL, mill);

break;

case ProcessPlants:

PLANT_PROCESS_MAT(THREAD, thread);

break;

case ProcessPlantsBag:

PLANT_PROCESS_MAT(LEAVES, leaves);

break;

case ProcessPlantsBarrel:

PLANT_PROCESS_MAT(EXTRACT_BARREL, extract_barrel);

break;

case ProcessPlantsVial:

PLANT_PROCESS_MAT(EXTRACT_VIAL, extract_vial);

break;

case ExtractFromPlants:

PLANT_PROCESS_MAT(EXTRACT_STILL_VIAL, extract_still_vial);

break;

#undef PLANT_PROCESS_MAT

default:

break;

}

link_job_constraint(pj, itype, isubtype, mat_mask, mat.type, mat.index);

{

melt_active = false;

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

{

constraints[i]->jobs.clear();

constraints[i]->is_active = false;

}

for (TKnownJobs::const_iterator it = known_jobs.begin(); it != known_jobs.end(); ++it)

{

ProtectedJob *pj = it->second;

pj->constraints.clear();

if (!pj->isLive())

continue;

if (!melt_active && pj->actual_job->job_type == job_type::MeltMetalObject)

melt_active = pj->isResumed();

compute_job_outputs(c, pj);

}

{

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

{

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

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

{

df::item *obj = ref->getItem();

if (obj &&

obj->getType() == item_type::LIQUID_MISC &&

obj->getMaterial() == builtin_mats::WATER)

{

obj->flags.bits.garbage_colect = true;

obj->flags.bits.hidden = true;

}

}

}