// Dwarf Manipulator - a Therapist-style labor editor

#include <Console.h>

#include <Export.h>

#include <PluginManager.h>

#include <MiscUtils.h>

#include <modules/Screen.h>

#include <modules/Translation.h>

#include <modules/Units.h>

#include <modules/Military.h>

#include <modules/Filesystem.h>

#include <modules/Job.h>

#include <vector>

#include <string>

#include <set>

#include <algorithm>

#include <tuple>

#include <VTableInterpose.h>

#include "df/activity_event.h"

#include "df/world.h"

#include "df/plotinfost.h"

#include "df/graphic.h"

#include "df/enabler.h"

#include "df/viewscreen_unitlistst.h"

#include "df/interface_key.h"

#include "df/unit.h"

#include "df/unit_soul.h"

#include "df/unit_skill.h"

#include "df/creature_graphics_role.h"

#include "df/creature_raw.h"

#include "df/caste_raw.h"

#include "df/historical_entity.h"

#include "df/entity_raw.h"

#include "df/goal_type.h"

#include "df/unit_personality.h"

#include "uicommon.h"

#include "listcolumn.h"

using std::stringstream;

using std::set;

using std::vector;

using std::string;

using namespace DFHack;

using namespace df::enums;

DFHACK_PLUGIN("manipulator");

DFHACK_PLUGIN_IS_ENABLED(is_enabled);

REQUIRE_GLOBAL(world);

REQUIRE_GLOBAL(plotinfo);

REQUIRE_GLOBAL(gps);

REQUIRE_GLOBAL(enabler);

struct SkillLevel

{

const char *name;

int points;

char abbrev;

};

#define NUM_SKILL_LEVELS (sizeof(skill_levels) / sizeof(SkillLevel))

// The various skill rankings. Zero skill is hardcoded to "Not" and '-'.

const SkillLevel skill_levels[] = {

{"Dabbling", 500, '0'},

{"Novice", 600, '1'},

{"Adequate", 700, '2'},

{"Competent", 800, '3'},

{"Skilled", 900, '4'},

{"Proficient", 1000, '5'},

{"Talented", 1100, '6'},

{"Adept", 1200, '7'},

{"Expert", 1300, '8'},

{"Professional",1400, '9'},

{"Accomplished",1500, 'A'},

{"Great", 1600, 'B'},

{"Master", 1700, 'C'},

{"High Master", 1800, 'D'},

{"Grand Master",1900, 'E'},

{"Legendary", 2000, 'U'},

{"Legendary+1", 2100, 'V'},

{"Legendary+2", 2200, 'W'},

{"Legendary+3", 2300, 'X'},

{"Legendary+4", 2400, 'Y'},

{"Legendary+5", 0, 'Z'}

};

struct SkillColumn

{

int group; // for navigation and mass toggling

int8_t color; // for column headers

df::profession profession; // to display graphical tiles

df::unit_labor labor; // toggled when pressing Enter

df::job_skill skill; // displayed rating

char label[3]; // column header

bool special; // specified labor is mutually exclusive with all other special labors

};

#define NUM_COLUMNS (sizeof(columns) / sizeof(SkillColumn))

// All of the skill/labor columns we want to display.

