{

if (!config.isValid())

return;

if (on)

config.ival(0) |= flag;

else

config.ival(0) &= ~flag;

DISABLE,

HAULERS,

AUTOMATIC,

{

PersistentDataItem config;

bool is_exclusive;

int active_dwarfs;

labor_mode mode() { return (labor_mode) config.ival(0); }

void set_mode(labor_mode mode) { config.ival(0) = mode; }

int minimum_dwarfs() { return config.ival(1); }

void set_minimum_dwarfs(int minimum_dwarfs) { config.ival(1) = minimum_dwarfs; }

int maximum_dwarfs() { return config.ival(2); }

void set_maximum_dwarfs(int maximum_dwarfs) { config.ival(2) = maximum_dwarfs; }

int talent_pool() { return config.ival(3); }

void set_talent_pool(int talent_pool) { config.ival(3) = talent_pool; }

{

labor_mode mode;

bool is_exclusive;

int minimum_dwarfs;

int maximum_dwarfs;

int active_dwarfs;

{

int highest_skill;

int total_skill;

int mastery_penalty;

int assigned_jobs;

dwarf_state state;

bool has_exclusive_labor;

int noble_penalty; // penalty for assignment due to noble status

bool medical; // this dwarf has medical responsibility

bool trader; // this dwarf has trade responsibility

bool diplomacy; // this dwarf meets with diplomats

{

enable_autolabor = false;

labor_infos.clear();

// reinstate DF's work detail system

game->external_flag.bits.automatic_professions_disabled = false;

{

labor_infos[labor].set_minimum_dwarfs(default_labor_infos[labor].minimum_dwarfs);

labor_infos[labor].set_maximum_dwarfs(default_labor_infos[labor].maximum_dwarfs);

labor_infos[labor].set_talent_pool(200);

labor_infos[labor].set_mode(default_labor_infos[labor].mode);

{

config = World::GetPersistentSiteData("autolabor/config");

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

config.ival(0) = 0;

enable_autolabor = isOptionEnabled(CF_ENABLED);

if (!enable_autolabor)

return;

// bypass DF's work detail system

game->external_flag.bits.automatic_professions_disabled = true;

auto cfg_haulpct = World::GetPersistentSiteData("autolabor/haulpct");

if (cfg_haulpct.isValid())

{

hauler_pct = cfg_haulpct.ival(0);

}

else

{

hauler_pct = 33;

}

// Load labors from save

labor_infos.resize(ARRAY_COUNT(default_labor_infos));

std::vector<PersistentDataItem> items;

World::GetPersistentSiteData(&items, "autolabor/labors/", true);

for (auto& p : items)

{

std::string key = p.key();

df::unit_labor labor = (df::unit_labor) atoi(key.substr(strlen("autolabor/labors/")).c_str());

if (labor >= 0 && size_t(labor) < labor_infos.size())

{

labor_infos[labor].config = p;

labor_infos[labor].is_exclusive = default_labor_infos[labor].is_exclusive;

labor_infos[labor].active_dwarfs = 0;

}

}

// Add default labors for those not in save

for (size_t i = 0; i < ARRAY_COUNT(default_labor_infos); i++) {

if (labor_infos[i].config.isValid())

continue;

std::stringstream name;

name << "autolabor/labors/" << i;

labor_infos[i].config = World::AddPersistentSiteData(name.str());

labor_infos[i].is_exclusive = default_labor_infos[i].is_exclusive;

labor_infos[i].active_dwarfs = 0;

reset_labor((df::unit_labor) i);

}

generate_labor_to_skill_map();

{

// Generate labor -> skill mapping

for (int i = 0; i <= ENUM_LAST_ITEM(unit_labor); i++)

labor_to_skill[i] = job_skill::NONE;

FOR_ENUM_ITEMS(job_skill, skill)

{

int labor = ENUM_ATTR(job_skill, labor, skill);

if (labor != unit_labor::NONE)

{

/*

labor_to_skill[labor] = skill;

}

}

{

if (!config.isValid())

{

config = World::AddPersistentSiteData("autolabor/config");

config.ival(0) = 0;

}

setOptionEnabled(CF_ENABLED, true);

enable_autolabor = true;

out << "Enabling autolabor." << std::endl;

cleanup_state();

init_state();

{

if (config.isValid())

setOptionEnabled(CF_ENABLED, false);

enable_autolabor = false;

out << "Disabling autolabor." << std::endl;

cleanup_state();

{

// initialize labor infos table from default table

if(ARRAY_COUNT(default_labor_infos) != ENUM_LAST_ITEM(unit_labor) + 1)

{

out.printerr("autolabor: labor size mismatch\n");

return CR_FAILURE;

}

commands.push_back(PluginCommand(

"autolabor",

"Automatically manage dwarf labors.",

autolabor));

init_state();

return CR_OK;

{

cleanup_state();

return CR_OK;

{

dwarfinfo_sorter(std::vector <dwarf_info_t> & info):dwarf_info(info){};

bool operator() (int i,int j)

{

if (dwarf_info[i].state == IDLE && dwarf_info[j].state != IDLE)

return true;

if (dwarf_info[i].state != IDLE && dwarf_info[j].state == IDLE)

return false;

return dwarf_info[i].mastery_penalty > dwarf_info[j].mastery_penalty;

};

std::vector <dwarf_info_t> & dwarf_info;

{

bool operator() (int i,int j)

{

if (labor_infos[i].mode() != labor_infos[j].mode())

return labor_infos[i].mode() < labor_infos[j].mode();

if (labor_infos[i].is_exclusive != labor_infos[j].is_exclusive)

return labor_infos[i].is_exclusive;

if (labor_infos[i].maximum_dwarfs() != labor_infos[j].maximum_dwarfs())

return labor_infos[i].maximum_dwarfs() < labor_infos[j].maximum_dwarfs();

return false;

};

{

values_sorter(std::vector <int> & values):values(values){};

bool operator() (int i,int j)

{

return values[i] > values[j];

};

std::vector<int> & values;

int n_dwarfs,

std::vector<dwarf_info_t>& dwarf_info,

bool trader_requested,

std::vector<df::unit *>& dwarfs,

bool has_butchers,

bool has_fishery,

color_ostream& out)

{

df::job_skill skill = labor_to_skill[labor];

if (labor_infos[labor].mode() != AUTOMATIC)

return;

int best_skill = 0;

std::vector<int> values(n_dwarfs);

std::vector<int> candidates;

std::map<int, int> dwarf_skill;

std::map<int, int> dwarf_skillxp;

std::vector<bool> previously_enabled(n_dwarfs);

// Find candidate dwarfs, and calculate a preference value for each dwarf

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if (dwarf_info[dwarf].state == CHILD)

continue;

if (dwarf_info[dwarf].state == MILITARY)

continue;

if (dwarf_info[dwarf].trader && trader_requested)

continue;

if (dwarf_info[dwarf].diplomacy)

continue;

if (labor_infos[labor].is_exclusive && dwarf_info[dwarf].has_exclusive_labor)

continue;

int value = dwarf_info[dwarf].mastery_penalty;

if (skill != job_skill::NONE)

{

int skill_level = 0;

int skill_experience = 0;

for (auto s : dwarfs[dwarf]->status.souls[0]->skills)

{

if (s->id == skill)

{

skill_level = s->rating;

skill_experience = s->experience;

break;

}

}

dwarf_skill[dwarf] = skill_level;

dwarf_skillxp[dwarf] = skill_experience;

if (best_skill < skill_level)

best_skill = skill_level;

value += skill_level * 100;

value += skill_experience / 20;

if (skill_level > 0 || skill_experience > 0)

value += 200;

if (skill_level >= 15)

value += 1000 * (skill_level - 14);

}

else

{

dwarf_skill[dwarf] = 0;

}

if (dwarfs[dwarf]->status.labors[labor])

{

value += 5;

if (labor_infos[labor].is_exclusive)

value += 350;

}

if (dwarf_info[dwarf].has_exclusive_labor)

value -= 500;

// bias by happiness

//value += dwarfs[dwarf]->status.happiness;

values[dwarf] = value;

candidates.push_back(dwarf);

}

int pool = labor_infos[labor].talent_pool();

if (pool < 200 && candidates.size() > 1 && size_t(abs(pool)) < candidates.size())

{

// Sort in descending order

std::sort(candidates.begin(), candidates.end(), [&](const int lhs, const int rhs) -> bool {

if (dwarf_skill[lhs] == dwarf_skill[rhs])

if (pool > 0)

return dwarf_skillxp[lhs] > dwarf_skillxp[rhs];

else

return dwarf_skillxp[lhs] < dwarf_skillxp[rhs];

else

if (pool > 0)

return dwarf_skill[lhs] > dwarf_skill[rhs];

else

return dwarf_skill[lhs] < dwarf_skill[rhs];

});

// Check if all dwarves have equivalent skills, usually zero

int first_dwarf = candidates[0];

int last_dwarf = candidates[candidates.size() - 1];

if (dwarf_skill[first_dwarf] == dwarf_skill[last_dwarf] &&

dwarf_skillxp[first_dwarf] == dwarf_skillxp[last_dwarf])

{

// There's no difference in skill, so change nothing

}

else

{

// Trim down to our top (or not) talents

candidates.resize(abs(pool));

}

}

// Sort candidates by preference value

values_sorter ivs(values);

std::sort(candidates.begin(), candidates.end(), ivs);

// Disable the labor on everyone

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if (dwarf_info[dwarf].state == CHILD)

continue;

previously_enabled[dwarf] = dwarfs[dwarf]->status.labors[labor];

dwarfs[dwarf]->status.labors[labor] = false;

}

int min_dwarfs = labor_infos[labor].minimum_dwarfs();

int max_dwarfs = labor_infos[labor].maximum_dwarfs();

// Special - don't assign hunt without a butchers, or fish without a fishery

if (unit_labor::HUNT == labor && !has_butchers)

min_dwarfs = max_dwarfs = 0;

if (unit_labor::FISH == labor && !has_fishery)

min_dwarfs = max_dwarfs = 0;

// If there are enough idle dwarves to choose from, enter an aggressive assignment

// mode. "Enough" idle dwarves is defined as 2 or 10% of the total number of dwarves,

// whichever is higher.

//

// In aggressive mode, we will always pick at least one idle dwarf for each skill,

// in order to try to get the idle dwarves to start doing something. We also pick

// any dwarf more preferable to the idle dwarf, since we'd rather have a more

// preferable dwarf do a new job if one becomes available (probably because that

// dwarf just finished a job).

//

// In non-aggressive mode, only dwarves that are good at a labor will be assigned

// to it. Dwarves good at nothing, or nothing that needs doing, will tend to get

// assigned to hauling by the hauler code. If there are no hauling jobs to do,

// they will sit around idle and when enough build up they will trigger aggressive

// mode again.

bool aggressive_mode = state_count[IDLE] >= 2 && state_count[IDLE] >= n_dwarfs * idler_pct / 100;

/*

for (size_t i = 0; i < candidates.size() && labor_infos[labor].active_dwarfs < max_dwarfs; i++)

{

int dwarf = candidates[i];

if (dwarf_info[dwarf].trader && trader_requested)

continue;

if (dwarf_info[dwarf].diplomacy)

continue;

assert(dwarf >= 0);

assert(dwarf < n_dwarfs);

bool preferred_dwarf = false;

if (dwarf_skillxp[dwarf] > 0 && dwarf_skill[dwarf] >= best_skill / 2)

preferred_dwarf = true;

if (previously_enabled[dwarf] && labor_infos[labor].is_exclusive && dwarf_info[dwarf].state == EXCLUSIVE)

preferred_dwarf = true;

if (dwarf_info[dwarf].medical && labor == df::unit_labor::DIAGNOSE)

preferred_dwarf = true;

if (labor_infos[labor].active_dwarfs >= min_dwarfs && !preferred_dwarf && !aggressive_mode)

continue;

if (!dwarfs[dwarf]->status.labors[labor])

dwarf_info[dwarf].assigned_jobs++;

if (Units::isValidLabor(dwarfs[dwarf], labor))

dwarfs[dwarf]->status.labors[labor] = true;

if (labor_infos[labor].is_exclusive)

{

dwarf_info[dwarf].has_exclusive_labor = true;

// all the exclusive labors require equipment so this should force the dorf to reequip if needed

dwarfs[dwarf]->uniform.pickup_flags.bits.update = 1;

}

TRACE(cycle, out).print("Dwarf {} \"{}\" assigned {}: value {} {} {}\n",

dwarf, dwarfs[dwarf]->name.first_name, ENUM_KEY_STR(unit_labor, labor), values[dwarf],

dwarf_info[dwarf].trader ? "(trader)" : "",

dwarf_info[dwarf].diplomacy ? "(diplomacy)" : "");

if (dwarf_info[dwarf].state == IDLE || dwarf_info[dwarf].state == BUSY || dwarf_info[dwarf].state == EXCLUSIVE)

labor_infos[labor].active_dwarfs++;

if (dwarf_info[dwarf].state == IDLE)

aggressive_mode = false;

}

cycle_timestamp = 0;

cleanup_state();

init_state();

return CR_OK;

{

switch (event) {

case SC_MAP_UNLOADED:

cleanup_state();

break;

default:

break;

}

return CR_OK;

{

if(!world || !world->map.block_index || !enable_autolabor)

{

return CR_OK;

}

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

return CR_OK;

cycle_timestamp = world->frame_counter;

std::vector<df::unit *> dwarfs;

bool has_butchers = false;

bool has_fishery = false;

bool trader_requested = false;

for (auto& build : world->buildings.all)

{

auto type = build->getType();

if (building_type::Workshop == type)

{

df::workshop_type subType = (df::workshop_type)build->getSubtype();

if (workshop_type::Butchers == subType)

has_butchers = true;

if (workshop_type::Fishery == subType)

has_fishery = true;

}

else if (building_type::TradeDepot == type)

{

df::building_tradedepotst* depot = (df::building_tradedepotst*) build;

trader_requested = trader_requested || depot->trade_flags.bits.trader_requested;

TRACE(cycle,out).print("{}", trader_requested

? "Trade depot found and trader requested, trader will be excluded from all labors.\n"

: "Trade depot found but trader is not requested.\n"

);

}

}

for (auto& cre : world->units.active)

{

if (Units::isCitizen(cre))

{

if (cre->burrows.size() > 0)

continue; // dwarfs assigned to active burrows are skipped entirely

dwarfs.push_back(cre);

}

}

int n_dwarfs = dwarfs.size();

if (n_dwarfs == 0)

return CR_OK;

std::vector<dwarf_info_t> dwarf_info(n_dwarfs);

// Find total skill and highest skill for each dwarf. More skilled dwarves shouldn't be used for minor tasks.

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if (dwarfs[dwarf]->status.souls.size() <= 0)

continue;

// compute noble penalty

int noble_penalty = 0;

df::historical_figure* hf = df::historical_figure::find(dwarfs[dwarf]->hist_figure_id);

if(hf!=NULL) //can be NULL. E.g. script created citizens

for (auto& hfelink : hf->entity_links)

{

if (hfelink->getType() == df::histfig_entity_link_type::POSITION)

{

df::histfig_entity_link_positionst *epos =

(df::histfig_entity_link_positionst*) hfelink;

df::historical_entity* entity = df::historical_entity::find(epos->entity_id);

if (!entity)

continue;

df::entity_position_assignment* assignment = binsearch_in_vector(entity->positions.assignments, epos->assignment_id);

if (!assignment)

continue;

df::entity_position* position = binsearch_in_vector(entity->positions.own, assignment->position_id);

if (!position)

continue;

for (int n = 0; n < 25; n++)

if (position->responsibilities[n])

noble_penalty += responsibility_penalties[n];

if (position->responsibilities[df::entity_position_responsibility::HEALTH_MANAGEMENT])

dwarf_info[dwarf].medical = true;

if (position->responsibilities[df::entity_position_responsibility::TRADE])

dwarf_info[dwarf].trader = true;

}

}

dwarf_info[dwarf].noble_penalty = noble_penalty;

// identify dwarfs who are needed for meetings and mark them for exclusion

for (auto& act : plotinfo->activities)

{

if (!act) continue;

bool p1 = act->unit_actor == dwarfs[dwarf]->id;

bool p2 = act->unit_noble == dwarfs[dwarf]->id;

if (p1 || p2)

{

dwarf_info[dwarf].diplomacy = true;

DEBUG(cycle, out).print("Dwarf {} \"{}\" has a meeting, will be cleared of all labors\n",

dwarf, dwarfs[dwarf]->name.first_name);

break;

}

}

for (auto& skill : dwarfs[dwarf]->status.souls[0]->skills)

{

df::job_skill_class skill_class = ENUM_ATTR(job_skill, type, skill->id);

int skill_level = skill->rating;

// Track total & highest skill among normal/medical skills. (We don't care about personal or social skills.)

if (skill_class != job_skill_class::Normal && skill_class != job_skill_class::Medical)

continue;

if (dwarf_info[dwarf].highest_skill < skill_level)

dwarf_info[dwarf].highest_skill = skill_level;

dwarf_info[dwarf].total_skill += skill_level;

}

}

// Calculate a base penalty for using each dwarf for a task he isn't good at.

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

dwarf_info[dwarf].mastery_penalty -= 40 * dwarf_info[dwarf].highest_skill;

dwarf_info[dwarf].mastery_penalty -= 10 * dwarf_info[dwarf].total_skill;

dwarf_info[dwarf].mastery_penalty -= dwarf_info[dwarf].noble_penalty;

FOR_ENUM_ITEMS(unit_labor, labor)

{

if (labor == unit_labor::NONE)

continue;

if (labor_infos[labor].is_exclusive && dwarfs[dwarf]->status.labors[labor])

dwarf_info[dwarf].mastery_penalty -= 100;

}

}

// Find the activity state for each dwarf. It's important to get this right - a dwarf who we think is IDLE but

// can't work will gum everything up. In the future I might add code to auto-detect slacker dwarves.

state_count.clear();

state_count.resize(NUM_STATE);

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if (Units::isBaby(dwarfs[dwarf]) ||

Units::isChild(dwarfs[dwarf]) ||

dwarfs[dwarf]->profession == profession::DRUNK)

{

dwarf_info[dwarf].state = CHILD;

}

else if (ENUM_ATTR(profession, military, dwarfs[dwarf]->profession))

dwarf_info[dwarf].state = MILITARY;

else if (dwarfs[dwarf]->job.current_job == NULL)

{

if (Units::getMiscTrait(dwarfs[dwarf], misc_trait_type::Migrant))

dwarf_info[dwarf].state = OTHER;

else if (dwarfs[dwarf]->specific_refs.size() > 0)

dwarf_info[dwarf].state = OTHER;

else

dwarf_info[dwarf].state = IDLE;

}

else

{

int job = dwarfs[dwarf]->job.current_job->job_type;

if (job >= 0 && size_t(job) < ARRAY_COUNT(dwarf_states))

dwarf_info[dwarf].state = dwarf_states[job];

else

{

WARN(cycle, out).print("Dwarf {} \"{}\" has unknown job {}\n", dwarf, dwarfs[dwarf]->name.first_name, job);

dwarf_info[dwarf].state = OTHER;

}

}

state_count[dwarf_info[dwarf].state]++;

TRACE(cycle, out).print("Dwarf {} \"{}\": penalty {}, state {}\n",

dwarf, dwarfs[dwarf]->name.first_name, dwarf_info[dwarf].mastery_penalty, state_names[dwarf_info[dwarf].state]);

}

std::vector<df::unit_labor> labors;

FOR_ENUM_ITEMS(unit_labor, labor)

{

if (labor == unit_labor::NONE)

continue;

labor_infos[labor].active_dwarfs = 0;

labors.push_back(labor);

}

laborinfo_sorter lasorter;

std::sort(labors.begin(), labors.end(), lasorter);

// Handle DISABLED skills (just bookkeeping).

// Note that autolabor should *NEVER* enable or disable a skill that has been marked as DISABLED, for any reason.

// The user has told us that they want manage this skill manually, and we must respect that.

for (auto& labor: labors)

{

if (labor_infos[labor].mode() != DISABLE)

continue;

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if (dwarfs[dwarf]->status.labors[labor])

{

if (labor_infos[labor].is_exclusive)

dwarf_info[dwarf].has_exclusive_labor = true;

dwarf_info[dwarf].assigned_jobs++;

}

}

}

// Handle all skills except those marked HAULERS

for (auto& labor : labors)

{

assign_labor(labor, n_dwarfs, dwarf_info, trader_requested, dwarfs, has_butchers, has_fishery, out);

}

// Set about 1/3 of the dwarfs as haulers. The haulers have all HAULER labors enabled. Having a lot of haulers helps

// make sure that hauling jobs are handled quickly rather than building up.

int num_haulers = state_count[IDLE] + (state_count[BUSY] + state_count[EXCLUSIVE]) * hauler_pct / 100;

if (num_haulers < 1)

num_haulers = 1;

std::vector<int> hauler_ids;

for (int dwarf = 0; dwarf < n_dwarfs; dwarf++)

{

if ((dwarf_info[dwarf].trader && trader_requested) ||

dwarf_info[dwarf].diplomacy)

{

FOR_ENUM_ITEMS(unit_labor, labor)

{

if (labor == unit_labor::NONE)

continue;

if (labor_infos[labor].mode() != HAULERS)

continue;

dwarfs[dwarf]->status.labors[labor] = false;

}

if (dwarf_info[dwarf].state == IDLE || dwarf_info[dwarf].state == BUSY || dwarf_info[dwarf].state == EXCLUSIVE)

{

num_haulers--;

}

continue;