DISABLE,

HAULERS,

AUTOMATIC,

// Ready for a new task

IDLE,

// Busy with a useful task

BUSY,

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

{

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

int single_labor; // this dwarf will be exclusively assigned to one labor (-1/NONE for none)

{

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_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 && 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 (int 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 the plugin." << endl;

cleanup_state();

init_state();

{

// initialize labor infos table from default table

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

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>]\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"

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

{

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

};

{

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;

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

std::vector<int> candidates;

std::map<int, int> dwarf_skill;

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;

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;

}

// bias by happiness

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

values[dwarf] = value;

candidates.push_back(dwarf);

}

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

bool want_idle_dwarf = true;

if (state_count[IDLE] < 2)

want_idle_dwarf = false;

/*

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

{

int dwarf = candidates[i];

assert(dwarf >= 0);

assert(dwarf < n_dwarfs);

bool preferred_dwarf = false;

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

preferred_dwarf = true;

if (dwarf_skill[dwarf] > 0)

preferred_dwarf = true;

if (previously_enabled[dwarf] && labor_infos[labor].is_exclusive)

preferred_dwarf = true;

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

preferred_dwarf = true;

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

continue;

if (dwarf_info[dwarf].diplomacy)

continue;

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

continue;

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

dwarf_info[dwarf].assigned_jobs++;

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

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

labor_infos[labor].active_dwarfs++;

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

want_idle_dwarf = false;

}

{

switch (event) {

case SC_MAP_LOADED:

cleanup_state();

init_state();

break;

case SC_MAP_UNLOADED:

cleanup_state();

break;

default:

break;

}

return CR_OK;

{

static int step_count = 0;

// check run conditions

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

{

// give up if we shouldn't be running'

return CR_OK;

}

if (++step_count < 60)

return CR_OK;

step_count = 0;

uint32_t race = ui->race_id;

uint32_t civ = ui->civ_id;

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

bool has_butchers = false;

bool has_fishery = false;

bool trader_requested = false;

for (int i = 0; i < world->buildings.all.size(); ++i)

{

df::building *build = world->buildings.all[i];

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;

if (print_debug)

{

if (trader_requested)

out.print("Trade depot found and trader requested, trader will be excluded from all labors.\n");

else

out.print("Trade depot found but trader is not requested.\n");

}

}

}

for (int i = 0; i < world->units.active.size(); ++i)

{

df::unit* cre = world->units.active[i];

if (Units::isCitizen(cre))

{

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

continue; // dwarfs assigned to 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);