const SkillColumn columns[] = {

// Mining

{0, 7, profession::MINER, unit_labor::MINE, job_skill::MINING, "Mi", true},

// Woodworking

{1, 14, profession::CARPENTER, unit_labor::CARPENTER, job_skill::CARPENTRY, "Ca"},

{1, 14, profession::BOWYER, unit_labor::BOWYER, job_skill::BOWYER, "Bw"},

{1, 14, profession::WOODCUTTER, unit_labor::CUTWOOD, job_skill::WOODCUTTING, "WC", true},

// Stoneworking

{2, 15, profession::MASON, unit_labor::MASON, job_skill::MASONRY, "Ma"},

{2, 15, profession::ENGRAVER, unit_labor::DETAIL, job_skill::ENGRAVE_STONE, "En"},

// Hunting/Related

{3, 2, profession::ANIMAL_TRAINER, unit_labor::ANIMALTRAIN, job_skill::ANIMALTRAIN, "Tn"},

{3, 2, profession::ANIMAL_CARETAKER, unit_labor::ANIMALCARE, job_skill::ANIMALCARE, "Ca"},

{3, 2, profession::HUNTER, unit_labor::HUNT, job_skill::SNEAK, "Hu", true},

{3, 2, profession::TRAPPER, unit_labor::TRAPPER, job_skill::TRAPPING, "Tr"},

{3, 2, profession::ANIMAL_DISSECTOR, unit_labor::DISSECT_VERMIN, job_skill::DISSECT_VERMIN, "Di"},

// Healthcare

{4, 5, profession::DIAGNOSER, unit_labor::DIAGNOSE, job_skill::DIAGNOSE, "Di"},

{4, 5, profession::SURGEON, unit_labor::SURGERY, job_skill::SURGERY, "Su"},

{4, 5, profession::BONE_SETTER, unit_labor::BONE_SETTING, job_skill::SET_BONE, "Bo"},

{4, 5, profession::SUTURER, unit_labor::SUTURING, job_skill::SUTURE, "St"},

{4, 5, profession::DOCTOR, unit_labor::DRESSING_WOUNDS, job_skill::DRESS_WOUNDS, "Dr"},

{4, 5, profession::NONE, unit_labor::FEED_WATER_CIVILIANS, job_skill::NONE, "Fd"},

{4, 5, profession::NONE, unit_labor::RECOVER_WOUNDED, job_skill::NONE, "Re"},

// Farming/Related

{5, 6, profession::BUTCHER, unit_labor::BUTCHER, job_skill::BUTCHER, "Bu"},

{5, 6, profession::TANNER, unit_labor::TANNER, job_skill::TANNER, "Ta"},

{5, 6, profession::PLANTER, unit_labor::PLANT, job_skill::PLANT, "Gr"},

{5, 6, profession::DYER, unit_labor::DYER, job_skill::DYER, "Dy"},

{5, 6, profession::SOAP_MAKER, unit_labor::SOAP_MAKER, job_skill::SOAP_MAKING, "So"},

{5, 6, profession::WOOD_BURNER, unit_labor::BURN_WOOD, job_skill::WOOD_BURNING, "WB"},

{5, 6, profession::POTASH_MAKER, unit_labor::POTASH_MAKING, job_skill::POTASH_MAKING, "Po"},

{5, 6, profession::LYE_MAKER, unit_labor::LYE_MAKING, job_skill::LYE_MAKING, "Ly"},

{5, 6, profession::MILLER, unit_labor::MILLER, job_skill::MILLING, "Ml"},

{5, 6, profession::BREWER, unit_labor::BREWER, job_skill::BREWING, "Br"},

{5, 6, profession::HERBALIST, unit_labor::HERBALIST, job_skill::HERBALISM, "He"},

{5, 6, profession::THRESHER, unit_labor::PROCESS_PLANT, job_skill::PROCESSPLANTS, "Th"},

{5, 6, profession::CHEESE_MAKER, unit_labor::MAKE_CHEESE, job_skill::CHEESEMAKING, "Ch"},

{5, 6, profession::MILKER, unit_labor::MILK, job_skill::MILK, "Mk"},

{5, 6, profession::SHEARER, unit_labor::SHEARER, job_skill::SHEARING, "Sh"},

{5, 6, profession::SPINNER, unit_labor::SPINNER, job_skill::SPINNING, "Sp"},

{5, 6, profession::COOK, unit_labor::COOK, job_skill::COOK, "Co"},

{5, 6, profession::PRESSER, unit_labor::PRESSING, job_skill::PRESSING, "Pr"},

{5, 6, profession::BEEKEEPER, unit_labor::BEEKEEPING, job_skill::BEEKEEPING, "Be"},

{5, 6, profession::GELDER, unit_labor::GELD, job_skill::GELD, "Ge"},

// Fishing/Related

{6, 1, profession::FISHERMAN, unit_labor::FISH, job_skill::FISH, "Fi"},

{6, 1, profession::FISH_CLEANER, unit_labor::CLEAN_FISH, job_skill::PROCESSFISH, "Cl"},

{6, 1, profession::FISH_DISSECTOR, unit_labor::DISSECT_FISH, job_skill::DISSECT_FISH, "Di"},

// Metalsmithing

{7, 8, profession::FURNACE_OPERATOR, unit_labor::SMELT, job_skill::SMELT, "Fu"},

{7, 8, profession::WEAPONSMITH, unit_labor::FORGE_WEAPON, job_skill::FORGE_WEAPON, "We"},

{7, 8, profession::ARMORER, unit_labor::FORGE_ARMOR, job_skill::FORGE_ARMOR, "Ar"},

{7, 8, profession::BLACKSMITH, unit_labor::FORGE_FURNITURE, job_skill::FORGE_FURNITURE, "Bl"},

{7, 8, profession::METALCRAFTER, unit_labor::METAL_CRAFT, job_skill::METALCRAFT, "Cr"},

// Jewelry

{8, 10, profession::GEM_CUTTER, unit_labor::CUT_GEM, job_skill::CUTGEM, "Cu"},

{8, 10, profession::GEM_SETTER, unit_labor::ENCRUST_GEM, job_skill::ENCRUSTGEM, "Se"},

// Crafts

{9, 9, profession::LEATHERWORKER, unit_labor::LEATHER, job_skill::LEATHERWORK, "Le"},

{9, 9, profession::WOODCRAFTER, unit_labor::WOOD_CRAFT, job_skill::WOODCRAFT, "Wo"},

{9, 9, profession::STONECRAFTER, unit_labor::STONE_CRAFT, job_skill::STONECRAFT, "St"},

{9, 9, profession::BONE_CARVER, unit_labor::BONE_CARVE, job_skill::BONECARVE, "Bo"},

{9, 9, profession::GLASSMAKER, unit_labor::GLASSMAKER, job_skill::GLASSMAKER, "Gl"},

{9, 9, profession::WEAVER, unit_labor::WEAVER, job_skill::WEAVING, "We"},

{9, 9, profession::CLOTHIER, unit_labor::CLOTHESMAKER, job_skill::CLOTHESMAKING, "Cl"},

{9, 9, profession::STRAND_EXTRACTOR, unit_labor::EXTRACT_STRAND, job_skill::EXTRACT_STRAND, "Ad"},

{9, 9, profession::POTTER, unit_labor::POTTERY, job_skill::POTTERY, "Po"},

{9, 9, profession::GLAZER, unit_labor::GLAZING, job_skill::GLAZING, "Gl"},

{9, 9, profession::WAX_WORKER, unit_labor::WAX_WORKING, job_skill::WAX_WORKING, "Wx"},

{9, 9, profession::PAPERMAKER, unit_labor::PAPERMAKING, job_skill::PAPERMAKING, "Pa"},

{9, 9, profession::BOOKBINDER, unit_labor::BOOKBINDING, job_skill::BOOKBINDING, "Bk"},

// Engineering

{10, 12, profession::SIEGE_ENGINEER, unit_labor::SIEGECRAFT, job_skill::SIEGECRAFT, "En"},

{10, 12, profession::SIEGE_OPERATOR, unit_labor::SIEGEOPERATE, job_skill::SIEGEOPERATE, "Op"},

{10, 12, profession::MECHANIC, unit_labor::MECHANIC, job_skill::MECHANICS, "Me"},

{10, 12, profession::PUMP_OPERATOR, unit_labor::OPERATE_PUMP, job_skill::OPERATE_PUMP, "Pu"},

// Hauling

{11, 3, profession::NONE, unit_labor::HAUL_STONE, job_skill::NONE, "St"},

{11, 3, profession::NONE, unit_labor::HAUL_WOOD, job_skill::NONE, "Wo"},

{11, 3, profession::NONE, unit_labor::HAUL_ITEM, job_skill::NONE, "It"},

{11, 3, profession::NONE, unit_labor::HAUL_BODY, job_skill::NONE, "Bu"},

{11, 3, profession::NONE, unit_labor::HAUL_FOOD, job_skill::NONE, "Fo"},

{11, 3, profession::NONE, unit_labor::HAUL_REFUSE, job_skill::NONE, "Re"},

{11, 3, profession::NONE, unit_labor::HAUL_FURNITURE, job_skill::NONE, "Fu"},

{11, 3, profession::NONE, unit_labor::HAUL_ANIMALS, job_skill::NONE, "An"},

{11, 3, profession::NONE, unit_labor::HANDLE_VEHICLES, job_skill::NONE, "Ve"},

{11, 3, profession::NONE, unit_labor::HAUL_TRADE, job_skill::NONE, "Tr"},

{11, 3, profession::NONE, unit_labor::HAUL_WATER, job_skill::NONE, "Wa"},

// Other Jobs

{12, 4, profession::ARCHITECT, unit_labor::ARCHITECT, job_skill::DESIGNBUILDING, "Ar"},

{12, 4, profession::ALCHEMIST, unit_labor::ALCHEMIST, job_skill::ALCHEMY, "Al"},

{12, 4, profession::NONE, unit_labor::CLEAN, job_skill::NONE, "Cl"},

{12, 4, profession::NONE, unit_labor::PULL_LEVER, job_skill::NONE, "Lv"},

{12, 4, profession::NONE, unit_labor::BUILD_ROAD, job_skill::NONE, "Ro"},

{12, 4, profession::NONE, unit_labor::BUILD_CONSTRUCTION, job_skill::NONE, "Co"},

{12, 4, profession::NONE, unit_labor::UNUSED_13, job_skill::NONE, "CR"},

// Military - Weapons

{13, 7, profession::WRESTLER, unit_labor::NONE, job_skill::WRESTLING, "Wr"},

{13, 7, profession::AXEMAN, unit_labor::NONE, job_skill::AXE, "Ax"},

{13, 7, profession::SWORDSMAN, unit_labor::NONE, job_skill::SWORD, "Sw"},

{13, 7, profession::MACEMAN, unit_labor::NONE, job_skill::MACE, "Mc"},

{13, 7, profession::HAMMERMAN, unit_labor::NONE, job_skill::HAMMER, "Ha"},

{13, 7, profession::SPEARMAN, unit_labor::NONE, job_skill::SPEAR, "Sp"},

{13, 7, profession::CROSSBOWMAN, unit_labor::NONE, job_skill::CROSSBOW, "Cb"},

{13, 7, profession::THIEF, unit_labor::NONE, job_skill::DAGGER, "Kn"},

{13, 7, profession::BOWMAN, unit_labor::NONE, job_skill::BOW, "Bo"},

{13, 7, profession::BLOWGUNMAN, unit_labor::NONE, job_skill::BLOWGUN, "Bl"},

{13, 7, profession::PIKEMAN, unit_labor::NONE, job_skill::PIKE, "Pk"},

{13, 7, profession::LASHER, unit_labor::NONE, job_skill::WHIP, "La"},

// Military - Other Combat

{14, 15, profession::NONE, unit_labor::NONE, job_skill::BITE, "Bi"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::GRASP_STRIKE, "St"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::STANCE_STRIKE, "Ki"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::MISC_WEAPON, "Mi"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::MELEE_COMBAT, "Fg"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::RANGED_COMBAT, "Ac"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::ARMOR, "Ar"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::SHIELD, "Sh"},

{14, 15, profession::NONE, unit_labor::NONE, job_skill::DODGING, "Do"},

// Military - Misc

{15, 8, profession::NONE, unit_labor::NONE, job_skill::LEADERSHIP, "Ld"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::TEACHING, "Te"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::KNOWLEDGE_ACQUISITION, "St"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::DISCIPLINE, "Di"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::CONCENTRATION, "Co"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::SITUATIONAL_AWARENESS, "Ob"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::COORDINATION, "Cr"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::BALANCE, "Ba"},

{15, 8, profession::NONE, unit_labor::NONE, job_skill::CLIMBING, "Cl"},

// Social

{16, 3, profession::NONE, unit_labor::NONE, job_skill::PERSUASION, "Pe"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::NEGOTIATION, "Ne"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::JUDGING_INTENT, "Ju"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::LYING, "Li"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::INTIMIDATION, "In"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::CONVERSATION, "Cn"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::COMEDY, "Cm"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::FLATTERY, "Fl"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::CONSOLE, "Cs"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::PACIFY, "Pc"},

{16, 3, profession::NONE, unit_labor::NONE, job_skill::INTRIGUE, "Sc"},

// Noble

{17, 5, profession::TRADER, unit_labor::NONE, job_skill::APPRAISAL, "Ap"},

{17, 5, profession::ADMINISTRATOR, unit_labor::NONE, job_skill::ORGANIZATION, "Or"},

{17, 5, profession::CLERK, unit_labor::NONE, job_skill::RECORD_KEEPING, "RK"},

// Miscellaneous

{18, 3, profession::NONE, unit_labor::NONE, job_skill::THROW, "Th"},

{18, 3, profession::NONE, unit_labor::NONE, job_skill::CRUTCH_WALK, "CW"},

{18, 3, profession::NONE, unit_labor::NONE, job_skill::SWIMMING, "Sw"},

{18, 3, profession::NONE, unit_labor::NONE, job_skill::KNAPPING, "Kn"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::WRITING, "Wr"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::PROSE, "Pr"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::POETRY, "Po"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::READING, "Rd"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::SPEAKING, "Sp"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::DANCE, "Dn"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::MAKE_MUSIC, "MM"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::SING_MUSIC, "SM"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::PLAY_KEYBOARD_INSTRUMENT, "PK"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::PLAY_STRINGED_INSTRUMENT, "PS"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::PLAY_WIND_INSTRUMENT, "PW"},

{19, 6, profession::NONE, unit_labor::NONE, job_skill::PLAY_PERCUSSION_INSTRUMENT, "PP"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::CRITICAL_THINKING, "CT"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::LOGIC, "Lo"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::MATHEMATICS, "Ma"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::ASTRONOMY, "As"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::CHEMISTRY, "Ch"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::GEOGRAPHY, "Ge"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::OPTICS_ENGINEER, "OE"},

{20, 4, profession::NONE, unit_labor::NONE, job_skill::FLUID_ENGINEER, "FE"},

{21, 5, profession::NONE, unit_labor::NONE, job_skill::MILITARY_TACTICS, "MT"},

{21, 5, profession::NONE, unit_labor::NONE, job_skill::TRACKING, "Tr"},

{21, 5, profession::NONE, unit_labor::NONE, job_skill::MAGIC_NATURE, "Dr"},

};

