1518 lines
43 KiB
C++
1518 lines
43 KiB
C++
// This is a generic plugin that does nothing useful apart from acting as an example... of a plugin that does nothing :D
|
|
|
|
// some headers required for a plugin. Nothing special, just the basics.
|
|
#include "Core.h"
|
|
#include <Console.h>
|
|
#include <Export.h>
|
|
#include <PluginManager.h>
|
|
|
|
#include <vector>
|
|
#include <algorithm>
|
|
|
|
#include "modules/Units.h"
|
|
#include "modules/World.h"
|
|
|
|
// DF data structure definition headers
|
|
#include "DataDefs.h"
|
|
#include <df/ui.h>
|
|
#include <df/world.h>
|
|
#include <df/unit.h>
|
|
#include <df/unit_soul.h>
|
|
#include <df/unit_labor.h>
|
|
#include <df/unit_skill.h>
|
|
#include <df/job.h>
|
|
#include <df/building.h>
|
|
#include <df/workshop_type.h>
|
|
#include <df/unit_misc_trait.h>
|
|
#include <df/entity_position_responsibility.h>
|
|
#include <df/historical_figure.h>
|
|
#include <df/historical_entity.h>
|
|
#include <df/histfig_entity_link.h>
|
|
#include <df/histfig_entity_link_positionst.h>
|
|
#include <df/entity_position_assignment.h>
|
|
#include <df/entity_position.h>
|
|
#include <df/building_tradedepotst.h>
|
|
#include <df/building_stockpilest.h>
|
|
#include <df/items_other_id.h>
|
|
#include <df/ui.h>
|
|
#include <df/activity_info.h>
|
|
#include <df/tile_dig_designation.h>
|
|
#include <df/item_weaponst.h>
|
|
#include <df/itemdef_weaponst.h>
|
|
#include <df/general_ref_unit_workerst.h>
|
|
#include <df/general_ref_building_holderst.h>
|
|
#include <df/building_workshopst.h>
|
|
#include <df/reaction.h>
|
|
|
|
|
|
#include <MiscUtils.h>
|
|
|
|
#include "modules/MapCache.h"
|
|
#include "modules/Items.h"
|
|
|
|
using std::string;
|
|
using std::endl;
|
|
using namespace DFHack;
|
|
using namespace df::enums;
|
|
using df::global::ui;
|
|
using df::global::world;
|
|
|
|
#define ARRAY_COUNT(array) (sizeof(array)/sizeof((array)[0]))
|
|
|
|
/*
|
|
* Autolabor module for dfhack
|
|
*
|
|
* The idea behind this module is to constantly adjust labors so that the right dwarves
|
|
* are assigned to new tasks. The key is that, for almost all labors, once a dwarf begins
|
|
* a job it will finish that job even if the associated labor is removed. Thus the
|
|
* strategy is to frequently decide, for each labor, which dwarves should possibly take
|
|
* a new job for that labor if it comes in and which shouldn't, and then set the labors
|
|
* appropriately. The updating should happen as often as can be reasonably done without
|
|
* causing lag.
|
|
*
|
|
* The obvious thing to do is to just set each labor on a single idle dwarf who is best
|
|
* suited to doing new jobs of that labor. This works in a way, but it leads to a lot
|
|
* of idle dwarves since only one dwarf will be dispatched for each labor in an update
|
|
* cycle, and dwarves that finish tasks will wait for the next update before being
|
|
* dispatched. An improvement is to also set some labors on dwarves that are currently
|
|
* doing a job, so that they will immediately take a new job when they finish. The
|
|
* details of which dwarves should have labors set is mostly a heuristic.
|
|
*
|
|
* A complication to the above simple scheme is labors that have associated equipment.
|
|
* Enabling/disabling these labors causes dwarves to change equipment, and disabling
|
|
* them in the middle of a job may cause the job to be abandoned. Those labors
|
|
* (mining, hunting, and woodcutting) need to be handled carefully to minimize churn.
|
|
*/
|
|
|
|
static int enable_autolabor = 0;
|
|
|
|
static bool print_debug = 0;
|
|
|
|
static std::vector<int> state_count(5);
|
|
|
|
static PersistentDataItem config;
|
|
|
|
enum ConfigFlags {
|
|
CF_ENABLED = 1,
|
|
};
|
|
|
|
|
|
// Here go all the command declarations...
|
|
// mostly to allow having the mandatory stuff on top of the file and commands on the bottom
|
|
command_result autolabor (color_ostream &out, std::vector <std::string> & parameters);
|
|
|
|
// A plugin must be able to return its name and version.
|
|
// The name string provided must correspond to the filename - autolabor.plug.so or autolabor.plug.dll in this case
|
|
DFHACK_PLUGIN("autolabor");
|
|
|
|
static void generate_labor_to_skill_map();
|
|
|
|
enum labor_mode {
|
|
DISABLE,
|
|
HAULERS,
|
|
AUTOMATIC,
|
|
};
|
|
|
|
enum dwarf_state {
|
|
// 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
|
|
};
|
|
|
|
const int NUM_STATE = 5;
|
|
|
|
static const char *state_names[] = {
|
|
"IDLE",
|
|
"BUSY",
|
|
"MILITARY",
|
|
"CHILD",
|
|
"OTHER",
|
|
};
|
|
|
|
static const dwarf_state dwarf_states[] = {
|
|
BUSY /* CarveFortification */,
|
|
BUSY /* DetailWall */,
|
|
BUSY /* DetailFloor */,
|
|
BUSY /* Dig */,
|
|
BUSY /* CarveUpwardStaircase */,
|
|
BUSY /* CarveDownwardStaircase */,
|
|
BUSY /* CarveUpDownStaircase */,
|
|
BUSY /* CarveRamp */,
|
|
BUSY /* DigChannel */,
|
|
BUSY /* FellTree */,
|
|
BUSY /* GatherPlants */,
|
|
BUSY /* RemoveConstruction */,
|
|
BUSY /* CollectWebs */,
|
|
BUSY /* BringItemToDepot */,
|
|
BUSY /* BringItemToShop */,
|
|
OTHER /* Eat */,
|
|
OTHER /* GetProvisions */,
|
|
OTHER /* Drink */,
|
|
OTHER /* Drink2 */,
|
|
OTHER /* FillWaterskin */,
|
|
OTHER /* FillWaterskin2 */,
|
|
OTHER /* Sleep */,
|
|
BUSY /* CollectSand */,
|
|
BUSY /* Fish */,
|
|
BUSY /* Hunt */,
|
|
OTHER /* HuntVermin */,
|
|
BUSY /* Kidnap */,
|
|
BUSY /* BeatCriminal */,
|
|
BUSY /* StartingFistFight */,
|
|
BUSY /* CollectTaxes */,
|
|
BUSY /* GuardTaxCollector */,
|
|
BUSY /* CatchLiveLandAnimal */,
|
|
BUSY /* CatchLiveFish */,
|
|
BUSY /* ReturnKill */,
|
|
BUSY /* CheckChest */,
|
|
BUSY /* StoreOwnedItem */,
|
|
BUSY /* PlaceItemInTomb */,
|
|
BUSY /* StoreItemInStockpile */,
|
|
BUSY /* StoreItemInBag */,
|
|
BUSY /* StoreItemInHospital */,
|
|
BUSY /* StoreItemInChest */,
|
|
BUSY /* StoreItemInCabinet */,
|
|
BUSY /* StoreWeapon */,
|
|
BUSY /* StoreArmor */,
|
|
BUSY /* StoreItemInBarrel */,
|
|
BUSY /* StoreItemInBin */,
|
|
BUSY /* SeekArtifact */,
|
|
BUSY /* SeekInfant */,
|
|
OTHER /* AttendParty */,
|
|
OTHER /* GoShopping */,
|
|
OTHER /* GoShopping2 */,
|
|
BUSY /* Clean */,
|
|
OTHER /* Rest */,
|
|
BUSY /* PickupEquipment */,
|
|
BUSY /* DumpItem */,
|
|
OTHER /* StrangeMoodCrafter */,
|
|
OTHER /* StrangeMoodJeweller */,
|
|
OTHER /* StrangeMoodForge */,
|
|
OTHER /* StrangeMoodMagmaForge */,
|
|
OTHER /* StrangeMoodBrooding */,
|
|
OTHER /* StrangeMoodFell */,
|
|
OTHER /* StrangeMoodCarpenter */,
|
|
OTHER /* StrangeMoodMason */,
|
|
OTHER /* StrangeMoodBowyer */,
|
|
OTHER /* StrangeMoodTanner */,
|
|
OTHER /* StrangeMoodWeaver */,
|
|
OTHER /* StrangeMoodGlassmaker */,
|
|
OTHER /* StrangeMoodMechanics */,
|
|
BUSY /* ConstructBuilding */,
|
|
BUSY /* ConstructDoor */,
|
|
BUSY /* ConstructFloodgate */,
|
|
BUSY /* ConstructBed */,
|
|
BUSY /* ConstructThrone */,
|
|
BUSY /* ConstructCoffin */,
|
|
BUSY /* ConstructTable */,
|
|
BUSY /* ConstructChest */,
|
|
BUSY /* ConstructBin */,
|
|
BUSY /* ConstructArmorStand */,
|
|
BUSY /* ConstructWeaponRack */,
|
|
BUSY /* ConstructCabinet */,
|
|
BUSY /* ConstructStatue */,
|
|
BUSY /* ConstructBlocks */,
|
|
BUSY /* MakeRawGlass */,
|
|
BUSY /* MakeCrafts */,
|
|
BUSY /* MintCoins */,
|
|
BUSY /* CutGems */,
|
|
BUSY /* CutGlass */,
|
|
BUSY /* EncrustWithGems */,
|
|
BUSY /* EncrustWithGlass */,
|
|
BUSY /* DestroyBuilding */,
|
|
BUSY /* SmeltOre */,
|
|
BUSY /* MeltMetalObject */,
|
|
BUSY /* ExtractMetalStrands */,
|
|
BUSY /* PlantSeeds */,
|
|
BUSY /* HarvestPlants */,
|
|
BUSY /* TrainHuntingAnimal */,
|
|
BUSY /* TrainWarAnimal */,
|
|
BUSY /* MakeWeapon */,
|
|
BUSY /* ForgeAnvil */,
|
|
BUSY /* ConstructCatapultParts */,
|
|
BUSY /* ConstructBallistaParts */,
|
|
BUSY /* MakeArmor */,
|
|
BUSY /* MakeHelm */,
|
|
BUSY /* MakePants */,
|
|
BUSY /* StudWith */,
|
|
BUSY /* ButcherAnimal */,
|
|
BUSY /* PrepareRawFish */,
|
|
BUSY /* MillPlants */,
|
|
BUSY /* BaitTrap */,
|
|
BUSY /* MilkCreature */,
|
|
BUSY /* MakeCheese */,
|
|
BUSY /* ProcessPlants */,
|
|
BUSY /* ProcessPlantsBag */,
|
|
BUSY /* ProcessPlantsVial */,
|
|
BUSY /* ProcessPlantsBarrel */,
|
|
BUSY /* PrepareMeal */,
|
|
BUSY /* WeaveCloth */,
|
|
BUSY /* MakeGloves */,
|
|
BUSY /* MakeShoes */,
|
|
BUSY /* MakeShield */,
|
|
BUSY /* MakeCage */,
|
|
BUSY /* MakeChain */,
|
|
BUSY /* MakeFlask */,
|
|
BUSY /* MakeGoblet */,
|
|
BUSY /* MakeInstrument */,
|
|
BUSY /* MakeToy */,
|
|
BUSY /* MakeAnimalTrap */,
|
|
BUSY /* MakeBarrel */,
|
|
BUSY /* MakeBucket */,
|
|
BUSY /* MakeWindow */,
|
|
BUSY /* MakeTotem */,
|
|
BUSY /* MakeAmmo */,
|
|
BUSY /* DecorateWith */,
|
|
BUSY /* MakeBackpack */,
|
|
BUSY /* MakeQuiver */,
|
|
BUSY /* MakeBallistaArrowHead */,
|
|
BUSY /* AssembleSiegeAmmo */,
|
|
BUSY /* LoadCatapult */,
|
|
BUSY /* LoadBallista */,
|
|
BUSY /* FireCatapult */,
|
|
BUSY /* FireBallista */,
|
|
BUSY /* ConstructMechanisms */,
|
|
BUSY /* MakeTrapComponent */,
|
|
BUSY /* LoadCageTrap */,
|
|
BUSY /* LoadStoneTrap */,
|
|
BUSY /* LoadWeaponTrap */,
|
|
BUSY /* CleanTrap */,
|
|
BUSY /* CastSpell */,
|
|
BUSY /* LinkBuildingToTrigger */,
|
|
BUSY /* PullLever */,
|
|
BUSY /* BrewDrink */,
|
|
BUSY /* ExtractFromPlants */,
|
|
BUSY /* ExtractFromRawFish */,
|
|
BUSY /* ExtractFromLandAnimal */,
|
|
BUSY /* TameVermin */,
|
|
BUSY /* TameAnimal */,
|
|
BUSY /* ChainAnimal */,
|
|
BUSY /* UnchainAnimal */,
|
|
BUSY /* UnchainPet */,
|
|
BUSY /* ReleaseLargeCreature */,
|
|
BUSY /* ReleasePet */,
|
|
BUSY /* ReleaseSmallCreature */,
|
|
BUSY /* HandleSmallCreature */,
|
|
BUSY /* HandleLargeCreature */,
|
|
BUSY /* CageLargeCreature */,
|
|
BUSY /* CageSmallCreature */,
|
|
BUSY /* RecoverWounded */,
|
|
BUSY /* DiagnosePatient */,
|
|
BUSY /* ImmobilizeBreak */,
|
|
BUSY /* DressWound */,
|
|
BUSY /* CleanPatient */,
|
|
BUSY /* Surgery */,
|
|
BUSY /* Suture */,
|
|
BUSY /* SetBone */,
|
|
BUSY /* PlaceInTraction */,
|
|
BUSY /* DrainAquarium */,
|
|
BUSY /* FillAquarium */,
|
|
BUSY /* FillPond */,
|
|
BUSY /* GiveWater */,
|
|
BUSY /* GiveFood */,
|
|
BUSY /* GiveWater2 */,
|
|
BUSY /* GiveFood2 */,
|
|
BUSY /* RecoverPet */,
|
|
BUSY /* PitLargeAnimal */,
|
|
BUSY /* PitSmallAnimal */,
|
|
BUSY /* SlaughterAnimal */,
|
|
BUSY /* MakeCharcoal */,
|
|
BUSY /* MakeAsh */,
|
|
BUSY /* MakeLye */,
|
|
BUSY /* MakePotashFromLye */,
|
|
BUSY /* FertilizeField */,
|
|
BUSY /* MakePotashFromAsh */,
|
|
BUSY /* DyeThread */,
|
|
BUSY /* DyeCloth */,
|
|
BUSY /* SewImage */,
|
|
BUSY /* MakePipeSection */,
|
|
BUSY /* OperatePump */,
|
|
OTHER /* ManageWorkOrders */,
|
|
OTHER /* UpdateStockpileRecords */,
|
|
OTHER /* TradeAtDepot */,
|
|
BUSY /* ConstructHatchCover */,
|
|
BUSY /* ConstructGrate */,
|
|
BUSY /* RemoveStairs */,
|
|
BUSY /* ConstructQuern */,
|
|
BUSY /* ConstructMillstone */,
|
|
BUSY /* ConstructSplint */,
|
|
BUSY /* ConstructCrutch */,
|
|
BUSY /* ConstructTractionBench */,
|
|
BUSY /* CleanSelf */,
|
|
BUSY /* BringCrutch */,
|
|
BUSY /* ApplyCast */,
|
|
BUSY /* CustomReaction */,
|
|
BUSY /* ConstructSlab */,
|
|
BUSY /* EngraveSlab */,
|
|
BUSY /* ShearCreature */,
|
|
BUSY /* SpinThread */,
|
|
BUSY /* PenLargeAnimal */,
|
|
BUSY /* PenSmallAnimal */,
|
|
BUSY /* MakeTool */,
|
|
BUSY /* CollectClay */,
|
|
BUSY /* InstallColonyInHive */,
|
|
BUSY /* CollectHiveProducts */,
|
|
OTHER /* CauseTrouble */,
|
|
OTHER /* DrinkBlood */,
|
|
OTHER /* ReportCrime */,
|
|
OTHER /* ExecuteCriminal */,
|
|
BUSY /* TrainAnimal */,
|
|
BUSY /* CarveTrack */,
|
|
BUSY /* PushTrackVehicle */,
|
|
BUSY /* PlaceTrackVehicle */,
|
|
BUSY /* StoreItemInVehicle */
|
|
};
|
|
|
|
struct labor_info
|
|
{
|
|
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; }
|
|
|
|
};
|
|
|
|
struct labor_default
|
|
{
|
|
labor_mode mode;
|
|
bool is_exclusive;
|
|
int minimum_dwarfs;
|
|
int maximum_dwarfs;
|
|
int active_dwarfs;
|
|
};
|
|
|
|
static int hauler_pct = 33;
|
|
|
|
static std::vector<struct labor_info> labor_infos;
|
|
|
|
static const struct labor_default default_labor_infos[] = {
|
|
/* MINE */ {AUTOMATIC, true, 2, 200, 0},
|
|
/* HAUL_STONE */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_WOOD */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_BODY */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_FOOD */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_REFUSE */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_ITEM */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_FURNITURE */ {HAULERS, false, 1, 200, 0},
|
|
/* HAUL_ANIMAL */ {HAULERS, false, 1, 200, 0},
|
|
/* CLEAN */ {HAULERS, false, 1, 200, 0},
|
|
/* CUTWOOD */ {AUTOMATIC, true, 1, 200, 0},
|
|
/* CARPENTER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DETAIL */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* MASON */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* ARCHITECT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* ANIMALTRAIN */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* ANIMALCARE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DIAGNOSE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SURGERY */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BONE_SETTING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SUTURING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DRESSING_WOUNDS */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* FEED_WATER_CIVILIANS */ {AUTOMATIC, false, 200, 200, 0},
|
|
/* RECOVER_WOUNDED */ {HAULERS, false, 1, 200, 0},
|
|
/* BUTCHER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* TRAPPER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DISSECT_VERMIN */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* LEATHER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* TANNER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BREWER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* ALCHEMIST */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SOAP_MAKER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* WEAVER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* CLOTHESMAKER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* MILLER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* PROCESS_PLANT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* MAKE_CHEESE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* MILK */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* COOK */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* PLANT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* HERBALIST */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* FISH */ {AUTOMATIC, false, 1, 1, 0},
|
|
/* CLEAN_FISH */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DISSECT_FISH */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* HUNT */ {AUTOMATIC, true, 1, 1, 0},
|
|
/* SMELT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* FORGE_WEAPON */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* FORGE_ARMOR */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* FORGE_FURNITURE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* METAL_CRAFT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* CUT_GEM */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* ENCRUST_GEM */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* WOOD_CRAFT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* STONE_CRAFT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BONE_CARVE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* GLASSMAKER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* EXTRACT_STRAND */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SIEGECRAFT */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SIEGEOPERATE */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BOWYER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* MECHANIC */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* POTASH_MAKING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* LYE_MAKING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* DYER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BURN_WOOD */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* OPERATE_PUMP */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SHEARER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* SPINNER */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* POTTERY */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* GLAZING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* PRESSING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* BEEKEEPING */ {AUTOMATIC, false, 1, 1, 0}, // reduce risk of stuck beekeepers (see http://www.bay12games.com/dwarves/mantisbt/view.php?id=3981)
|
|
/* WAX_WORKING */ {AUTOMATIC, false, 1, 200, 0},
|
|
/* PUSH_HAUL_VEHICLES */ {HAULERS, false, 1, 200, 0}
|
|
};
|
|
|
|
static const int responsibility_penalties[] = {
|
|
0, /* LAW_MAKING */
|
|
0, /* LAW_ENFORCEMENT */
|
|
3000, /* RECEIVE_DIPLOMATS */
|
|
0, /* MEET_WORKERS */
|
|
1000, /* MANAGE_PRODUCTION */
|
|
3000, /* TRADE */
|
|
1000, /* ACCOUNTING */
|
|
0, /* ESTABLISH_COLONY_TRADE_AGREEMENTS */
|
|
0, /* MAKE_INTRODUCTIONS */
|
|
0, /* MAKE_PEACE_AGREEMENTS */
|
|
0, /* MAKE_TOPIC_AGREEMENTS */
|
|
0, /* COLLECT_TAXES */
|
|
0, /* ESCORT_TAX_COLLECTOR */
|
|
0, /* EXECUTIONS */
|
|
0, /* TAME_EXOTICS */
|
|
0, /* RELIGION */
|
|
0, /* ATTACK_ENEMIES */
|
|
0, /* PATROL_TERRITORY */
|
|
0, /* MILITARY_GOALS */
|
|
0, /* MILITARY_STRATEGY */
|
|
0, /* UPGRADE_SQUAD_EQUIPMENT */
|
|
0, /* EQUIPMENT_MANIFESTS */
|
|
0, /* SORT_AMMUNITION */
|
|
0, /* BUILD_MORALE */
|
|
5000 /* HEALTH_MANAGEMENT */
|
|
};
|
|
|
|
struct dwarf_info_t
|
|
{
|
|
df::unit* dwarf;
|
|
dwarf_state state;
|
|
|
|
bool clear_all;
|
|
|
|
bool has_axe;
|
|
bool has_pick;
|
|
bool has_crossbow;
|
|
|
|
dwarf_info_t(df::unit* dw) : dwarf(dw), clear_all(0), has_axe(0), has_pick(0), has_crossbow(0), state(OTHER) {}
|
|
|
|
void set_labor(df::unit_labor labor)
|
|
{
|
|
dwarf->status.labors[labor] = true;
|
|
if ((labor == df::unit_labor::MINE && !has_pick) ||
|
|
(labor == df::unit_labor::CUTWOOD && !has_axe) ||
|
|
(labor == df::unit_labor::HUNT && !has_crossbow))
|
|
dwarf->military.pickup_flags.bits.update = 1;
|
|
}
|
|
};
|
|
|
|
static bool isOptionEnabled(unsigned flag)
|
|
{
|
|
return config.isValid() && (config.ival(0) & flag) != 0;
|
|
}
|
|
|
|
static void setOptionEnabled(ConfigFlags flag, bool on)
|
|
{
|
|
if (!config.isValid())
|
|
return;
|
|
|
|
if (on)
|
|
config.ival(0) |= flag;
|
|
else
|
|
config.ival(0) &= ~flag;
|
|
}
|
|
|
|
static void cleanup_state()
|
|
{
|
|
labor_infos.clear();
|
|
}
|
|
|
|
static void reset_labor(df::unit_labor labor)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static void init_state()
|
|
{
|
|
auto pworld = Core::getInstance().getWorld();
|
|
|
|
config = pworld->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 = pworld->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;
|
|
pworld->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 = pworld->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();
|
|
|
|
}
|
|
|
|
static df::job_skill labor_to_skill[ENUM_LAST_ITEM(unit_labor) + 1];
|
|
|
|
static void 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)
|
|
{
|
|
/*
|
|
assert(labor >= 0);
|
|
assert(labor < ARRAY_COUNT(labor_to_skill));
|
|
*/
|
|
|
|
labor_to_skill[labor] = skill;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void enable_plugin(color_ostream &out)
|
|
{
|
|
auto pworld = Core::getInstance().getWorld();
|
|
|
|
if (!config.isValid())
|
|
{
|
|
config = pworld->AddPersistentData("autolabor/config");
|
|
config.ival(0) = 0;
|
|
}
|
|
|
|
setOptionEnabled(CF_ENABLED, true);
|
|
enable_autolabor = true;
|
|
out << "Enabling the plugin." << endl;
|
|
|
|
cleanup_state();
|
|
init_state();
|
|
}
|
|
|
|
DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
|
|
{
|
|
// 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"
|
|
"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;
|
|
}
|
|
|
|
DFhackCExport command_result plugin_shutdown ( color_ostream &out )
|
|
{
|
|
cleanup_state();
|
|
|
|
return CR_OK;
|
|
}
|
|
|
|
|
|
static df::building* get_building_from_job(df::job* j)
|
|
{
|
|
for (auto r = j->references.begin(); r != j->references.end(); r++)
|
|
{
|
|
if ((*r)->getType() == df::general_ref_type::BUILDING_HOLDER)
|
|
{
|
|
int32_t id = ((df::general_ref_building_holderst*)(*r))->building_id;
|
|
df::building* bld = binsearch_in_vector(world->buildings.all, id);
|
|
return bld;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static df::job_skill workshop_build_labor[] =
|
|
{
|
|
/* Carpenters */ df::job_skill::CARPENTRY,
|
|
/* Farmers */ df::job_skill::PROCESSPLANTS,
|
|
/* Masons */ df::job_skill::MASONRY,
|
|
/* Craftsdwarfs */ df::job_skill::STONECRAFT,
|
|
/* Jewelers */ df::job_skill::CUTGEM,
|
|
/* MetalsmithsForge */ df::job_skill::METALCRAFT,
|
|
/* MagmaForge */ df::job_skill::METALCRAFT,
|
|
/* Bowyers */ df::job_skill::BOWYER,
|
|
/* Mechanics */ df::job_skill::MECHANICS,
|
|
/* Siege */ df::job_skill::SIEGECRAFT,
|
|
/* Butchers */ df::job_skill::BUTCHER,
|
|
/* Leatherworks */ df::job_skill::LEATHERWORK,
|
|
/* Tanners */ df::job_skill::TANNER,
|
|
/* Clothiers */ df::job_skill::CLOTHESMAKING,
|
|
/* Fishery */ df::job_skill::FISH,
|
|
/* Still */ df::job_skill::BREWING,
|
|
/* Loom */ df::job_skill::WEAVING,
|
|
/* Quern */ df::job_skill::MILLING,
|
|
/* Kennels */ df::job_skill::ANIMALTRAIN,
|
|
/* Kitchen */ df::job_skill::COOK,
|
|
/* Ashery */ df::job_skill::LYE_MAKING,
|
|
/* Dyers */ df::job_skill::DYER,
|
|
/* Millstone */ df::job_skill::MILLING,
|
|
/* Custom */ (df::job_skill) -1,
|
|
/* Tool */ (df::job_skill) -1
|
|
};
|
|
|
|
static void find_job_skill_labor(df::job* j, df::job_skill &skill, df::unit_labor &labor)
|
|
{
|
|
|
|
switch (j->job_type)
|
|
{
|
|
case df::job_type::ConstructBuilding:
|
|
{
|
|
df::building* bld = get_building_from_job (j);
|
|
switch (bld->getType())
|
|
{
|
|
case df::building_type::Workshop:
|
|
df::building_workshopst* ws = (df::building_workshopst*) bld;
|
|
skill = workshop_build_labor[ws->type];
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case df::job_type::CustomReaction:
|
|
for (auto r = world->raws.reactions.begin(); r != world->raws.reactions.end(); r++)
|
|
{
|
|
if ((*r)->code == j->reaction_name)
|
|
{
|
|
skill = (*r)->skill;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
skill = ENUM_ATTR(job_type, skill, j->job_type);
|
|
}
|
|
|
|
if (skill != df::job_skill::NONE)
|
|
labor = ENUM_ATTR(job_skill, labor, skill);
|
|
|
|
if (labor == df::unit_labor::NONE)
|
|
labor = ENUM_ATTR(job_type, labor, j->job_type);
|
|
|
|
if (labor == -1)
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
class AutoLaborManager {
|
|
color_ostream& out;
|
|
|
|
public:
|
|
AutoLaborManager(color_ostream& o) : out(o)
|
|
{
|
|
}
|
|
|
|
~AutoLaborManager()
|
|
{
|
|
for (std::vector<dwarf_info_t*>::iterator i = dwarf_info.begin();
|
|
i != dwarf_info.end(); i++)
|
|
delete (*i);
|
|
}
|
|
|
|
dwarf_info_t* add_dwarf(df::unit* u)
|
|
{
|
|
dwarf_info_t* dwarf = new dwarf_info_t(u);
|
|
dwarf_info.push_back(dwarf);
|
|
return dwarf;
|
|
}
|
|
|
|
|
|
private:
|
|
bool has_butchers;
|
|
bool has_fishery;
|
|
bool trader_requested;
|
|
|
|
int dig_count;
|
|
int tree_count;
|
|
int plant_count;
|
|
int detail_count;
|
|
int pick_count;
|
|
int axe_count;
|
|
|
|
std::vector<df::job*> jobs;
|
|
std::vector<dwarf_info_t*> dwarf_info;
|
|
std::deque<dwarf_info_t*> idle_dwarfs;
|
|
|
|
private:
|
|
void scan_buildings()
|
|
{
|
|
for (auto b = world->buildings.all.begin(); b != world->buildings.all.end(); b++)
|
|
{
|
|
df::building *build = *b;
|
|
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 = 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");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void count_map_designations()
|
|
{
|
|
dig_count = 0;
|
|
tree_count = 0;
|
|
plant_count = 0;
|
|
detail_count = 0;
|
|
|
|
for (int i = 0; i < world->map.map_blocks.size(); ++i)
|
|
{
|
|
df::map_block* bl = world->map.map_blocks[i];
|
|
|
|
if (!bl->flags.bits.designated)
|
|
continue;
|
|
|
|
if (print_debug)
|
|
out.print ("block with designations found: %d, %d, %d\n", bl->map_pos.x, bl->map_pos.y, bl->map_pos.z);
|
|
|
|
for (int x = 0; x < 16; x++)
|
|
for (int y = 0; y < 16; y++)
|
|
{
|
|
df::tile_dig_designation dig = bl->designation[x][y].bits.dig;
|
|
if (dig != df::enums::tile_dig_designation::No)
|
|
{
|
|
df::tiletype tt = bl->tiletype[x][y];
|
|
df::tiletype_shape tts = ENUM_ATTR(tiletype, shape, tt);
|
|
switch (tts)
|
|
{
|
|
case df::enums::tiletype_shape::TREE:
|
|
tree_count++; break;
|
|
case df::enums::tiletype_shape::SHRUB:
|
|
plant_count++; break;
|
|
default:
|
|
dig_count++; break;
|
|
}
|
|
}
|
|
if (bl->designation[x][y].bits.smooth != 0)
|
|
detail_count++;
|
|
}
|
|
}
|
|
|
|
if (print_debug)
|
|
out.print("Dig count = %d, Cut tree count = %d, gather plant count = %d, detail count = %d\n", dig_count, tree_count, plant_count, detail_count);
|
|
|
|
}
|
|
|
|
void count_tools()
|
|
{
|
|
pick_count = 0;
|
|
axe_count = 0;
|
|
|
|
df::item_flags bad_flags;
|
|
bad_flags.whole = 0;
|
|
|
|
#define F(x) bad_flags.bits.x = true;
|
|
F(dump); F(forbid); F(garbage_collect);
|
|
F(hostile); F(on_fire); F(rotten); F(trader);
|
|
F(in_building); F(construction); F(artifact1);
|
|
#undef F
|
|
|
|
for (int i = 0; i < world->items.all.size(); ++i)
|
|
{
|
|
df::item* item = world->items.all[i];
|
|
if (item->flags.whole & bad_flags.whole)
|
|
continue;
|
|
|
|
if (!item->isWeapon())
|
|
continue;
|
|
|
|
df::itemdef_weaponst* weapondef = ((df::item_weaponst*)item)->subtype;
|
|
df::job_skill weaponsk = (df::job_skill) weapondef->skill_melee;
|
|
if (weaponsk == df::job_skill::AXE)
|
|
axe_count++;
|
|
else if (weaponsk == df::job_skill::MINING)
|
|
pick_count++;
|
|
}
|
|
|
|
if (print_debug)
|
|
out.print("Axes = %d, picks = %d\n", axe_count, pick_count);
|
|
|
|
}
|
|
|
|
void collect_job_list()
|
|
{
|
|
std::vector<df::job*> repeating_jobs;
|
|
|
|
|
|
for (df::job_list_link* jll = world->job_list.next; jll; jll = jll->next)
|
|
{
|
|
df::job* j = jll->item;
|
|
if (!j)
|
|
continue;
|
|
|
|
if (j->flags.bits.suspend)
|
|
continue;
|
|
|
|
int worker = -1;
|
|
|
|
for (int r = 0; r < j->references.size(); ++r)
|
|
if (j->references[r]->getType() == df::general_ref_type::UNIT_WORKER)
|
|
worker = ((df::general_ref_unit_workerst *)(j->references[r]))->unit_id;
|
|
|
|
if (worker != -1)
|
|
continue;
|
|
|
|
if (j->flags.bits.repeat)
|
|
repeating_jobs.push_back(j);
|
|
else
|
|
jobs.push_back(j);
|
|
}
|
|
|
|
if (print_debug)
|
|
out.print("%d repeating jobs, %d nonrepeating jobs\n", repeating_jobs.size(), jobs.size());
|
|
|
|
for (int i = 0; i < repeating_jobs.size(); i++)
|
|
jobs.push_back(repeating_jobs[i]);
|
|
|
|
}
|
|
|
|
void collect_dwarf_list()
|
|
{
|
|
|
|
for (auto u = world->units.active.begin(); u != world->units.active.end(); ++u)
|
|
{
|
|
df::unit* cre = *u;
|
|
|
|
if (Units::isCitizen(cre))
|
|
{
|
|
if (cre->burrows.size() > 0)
|
|
continue; // dwarfs assigned to burrows are skipped entirely
|
|
|
|
dwarf_info_t* dwarf = add_dwarf(cre);
|
|
|
|
df::historical_figure* hf = df::historical_figure::find(dwarf->dwarf->hist_figure_id);
|
|
for (int i = 0; i < hf->entity_links.size(); i++)
|
|
{
|
|
df::histfig_entity_link* hfelink = hf->entity_links.at(i);
|
|
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;
|
|
|
|
if (position->responsibilities[df::entity_position_responsibility::TRADE])
|
|
if (trader_requested)
|
|
dwarf->clear_all = true;
|
|
}
|
|
|
|
}
|
|
|
|
// identify dwarfs who are needed for meetings and mark them for exclusion
|
|
|
|
for (int i = 0; i < ui->activities.size(); ++i)
|
|
{
|
|
df::activity_info *act = ui->activities[i];
|
|
if (!act) continue;
|
|
bool p1 = act->person1 == dwarf->dwarf;
|
|
bool p2 = act->person2 == dwarf->dwarf;
|
|
|
|
if (p1 || p2)
|
|
{
|
|
dwarf->clear_all = true;
|
|
if (print_debug)
|
|
out.print("Dwarf \"%s\" has a meeting, will be cleared of all labors\n", dwarf->dwarf->name.first_name.c_str());
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Find the activity state for each dwarf->
|
|
|
|
bool is_on_break = false;
|
|
dwarf_state state = OTHER;
|
|
|
|
for (auto p = dwarf->dwarf->status.misc_traits.begin(); p < dwarf->dwarf->status.misc_traits.end(); p++)
|
|
{
|
|
if ((*p)->id == misc_trait_type::Migrant || (*p)->id == misc_trait_type::OnBreak)
|
|
is_on_break = true;
|
|
}
|
|
|
|
if (dwarf->dwarf->profession == profession::BABY ||
|
|
dwarf->dwarf->profession == profession::CHILD ||
|
|
dwarf->dwarf->profession == profession::DRUNK)
|
|
{
|
|
state = CHILD;
|
|
}
|
|
else if (ENUM_ATTR(profession, military, dwarf->dwarf->profession))
|
|
state = MILITARY;
|
|
else if (dwarf->dwarf->job.current_job == NULL)
|
|
{
|
|
if (is_on_break)
|
|
state = OTHER;
|
|
else if (dwarf->dwarf->specific_refs.size() > 0)
|
|
state = OTHER;
|
|
else
|
|
state = IDLE;
|
|
}
|
|
else
|
|
{
|
|
int job = dwarf->dwarf->job.current_job->job_type;
|
|
if (job >= 0 && job < ARRAY_COUNT(dwarf_states))
|
|
state = dwarf_states[job];
|
|
else
|
|
{
|
|
out.print("Dwarf \"%s\" has unknown job %i\n", dwarf->dwarf->name.first_name.c_str(), job);
|
|
state = OTHER;
|
|
}
|
|
}
|
|
|
|
dwarf->state = state;
|
|
|
|
if (print_debug)
|
|
out.print("Dwarf \"%s\": state %s\n", dwarf->dwarf->name.first_name.c_str(), state_names[dwarf->state]);
|
|
|
|
// check if dwarf has an axe, pick, or crossbow
|
|
|
|
for (int j = 0; j < dwarf->dwarf->inventory.size(); j++)
|
|
{
|
|
df::unit_inventory_item* ui = dwarf->dwarf->inventory[j];
|
|
if (ui->mode == df::unit_inventory_item::Weapon && ui->item->isWeapon())
|
|
{
|
|
df::itemdef_weaponst* weapondef = ((df::item_weaponst*)(ui->item))->subtype;
|
|
df::job_skill weaponsk = (df::job_skill) weapondef->skill_melee;
|
|
df::job_skill rangesk = (df::job_skill) weapondef->skill_ranged;
|
|
if (weaponsk == df::job_skill::AXE)
|
|
{
|
|
dwarf->has_axe = 1;
|
|
if (state != IDLE)
|
|
axe_count--;
|
|
if (print_debug)
|
|
out.print("Dwarf \"%s\" has an axe\n", dwarf->dwarf->name.first_name.c_str());
|
|
}
|
|
else if (weaponsk == df::job_skill::MINING)
|
|
{
|
|
dwarf->has_pick = 1;
|
|
if (state != IDLE)
|
|
pick_count--;
|
|
if (print_debug)
|
|
out.print("Dwarf \"%s\" has an pick\n", dwarf->dwarf->name.first_name.c_str());
|
|
}
|
|
else if (rangesk == df::job_skill::CROSSBOW)
|
|
{
|
|
dwarf->has_crossbow = 1;
|
|
if (print_debug)
|
|
out.print("Dwarf \"%s\" has a crossbow\n", dwarf->dwarf->name.first_name.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
// clear labors if currently idle
|
|
|
|
if (state == IDLE || dwarf->clear_all)
|
|
{
|
|
FOR_ENUM_ITEMS(unit_labor, labor)
|
|
{
|
|
if (labor == unit_labor::NONE)
|
|
continue;
|
|
|
|
dwarf->dwarf->status.labors[labor] = false;
|
|
}
|
|
}
|
|
|
|
if (state == IDLE && !dwarf->clear_all)
|
|
idle_dwarfs.push_back(dwarf);
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void assign_one_dwarf (df::job_skill skill, df::unit_labor labor)
|
|
{
|
|
if (labor == df::unit_labor::NONE)
|
|
return;
|
|
|
|
std::deque<dwarf_info_t*>::iterator bestdwarf = idle_dwarfs.begin();
|
|
|
|
if (skill != df::job_skill::NONE)
|
|
{
|
|
int best_skill_level = -1;
|
|
|
|
for (std::deque<dwarf_info_t*>::iterator k = idle_dwarfs.begin(); k != idle_dwarfs.end(); k++)
|
|
{
|
|
dwarf_info_t* d = (*k);
|
|
int skill_level = Units::getEffectiveSkill(d->dwarf, skill);
|
|
|
|
if (skill_level > best_skill_level)
|
|
{
|
|
bestdwarf = k;
|
|
best_skill_level = skill_level;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (print_debug)
|
|
out.print("assign \"%s\" labor %d\n", (*bestdwarf)->dwarf->name.first_name.c_str(), labor);
|
|
(*bestdwarf)->set_labor(labor);
|
|
|
|
idle_dwarfs.erase(bestdwarf);
|
|
}
|
|
|
|
public:
|
|
void process()
|
|
{
|
|
// scan for specific buildings of interest
|
|
|
|
scan_buildings();
|
|
|
|
// count number of squares designated for dig, wood cutting, detailing, and plant harvesting
|
|
|
|
count_map_designations();
|
|
|
|
// count number of picks and axes available for use
|
|
|
|
count_tools();
|
|
|
|
// collect current job list
|
|
|
|
collect_job_list();
|
|
|
|
// collect list of dwarfs
|
|
|
|
collect_dwarf_list();
|
|
|
|
// assign jobs requiring skill to idle dwarfs
|
|
|
|
int jobs_to_assign = jobs.size();
|
|
if (jobs_to_assign > idle_dwarfs.size())
|
|
jobs_to_assign = idle_dwarfs.size();
|
|
|
|
if (print_debug)
|
|
out.print ("Assign idle (skilled): %d\n", jobs_to_assign);
|
|
|
|
std::vector<df::job*> jobs2;
|
|
|
|
for (int i = 0; i < jobs_to_assign; ++i)
|
|
{
|
|
df::job* j = jobs[i];
|
|
|
|
df::job_skill skill;
|
|
df::unit_labor labor;
|
|
|
|
find_job_skill_labor(j, skill, labor);
|
|
|
|
if(print_debug)
|
|
out.print("Job skill = %d labor = %d\n", skill, labor);
|
|
|
|
if (labor == -1)
|
|
out.print("Invalid labor for job (%d)\n", j->job_type);
|
|
|
|
if (skill == df::job_skill::NONE)
|
|
jobs2.push_back(j);
|
|
else
|
|
assign_one_dwarf(skill, labor);
|
|
}
|
|
|
|
// assign mining jobs to idle dwarfs
|
|
|
|
int dig_max = dig_count;
|
|
if (dig_max > pick_count)
|
|
dig_max = pick_count;
|
|
|
|
jobs_to_assign = dig_max - jobs2.size();
|
|
if (jobs_to_assign > idle_dwarfs.size())
|
|
jobs_to_assign = idle_dwarfs.size();
|
|
|
|
if (print_debug)
|
|
out.print ("Assign idle (mining): %d\n", jobs_to_assign);
|
|
|
|
for (int i = 0; i < jobs_to_assign; ++i)
|
|
{
|
|
df::job_skill skill = df::job_skill::MINING;
|
|
df::unit_labor labor = df::unit_labor::MINE;
|
|
|
|
assign_one_dwarf(skill, labor);
|
|
}
|
|
|
|
// now assign unskilled jobs to idle dwarfs
|
|
|
|
jobs_to_assign = jobs2.size();
|
|
if (jobs_to_assign > idle_dwarfs.size())
|
|
jobs_to_assign = idle_dwarfs.size();
|
|
|
|
if (print_debug)
|
|
out.print ("Assign idle (unskilled): %d\n", jobs_to_assign);
|
|
|
|
for (int i = 0; i < jobs_to_assign; ++i)
|
|
{
|
|
df::job* j = jobs2[i];
|
|
|
|
df::job_skill skill;
|
|
df::unit_labor labor;
|
|
|
|
find_job_skill_labor(j, skill, labor);
|
|
assign_one_dwarf(skill, labor);
|
|
}
|
|
|
|
print_debug = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
|
|
{
|
|
switch (event) {
|
|
case SC_MAP_LOADED:
|
|
cleanup_state();
|
|
init_state();
|
|
break;
|
|
case SC_MAP_UNLOADED:
|
|
cleanup_state();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return CR_OK;
|
|
}
|
|
|
|
DFhackCExport command_result plugin_onupdate ( color_ostream &out )
|
|
{
|
|
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;
|
|
|
|
AutoLaborManager alm(out);
|
|
|
|
alm.process();
|
|
|
|
|
|
return CR_OK;
|
|
}
|
|
|
|
void print_labor (df::unit_labor labor, color_ostream &out)
|
|
{
|
|
string labor_name = ENUM_KEY_STR(unit_labor, labor);
|
|
out << labor_name << ": ";
|
|
for (int i = 0; i < 20 - (int)labor_name.length(); i++)
|
|
out << ' ';
|
|
if (labor_infos[labor].mode() == DISABLE)
|
|
out << "disabled" << endl;
|
|
else
|
|
{
|
|
if (labor_infos[labor].mode() == HAULERS)
|
|
out << "haulers";
|
|
else
|
|
out << "minimum " << labor_infos[labor].minimum_dwarfs() << ", maximum " << labor_infos[labor].maximum_dwarfs();
|
|
out << ", currently " << labor_infos[labor].active_dwarfs << " dwarfs" << endl;
|
|
}
|
|
}
|
|
|
|
|
|
command_result autolabor (color_ostream &out, std::vector <std::string> & parameters)
|
|
{
|
|
CoreSuspender suspend;
|
|
|
|
if (!Core::getInstance().isWorldLoaded()) {
|
|
out.printerr("World is not loaded: please load a game first.\n");
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
if (parameters.size() == 1 &&
|
|
(parameters[0] == "0" || parameters[0] == "enable" ||
|
|
parameters[0] == "1" || parameters[0] == "disable"))
|
|
{
|
|
bool enable = (parameters[0] == "1" || parameters[0] == "enable");
|
|
if (enable && !enable_autolabor)
|
|
{
|
|
enable_plugin(out);
|
|
}
|
|
else if(!enable && enable_autolabor)
|
|
{
|
|
enable_autolabor = false;
|
|
setOptionEnabled(CF_ENABLED, false);
|
|
|
|
out << "The plugin is disabled." << endl;
|
|
}
|
|
|
|
return CR_OK;
|
|
}
|
|
else if (parameters.size() == 2 && parameters[0] == "haulpct")
|
|
{
|
|
if (!enable_autolabor)
|
|
{
|
|
out << "Error: The plugin is not enabled." << endl;
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
int pct = atoi (parameters[1].c_str());
|
|
hauler_pct = pct;
|
|
return CR_OK;
|
|
}
|
|
else if (parameters.size() == 2 || parameters.size() == 3)
|
|
{
|
|
if (!enable_autolabor)
|
|
{
|
|
out << "Error: The plugin is not enabled." << endl;
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
df::unit_labor labor = unit_labor::NONE;
|
|
|
|
FOR_ENUM_ITEMS(unit_labor, test_labor)
|
|
{
|
|
if (parameters[0] == ENUM_KEY_STR(unit_labor, test_labor))
|
|
labor = test_labor;
|
|
}
|
|
|
|
if (labor == unit_labor::NONE)
|
|
{
|
|
out.printerr("Could not find labor %s.\n", parameters[0].c_str());
|
|
return CR_WRONG_USAGE;
|
|
}
|
|
|
|
if (parameters[1] == "haulers")
|
|
{
|
|
labor_infos[labor].set_mode(HAULERS);
|
|
print_labor(labor, out);
|
|
return CR_OK;
|
|
}
|
|
if (parameters[1] == "disable")
|
|
{
|
|
labor_infos[labor].set_mode(DISABLE);
|
|
print_labor(labor, out);
|
|
return CR_OK;
|
|
}
|
|
if (parameters[1] == "reset")
|
|
{
|
|
reset_labor(labor);
|
|
print_labor(labor, out);
|
|
return CR_OK;
|
|
}
|
|
|
|
int minimum = atoi (parameters[1].c_str());
|
|
int maximum = 200;
|
|
if (parameters.size() == 3)
|
|
maximum = atoi (parameters[2].c_str());
|
|
|
|
if (maximum < minimum || maximum < 0 || minimum < 0)
|
|
{
|
|
out.printerr("Syntax: autolabor <labor> <minimum> [<maximum>]\n", maximum, minimum);
|
|
return CR_WRONG_USAGE;
|
|
}
|
|
|
|
labor_infos[labor].set_minimum_dwarfs(minimum);
|
|
labor_infos[labor].set_maximum_dwarfs(maximum);
|
|
labor_infos[labor].set_mode(AUTOMATIC);
|
|
print_labor(labor, out);
|
|
|
|
return CR_OK;
|
|
}
|
|
else if (parameters.size() == 1 && parameters[0] == "reset-all")
|
|
{
|
|
if (!enable_autolabor)
|
|
{
|
|
out << "Error: The plugin is not enabled." << endl;
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
for (int i = 0; i < labor_infos.size(); i++)
|
|
{
|
|
reset_labor((df::unit_labor) i);
|
|
}
|
|
out << "All labors reset." << endl;
|
|
return CR_OK;
|
|
}
|
|
else if (parameters.size() == 1 && parameters[0] == "list" || parameters[0] == "status")
|
|
{
|
|
if (!enable_autolabor)
|
|
{
|
|
out << "Error: The plugin is not enabled." << endl;
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
bool need_comma = 0;
|
|
for (int i = 0; i < NUM_STATE; i++)
|
|
{
|
|
if (state_count[i] == 0)
|
|
continue;
|
|
if (need_comma)
|
|
out << ", ";
|
|
out << state_count[i] << ' ' << state_names[i];
|
|
need_comma = 1;
|
|
}
|
|
out << endl;
|
|
|
|
if (parameters[0] == "list")
|
|
{
|
|
FOR_ENUM_ITEMS(unit_labor, labor)
|
|
{
|
|
if (labor == unit_labor::NONE)
|
|
continue;
|
|
|
|
print_labor(labor, out);
|
|
}
|
|
}
|
|
|
|
return CR_OK;
|
|
}
|
|
else if (parameters.size() == 1 && parameters[0] == "debug")
|
|
{
|
|
if (!enable_autolabor)
|
|
{
|
|
out << "Error: The plugin is not enabled." << endl;
|
|
return CR_FAILURE;
|
|
}
|
|
|
|
print_debug = 1;
|
|
|
|
return CR_OK;
|
|
}
|
|
else
|
|
{
|
|
out.print("Automatically assigns labors to dwarves.\n"
|
|
"Activate with 'autolabor 1', deactivate with 'autolabor 0'.\n"
|
|
"Current state: %d.\n", enable_autolabor);
|
|
|
|
return CR_OK;
|
|
}
|
|
}
|
|
|