DISABLE,

HAULERS,

AUTOMATIC,

// Ready for a new task

IDLE,

// Busy with a useful task

BUSY,

// Busy with a useful task that requires a tool

EXCLUSIVE,

// In the military, can't work

MILITARY,

// Child or noble, can't work

CHILD,

// Doing something that precludes working, may be busy for a while

OTHER

{

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

{

if (!config.isValid())

return;

if (on)

config.ival(0) |= flag;

else

config.ival(0) &= ~flag;

{

enable_autolabor = false;

labor_infos.clear();

{

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::GetPersistentData("autolabor/config");

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

config.ival(0) = 0;

enable_autolabor = isOptionEnabled(CF_ENABLED);

if (!enable_autolabor)

return;

auto cfg_haulpct = World::GetPersistentData("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::GetPersistentData(&items, "autolabor/labors/", true);

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

{

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::AddPersistentData(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::AddPersistentData("autolabor/config");

config.ival(0) = 0;

}

setOptionEnabled(CF_ENABLED, true);

enable_autolabor = true;

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

cleanup_state();

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

}

// Fill the command list with your commands.

commands.push_back(PluginCommand(

"autolabor", "Automatically manage dwarf labors.",

autolabor, false, /* true means that the command can't be used from non-interactive user interface */

// Extended help string. Used by CR_WRONG_USAGE and the help command:

" autolabor enable\n"

" autolabor disable\n"

" Enables or disables the plugin.\n"

" autolabor <labor> <minimum> [<maximum>] [<talent pool>]\n"

" Set number of dwarves assigned to a labor.\n"

" autolabor <labor> haulers\n"

" Set a labor to be handled by hauler dwarves.\n"

" autolabor <labor> disable\n"

" Turn off autolabor for a specific labor.\n"

" autolabor <labor> reset\n"

" Return a labor to the default handling.\n"

" autolabor reset-all\n"

" Return all labors to the default handling.\n"

" autolabor list\n"

" List current status of all labors.\n"

" autolabor status\n"

" Show basic status information.\n"

"Function:\n"

" When enabled, autolabor periodically checks your dwarves and enables or\n"

" disables labors. It tries to keep as many dwarves as possible busy but\n"

" also tries to have dwarves specialize in specific skills.\n"

" Warning: autolabor will override any manual changes you make to labors\n"

" while it is enabled.\n"

" To prevent particular dwarves from being managed by autolabor, put them\n"

" in any burrow.\n"

" To restrict the assignment of a labor to only the top <n> most skilled\n"

" dwarves, add a talent pool number <n>.\n"

"Examples:\n"

" autolabor MINE 2\n"

" Keep at least 2 dwarves with mining enabled.\n"

" autolabor CUT_GEM 1 1\n"

" Keep exactly 1 dwarf with gemcutting enabled.\n"

" autolabor COOK 1 1 3\n"

" Keep 1 dwarf with cooking enabled, selected only from the top 3.\n"

" autolabor FEED_WATER_CIVILIANS haulers\n"

" Have haulers feed and water wounded dwarves.\n"

" autolabor CUTWOOD disable\n"

" Turn off autolabor for wood cutting.\n"

));

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_dwarf = 0;

int best_value = -10000;

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

auto mode = labor_infos[labor].mode();

// 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.begin(); s < dwarfs[dwarf]->status.souls[0]->skills.end(); s++)

{

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 && 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]->military.pickup_flags.bits.update = 1;

}

if (print_debug)

out.print("Dwarf %i \"%s\" assigned %s: value %i %s %s\n", dwarf, dwarfs[dwarf]->name.first_name.c_str(), ENUM_KEY_STR(unit_labor, labor).c_str(), values[dwarf], dwarf_info[dwarf].trader ? "(trader)" : "", dwarf_info[dwarf].diplomacy ? "(diplomacy)" : "");