struct UnitInfo

{

df::unit *unit;

bool allowEdit;

string name;

string transname;

string profession;

string goal;

df::pronoun_type goal_gender;

bool achieved_goal;

int8_t color;

int active_index;

string squad_effective_name;

string squad_info;

string job_desc;

enum { IDLE, SOCIAL, JOB } job_mode;

bool selected;

struct {

// Used for custom professions, 1-indexed

int list_id; // Position in list

int list_id_group; // Position in list by group (e.g. craftsdwarf)

int list_id_prof; // Position in list by profession (e.g. woodcrafter)

void init() {

list_id = 0;

list_id_group = 0;

list_id_prof = 0;

}

} ids;

};

enum detail_cols {

DETAIL_MODE_PROFESSION,

DETAIL_MODE_SQUAD,

DETAIL_MODE_JOB,

DETAIL_MODE_GOAL

};

enum altsort_mode {

ALTSORT_NAME,

ALTSORT_SELECTED,

ALTSORT_DETAIL,

ALTSORT_STRESS,

ALTSORT_ARRIVAL,

ALTSORT_MAX

};

string itos (int n)

{

stringstream ss;

ss << n;

return ss.str();

}

bool descending;

df::job_skill sort_skill;

df::unit_labor sort_labor;

bool sortByName (const UnitInfo *d1, const UnitInfo *d2)

{

if (descending)

return (d1->name > d2->name);

else

return (d1->name < d2->name);

}

bool sortByProfession (const UnitInfo *d1, const UnitInfo *d2)

{

if (descending)

return (d1->profession > d2->profession);

else

return (d1->profession < d2->profession);

}

bool sortByGoal (const UnitInfo *d1, const UnitInfo *d2)

{

if (!d1->unit->status.current_soul)

return !descending;

if (!d2->unit->status.current_soul)

return descending;

df::goal_type goal1 = Units::getGoalType(d1->unit);

df::goal_type goal2 = Units::getGoalType(d2->unit);

if (descending)

return (goal1 > goal2);

else

return (goal1 < goal2);

}

bool sortBySquad (const UnitInfo *d1, const UnitInfo *d2)

{

bool gt = false;

if (d1->unit->military.squad_id == -1 && d2->unit->military.squad_id == -1)

gt = d1->name > d2->name;

else if (d1->unit->military.squad_id == -1)

gt = true;

else if (d2->unit->military.squad_id == -1)

gt = false;

else if (d1->unit->military.squad_id != d2->unit->military.squad_id)

gt = d1->squad_effective_name > d2->squad_effective_name;

else

gt = d1->unit->military.squad_position > d2->unit->military.squad_position;

return descending ? gt : !gt;

}

bool sortByJob (const UnitInfo *d1, const UnitInfo *d2)

{

if (d1->job_mode != d2->job_mode)

{

if (descending)

return int(d1->job_mode) < int(d2->job_mode);

else

return int(d1->job_mode) > int(d2->job_mode);

}

if (descending)

return d1->job_desc > d2->job_desc;

else

return d1->job_desc < d2->job_desc;

}

bool sortByStress (const UnitInfo *d1, const UnitInfo *d2)

{

if (!d1->unit->status.current_soul)

return !descending;

if (!d2->unit->status.current_soul)

return descending;

if (descending)

return (d1->unit->status.current_soul->personality.stress_level > d2->unit->status.current_soul->personality.stress_level);

else

return (d1->unit->status.current_soul->personality.stress_level < d2->unit->status.current_soul->personality.stress_level);

}

bool sortByArrival (const UnitInfo *d1, const UnitInfo *d2)

{

if (descending)

return (d1->active_index > d2->active_index);

else

return (d1->active_index < d2->active_index);

}

bool sortBySkill (const UnitInfo *d1, const UnitInfo *d2)

{

if (sort_skill != job_skill::NONE)

{

if (!d1->unit->status.current_soul)

return !descending;

if (!d2->unit->status.current_soul)

return descending;

df::unit_skill *s1 = binsearch_in_vector<df::unit_skill,df::job_skill>(d1->unit->status.current_soul->skills, &df::unit_skill::id, sort_skill);

df::unit_skill *s2 = binsearch_in_vector<df::unit_skill,df::job_skill>(d2->unit->status.current_soul->skills, &df::unit_skill::id, sort_skill);

int l1 = s1 ? s1->rating : 0;

int l2 = s2 ? s2->rating : 0;

int e1 = s1 ? s1->experience : 0;

int e2 = s2 ? s2->experience : 0;

if (descending)

{

if (l1 != l2)

return l1 > l2;

if (e1 != e2)

return e1 > e2;

}

else

{

if (l1 != l2)

return l1 < l2;

if (e1 != e2)

return e1 < e2;

}

}

if (sort_labor != unit_labor::NONE)

{

if (descending)

return d1->unit->status.labors[sort_labor] > d2->unit->status.labors[sort_labor];

else

return d1->unit->status.labors[sort_labor] < d2->unit->status.labors[sort_labor];

}

return false;

}

bool sortBySelected (const UnitInfo *d1, const UnitInfo *d2)

{

return descending ? (d1->selected > d2->selected) : (d1->selected < d2->selected);

}

template<typename T>

class StringFormatter {

public:

typedef string(*T_callback)(T);

typedef std::tuple<string, string, T_callback> T_opt;

typedef vector<T_opt> T_optlist;

static bool compare_opts(const string &first, const string &second)

{

return first.size() > second.size();

}

StringFormatter() {}

void add_option(string spec, string help, string (*callback)(T))

{

opt_list.push_back(std::make_tuple(spec, help, callback));

}

T_optlist *get_options() { return &opt_list; }

void clear_options()

{

opt_list.clear();

}

string grab_opt (string s, size_t start)

{

vector<string> candidates;

for (auto it = opt_list.begin(); it != opt_list.end(); ++it)

{

string opt = std::get<0>(*it);

string slice = s.substr(start, opt.size());

if (slice == opt)

candidates.push_back(slice);

}

if (!candidates.size())

return "";

// Select the longest candidate

std::sort(candidates.begin(), candidates.end(), StringFormatter<T>::compare_opts);

return candidates[0];

}

T_callback get_callback (string s)

{

for (auto it = opt_list.begin(); it != opt_list.end(); ++it)

{

if (std::get<0>(*it) == s)

return std::get<2>(*it);

}

return NULL;

}

string format (T obj, string fmt)

{

string dest = "";

bool in_opt = false;

size_t i = 0;

while (i < fmt.size())

{

if (in_opt)

{

if (fmt[i] == '%')

{

// escape: %% -> %

in_opt = false;

dest.push_back('%');

i++;

}

else

{

string opt = grab_opt(fmt, i);

if (opt.size())

{

T_callback func = get_callback(opt);

if (func != NULL)

dest += func(obj);

i += opt.size();

in_opt = false;

if (i < fmt.size() && fmt[i] == '$')

// Allow $ to terminate format options

i++;

}

else

{

// Unrecognized format option; replace with original text

dest.push_back('%');

in_opt = false;

}

}

}

else

{

if (fmt[i] == '%')

in_opt = true;

else

dest.push_back(fmt[i]);

i++;

}

}

return dest;

}

protected:

T_optlist opt_list;

};

namespace unit_ops {

string get_real_name(UnitInfo *u)

{ return Translation::TranslateName(&u->unit->name, false); }

string get_nickname(UnitInfo *u)

{ return Translation::TranslateName(Units::getVisibleName(u->unit), false); }

string get_real_name_eng(UnitInfo *u)

{ return Translation::TranslateName(&u->unit->name, true); }

string get_nickname_eng(UnitInfo *u)

{ return Translation::TranslateName(Units::getVisibleName(u->unit), true); }

string get_first_nickname(UnitInfo *u)

{

return Translation::capitalize(u->unit->name.nickname.size() ?

u->unit->name.nickname : u->unit->name.first_name);

}

string get_first_name(UnitInfo *u)

{ return Translation::capitalize(u->unit->name.first_name); }

string get_last_name(UnitInfo *u)

{

df::language_name name = u->unit->name;

string ret = "";

for (int i = 0; i < 2; i++)

{

if (name.words[i] >= 0)

ret += *world->raws.language.translations[name.language]->words[name.words[i]];

}

return Translation::capitalize(ret);

}

string get_last_name_eng(UnitInfo *u)

{

df::language_name name = u->unit->name;

string ret = "";

for (int i = 0; i < 2; i++)

{

if (name.words[i] >= 0)

ret += world->raws.language.words[name.words[i]]->forms[name.parts_of_speech[i]];

}

return Translation::capitalize(ret);

}

string get_profname(UnitInfo *u)

{ return Units::getProfessionName(u->unit); }

string get_goalname(UnitInfo *u)

{ return Units::getGoalName(u->unit); }

string get_real_profname(UnitInfo *u)

{

string tmp = u->unit->custom_profession;

u->unit->custom_profession = "";

string ret = get_profname(u);

u->unit->custom_profession = tmp;

return ret;

}

string get_base_profname(UnitInfo *u)

{

return ENUM_ATTR_STR(profession, caption, u->unit->profession);

}

string get_short_profname(UnitInfo *u)

{

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (columns[i].profession == u->unit->profession)

return string(columns[i].label);

}

return "??";

}

#define id_getter(id) \

string get_##id(UnitInfo *u) \

{ return itos(u->ids.id); }

id_getter(list_id);

id_getter(list_id_prof);

id_getter(list_id_group);

#undef id_getter

string get_unit_id(UnitInfo *u)

{ return itos(u->unit->id); }

string get_age(UnitInfo *u)

{ return itos((int)Units::getAge(u->unit)); }

void set_nickname(UnitInfo *u, std::string nick)

{

Units::setNickname(u->unit, nick);

u->name = get_nickname(u);

u->transname = get_nickname_eng(u);

}

void set_profname(UnitInfo *u, std::string prof)

{

u->unit->custom_profession = prof;

u->profession = get_profname(u);

}

}

struct ProfessionTemplate

{

std::string name;

std::string displayName;

bool library;

bool mask;

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

bool load(string directory, string file, bool isLibrary)

{

cerr << "Attempt to load " << file << endl;

std::ifstream infile(directory + "/" + file);

if (infile.bad()) {

return false;

}

library = isLibrary;

std::string line;

name = file; // If no name is given we default to the filename

displayName = name;

mask = false;

while (std::getline(infile, line)) {

if (strcmp(line.substr(0,5).c_str(),"NAME ")==0)

{

auto nextInd = line.find(' ');

displayName = line.substr(nextInd + 1);

name = displayName;

size_t slashpos = name.find_first_of("\\/");

while (name.npos != slashpos) {

name = name.substr(slashpos + 1);

slashpos = name.find_first_of("\\/");

}

if (name == "")

name = file;

continue;

}

if (line == "MASK")

{

mask = true;

continue;

}

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (line == ENUM_KEY_STR(unit_labor, columns[i].labor))

{

labors.push_back(columns[i].labor);

}

}

}

return true;

}

bool save(string directory)

{

std::ofstream outfile(directory + "/" + name);

if (outfile.bad())

return false;

outfile << "NAME " << name << std::endl;

if (mask)

outfile << "MASK" << std::endl;

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (hasLabor(columns[i].labor))

{

outfile << ENUM_KEY_STR(unit_labor, columns[i].labor) << std::endl;

}

}

outfile.flush();

outfile.close();

return true;

}

void apply(UnitInfo* u)

{

if (!mask && name.size() > 0)

unit_ops::set_profname(u, name);

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

df::unit_labor labor = columns[i].labor;

bool status = hasLabor(labor);

if (!mask || status) {

u->unit->status.labors[labor] = status;

}

}

}

void fromUnit(UnitInfo* u)

{

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (u->unit->status.labors[columns[i].labor])

labors.push_back(columns[i].labor);

}

}

bool hasLabor (df::unit_labor labor)

{

return std::find(labors.begin(), labors.end(), labor) != labors.end();

}

};

static std::string professions_folder = "dfhack-config/professions";

static std::string professions_library_folder = "dfhack-config/professions/library";

class ProfessionTemplateManager

{

public:

std::vector<ProfessionTemplate> templates;

void reload() {

unload();

load();

}

void unload() {

templates.clear();

}

void load()

{

cerr << "Attempting to load professions: " << professions_folder.c_str() << endl;

if (!Filesystem::isdir(professions_folder) && !Filesystem::mkdir(professions_folder))

{

cerr << professions_folder << ": Does not exist and cannot be created" << endl;

return;

}

_load(professions_folder, false);

_load(professions_library_folder, true);

// sort alphabetically by display name, with user data above library data

std::sort(templates.begin(), templates.end(),

[](const ProfessionTemplate &a, const ProfessionTemplate &b) {

return (a.library == b.library && a.displayName < b.displayName)

|| (b.library && !a.library);

});

}

void save_from_unit(UnitInfo *unit)

{

ProfessionTemplate t = {

unit_ops::get_profname(unit)

};

t.fromUnit(unit);

t.save(professions_folder);

reload();

}

private:

void _load(const std::string &path, bool library) {

vector<string> files;

Filesystem::listdir(path, files);

for (auto &fname : files) {

if (Filesystem::isdir(path + "/" + fname))

continue;

ProfessionTemplate t;

if (t.load(path, fname, library)) {

templates.push_back(t);

}

}

}

};

static ProfessionTemplateManager manager;

class viewscreen_unitbatchopst : public dfhack_viewscreen {

public:

enum page { MENU, NICKNAME, PROFNAME };

viewscreen_unitbatchopst(vector<UnitInfo*> &base_units,

bool filter_selected = true,

bool *dirty_flag = NULL

)

:cur_page(MENU), entry(""), selection_empty(false), dirty(dirty_flag)

{

menu_options.multiselect = false;

menu_options.auto_select = true;

menu_options.allow_search = false;

menu_options.left_margin = 2;

menu_options.bottom_margin = 2;

menu_options.clear();

menu_options.add("Change nickname", page::NICKNAME);

menu_options.add("Change profession name", page::PROFNAME);

menu_options.filterDisplay();

formatter.add_option("n", "Displayed name (or nickname)", unit_ops::get_nickname);

formatter.add_option("N", "Real name", unit_ops::get_real_name);

formatter.add_option("en", "Displayed name (or nickname), in English", unit_ops::get_nickname_eng);

formatter.add_option("eN", "Real name, in English", unit_ops::get_real_name_eng);

formatter.add_option("fn", "Displayed first name (or nickname)", unit_ops::get_first_nickname);

formatter.add_option("fN", "Real first name", unit_ops::get_first_name);

formatter.add_option("ln", "Last name", unit_ops::get_last_name);

formatter.add_option("eln", "Last name, in English", unit_ops::get_last_name_eng);

formatter.add_option("p", "Displayed profession", unit_ops::get_profname);

formatter.add_option("P", "Real profession (non-customized)", unit_ops::get_real_profname);

formatter.add_option("bp", "Base profession (excluding nobles & other positions)", unit_ops::get_base_profname);

formatter.add_option("sp", "Short (base) profession name (from manipulator headers)", unit_ops::get_short_profname);

formatter.add_option("a", "Age (in years)", unit_ops::get_age);

formatter.add_option("i", "Position in list", unit_ops::get_list_id);

formatter.add_option("pi", "Position in list, among dwarves with same profession", unit_ops::get_list_id_prof);

formatter.add_option("gi", "Position in list, among dwarves in same profession group", unit_ops::get_list_id_group);

formatter.add_option("ri", "Raw unit ID", unit_ops::get_unit_id);

selection_empty = true;

for (auto it = base_units.begin(); it != base_units.end(); ++it)

{

UnitInfo* uinfo = *it;

if (uinfo->selected || !filter_selected)

{

selection_empty = false;

units.push_back(uinfo);

}

}

}

std::string getFocusString() { return "unitlabors/batch"; }

void select_page (page p)

{

if (p == NICKNAME || p == PROFNAME)

entry = "";

cur_page = p;

}

void apply(void (*func)(UnitInfo*, string), string arg, StringFormatter<UnitInfo*> *arg_formatter)

{

if (dirty)

*dirty = true;

for (auto it = units.begin(); it != units.end(); ++it)

{

UnitInfo* u = (*it);

if (!u || !u->unit || !u->allowEdit) continue;

string cur_arg = arg_formatter->format(u, arg);

func(u, cur_arg);

}

}

void feed(set<df::interface_key> *events)

{

if (cur_page == MENU)

{

if (events->count(interface_key::LEAVESCREEN))

{

Screen::dismiss(this);

return;

}

if (selection_empty)

return;

if (menu_options.feed(events))

{

// Allow left mouse button to trigger menu options

if (menu_options.feed_mouse_set_highlight)

events->insert(interface_key::SELECT);

else

return;

}

if (events->count(interface_key::SELECT))

select_page(menu_options.getFirstSelectedElem());

}

else if (cur_page == NICKNAME || cur_page == PROFNAME)

{

if (events->count(interface_key::LEAVESCREEN))

select_page(MENU);

else if (events->count(interface_key::SELECT))

{

apply((cur_page == NICKNAME) ? unit_ops::set_nickname : unit_ops::set_profname, entry, &formatter);

select_page(MENU);

}

else

{

for (auto it = events->begin(); it != events->end(); ++it)

{

int ch = Screen::keyToChar(*it);

if (ch == 0 && entry.size())

entry.resize(entry.size() - 1);

else if (ch > 0)

entry.push_back(char(ch));

}

}

}

}

void render()

{

dfhack_viewscreen::render();

Screen::clear();

int x = 2, y = 2;

if (cur_page == MENU)

{

Screen::drawBorder(" Dwarf Manipulator - Batch Operations ");

if (selection_empty)

{

OutputString(COLOR_LIGHTRED, x, y, "No dwarves selected!");

return;

}

menu_options.display(true);

}

OutputString(COLOR_LIGHTGREEN, x, y, itos(units.size()));

OutputString(COLOR_GREY, x, y, string(" ") + (units.size() > 1 ? "dwarves" : "dwarf") + " selected: ");

size_t max_x = gps->dimx - 2;

size_t i = 0;

for ( ; i < units.size(); i++)

{

string name = unit_ops::get_nickname(units[i]);

if (name.size() + x + 12 >= max_x) // 12 = "and xxx more"

break;

OutputString(COLOR_WHITE, x, y, name + ", ");

}

if (i == units.size())

{

x -= 2;

OutputString(COLOR_WHITE, x, y, " ");

}

else

{

OutputString(COLOR_GREY, x, y, "and " + itos(units.size() - i) + " more");

}

x = 2; y += 2;

if (cur_page == NICKNAME || cur_page == PROFNAME)

{

std::string name_type = (cur_page == page::NICKNAME) ? "Nickname" : "Profession name";

OutputString(COLOR_GREY, x, y, "Custom " + name_type + ":");

x = 2; y += 1;

OutputString(COLOR_WHITE, x, y, entry);

OutputString(COLOR_LIGHTGREEN, x, y, "_");

x = 2; y += 2;

OutputString(COLOR_DARKGREY, x, y, "(Leave blank to use original name)");

x = 2; y += 2;

OutputString(COLOR_WHITE, x, y, "Format options:");

StringFormatter<UnitInfo*>::T_optlist *format_options = formatter.get_options();

for (auto it = format_options->begin(); it != format_options->end(); ++it)

{

x = 2; y++;

auto opt = *it;

OutputString(COLOR_LIGHTCYAN, x, y, "%" + string(std::get<0>(opt)));

OutputString(COLOR_WHITE, x, y, ": " + string(std::get<1>(opt)));

}

}

}

protected:

ListColumn<page> menu_options;

page cur_page;

string entry;

vector<UnitInfo*> units;

StringFormatter<UnitInfo*> formatter;

bool selection_empty;

bool *dirty;

private:

void resize(int32_t x, int32_t y)

{

dfhack_viewscreen::resize(x, y);

menu_options.resize();

}