MetzNet
/
dfhack
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dfhack/plugins/labormanager.cpp

3136 lines
126 KiB
C++
Raw Normal View History Unescape Escape

to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
/*
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
* Labor manager (formerly Autolabor 2) module for dfhack
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
*
* */
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
#include "Core.h"
#include <Console.h>
#include <Export.h>
#include <PluginManager.h>
#include <vector>
#include <algorithm>
Assorted progress on new autolabor. Still lots of issues.
2012-11-30 19:22:58 -07:00
#include <queue>
#include <map>
#include <iterator>
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
#include "modules/Units.h"
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
#include "modules/World.h"
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
#include "modules/Maps.h"
#include "modules/MapCache.h"
#include "modules/Items.h"
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
// DF data structure definition headers
#include "DataDefs.h"
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
#include <MiscUtils.h>
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
#include <df/ui.h>
#include <df/world.h>
#include <df/unit.h>
Update labormanager for unit.relations removal and fix warnings
2016-08-11 21:42:58 -06:00
#include <df/unit_relationship_type.h>
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
#include <df/unit_soul.h>
#include <df/unit_labor.h>
#include <df/unit_skill.h>
#include <df/job.h>
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
#include <df/building.h>
#include <df/workshop_type.h>
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
#include <df/unit_misc_trait.h>
Autolabor: Instead of guessing who the nobles are based on noble skills, actually find out who they are and behave appropriately. Certain responsibilities are assigned various penalties to increase their holders' availability to perform noble functions. Also, holders of the "manage health" responsibility are always assigned the diagnose labor. The responsibility penalties are first-approximation and will likely need tuning.
2012-04-26 08:38:25 -06:00
#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>
Autolabor will exclude the trade broker from all labors if the "trader requested" flag is on at the trade depot.
2012-04-26 12:46:38 -06:00
#include <df/building_tradedepotst.h>
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
#include <df/building_stockpilest.h>
#include <df/items_other_id.h>
#include <df/ui.h>
#include <df/activity_info.h>
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
#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>
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
#include <df/building_furnacest.h>
#include <df/building_def.h>
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
#include <df/reaction.h>
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
#include <df/job_item.h>
#include <df/job_item_ref.h>
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
#include <df/unit_health_info.h>
#include <df/unit_health_flags.h>
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
#include <df/building_design.h>
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
#include <df/vehicle.h>
Autolabor: slabs, animal trainers
2012-12-06 00:38:43 -07:00
#include <df/units_other_id.h>
#include <df/ui.h>
#include <df/training_assignment.h>
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
#include <df/general_ref_contains_itemst.h>
Autolabor: Instead of guessing who the nobles are based on noble skills, actually find out who they are and behave appropriately. Certain responsibilities are assigned various penalties to increase their holders' availability to perform noble functions. Also, holders of the "manage health" responsibility are always assigned the diagnose labor. The responsibility penalties are first-approximation and will likely need tuning.
2012-04-26 08:38:25 -06:00
Remove "using namespace std" from MiscUtils.h.
2013-10-08 07:41:49 -06:00
using namespace std;
Add commands to change how autolabor handles specific jobs, and to list the current settings. Changes are not saved with the current world (yet).
2012-04-02 23:12:06 -06:00
using std::string;
using std::endl;
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
using namespace DFHack;
using namespace df::enums;
using df::global::ui;
using df::global::world;
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
#define ARRAY_COUNT(array) (sizeof(array)/sizeof((array)[0]))
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
DFHACK_PLUGIN_IS_ENABLED(enable_labormanager);
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Large change to how autolabor assigns labors. Military dwarves and children/nobles will never be assigned labors. Labor assignments are more understandable.
2012-04-02 21:55:02 -06:00
static bool print_debug = 0;
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
static bool pause_on_error = 1;
Large change to how autolabor assigns labors. Military dwarves and children/nobles will never be assigned labors. Labor assignments are more understandable.
2012-04-02 21:55:02 -06:00
Add commands to change how autolabor handles specific jobs, and to list the current settings. Changes are not saved with the current world (yet).
2012-04-02 23:12:06 -06:00
static std::vector<int> state_count(5);
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
static PersistentDataItem config;
enum ConfigFlags {
CF_ENABLED = 1,
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
CF_ALLOW_FISHING = 2,
CF_ALLOW_HUNTING = 4,
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
};
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
// Here go all the command declarations...
// mostly to allow having the mandatory stuff on top of the file and commands on the bottom
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
command_result labormanager (color_ostream &out, std::vector <std::string> & parameters);
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
// A plugin must be able to return its name and version.
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
// The name string provided must correspond to the filename - labormanager.plug.so or labormanager.plug.dll in this case
DFHACK_PLUGIN("labormanager");
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
fix autolabor compilation error
2012-08-02 19:28:29 -06:00
static void generate_labor_to_skill_map();
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
enum dwarf_state {
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// Ready for a new task
IDLE,
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// Busy with a useful task
BUSY,
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// In the military, can't work
MILITARY,
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// Child or noble, can't work
CHILD,
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// Doing something that precludes working, may be busy for a while
OTHER
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
};
Add commands to change how autolabor handles specific jobs, and to list the current settings. Changes are not saved with the current world (yet).
2012-04-02 23:12:06 -06:00
const int NUM_STATE = 5;
Large change to how autolabor assigns labors. Military dwarves and children/nobles will never be assigned labors. Labor assignments are more understandable.
2012-04-02 21:55:02 -06:00
static const char *state_names[] = {
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
"IDLE",
"BUSY",
"MILITARY",
"CHILD",
"OTHER",
Large change to how autolabor assigns labors. Military dwarves and children/nobles will never be assigned labors. Labor assignments are more understandable.
2012-04-02 21:55:02 -06:00
};
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
static const dwarf_state dwarf_states[] = {
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
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 */,
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
OTHER /* PickupEquipment */,
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
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 */,
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
BUSY /* TrainAnimal */,
BUSY /* CarveTrack */,
BUSY /* PushTrackVehicle */,
BUSY /* PlaceTrackVehicle */,
add new jobs to autolabor
2016-02-22 10:40:52 -07:00
BUSY /* StoreItemInVehicle */,
BUSY /* GeldAnimal */,
BUSY /* MakeFigurine */,
BUSY /* MakeAmulet */,
BUSY /* MakeScepter */,
BUSY /* MakeCrown */,
BUSY /* MakeRing */,
BUSY /* MakeEarring */,
BUSY /* MakeBracelet */,
BUSY /* MakeGem */
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
};
struct labor_info
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
{
PersistentDataItem config;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
int active_dwarfs;
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
int idle_dwarfs;
int busy_dwarfs;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
int priority() { return config.ival(1); }
void set_priority(int priority) { config.ival(1) = priority; }
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
int maximum_dwarfs() { return config.ival(2); }
void set_maximum_dwarfs(int maximum_dwarfs) { config.ival(2) = maximum_dwarfs; }
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
int time_since_last_assigned()
{
return (*df::global::cur_year - config.ival(3)) * 403200 + *df::global::cur_year_tick - config.ival(4);
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
}
void mark_assigned() {
config.ival(3) = (* df::global::cur_year);
config.ival(4) = (* df::global::cur_year_tick);
}
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
};
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
enum tools_enum {
TOOL_NONE, TOOL_PICK, TOOL_AXE, TOOL_CROSSBOW,
TOOLS_MAX
};
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
struct labor_default
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
int priority;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
int maximum_dwarfs;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
tools_enum tool;
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
};
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
static std::vector<struct labor_info> labor_infos;
Make autolabor accept "enable" and "disable" as well as "0" or "1". Add ability to set target number of miners in autolabor with "autolabor miners".
2012-03-28 09:25:36 -06:00
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
static const struct labor_default default_labor_infos[] = {
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* MINE */ {100, 0, TOOL_PICK},
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* HAUL_STONE */ {100, 0, TOOL_NONE},
/* HAUL_WOOD */ {100, 0, TOOL_NONE},
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* HAUL_BODY */ {1000, 0, TOOL_NONE},
/* HAUL_FOOD */ {500, 0, TOOL_NONE},
/* HAUL_REFUSE */ {200, 0, TOOL_NONE},
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* HAUL_ITEM */ {100, 0, TOOL_NONE},
/* HAUL_FURNITURE */ {100, 0, TOOL_NONE},
/* HAUL_ANIMAL */ {100, 0, TOOL_NONE},
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* CLEAN */ {100, 0, TOOL_NONE},
/* CUTWOOD */ {100, 0, TOOL_AXE},
/* CARPENTER */ {100, 0, TOOL_NONE},
/* DETAIL */ {100, 0, TOOL_NONE},
/* MASON */ {100, 0, TOOL_NONE},
/* ARCHITECT */ {100, 0, TOOL_NONE},
/* ANIMALTRAIN */ {100, 0, TOOL_NONE},
/* ANIMALCARE */ {100, 0, TOOL_NONE},
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* DIAGNOSE */ {1000, 0, TOOL_NONE},
/* SURGERY */ {1000, 0, TOOL_NONE},
/* BONE_SETTING */ {1000, 0, TOOL_NONE},
/* SUTURING */ {1000, 0, TOOL_NONE},
/* DRESSING_WOUNDS */ {1000, 0, TOOL_NONE},
/* FEED_WATER_CIVILIANS */ {1000, 0, TOOL_NONE},
/* RECOVER_WOUNDED */ {200, 0, TOOL_NONE},
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* BUTCHER */ {500, 0, TOOL_NONE},
/* TRAPPER */ {100, 0, TOOL_NONE},
/* DISSECT_VERMIN */ {100, 0, TOOL_NONE},
/* LEATHER */ {100, 0, TOOL_NONE},
/* TANNER */ {100, 0, TOOL_NONE},
/* BREWER */ {100, 0, TOOL_NONE},
/* ALCHEMIST */ {100, 0, TOOL_NONE},
/* SOAP_MAKER */ {100, 0, TOOL_NONE},
/* WEAVER */ {100, 0, TOOL_NONE},
/* CLOTHESMAKER */ {100, 0, TOOL_NONE},
/* MILLER */ {100, 0, TOOL_NONE},
/* PROCESS_PLANT */ {100, 0, TOOL_NONE},
/* MAKE_CHEESE */ {100, 0, TOOL_NONE},
/* MILK */ {100, 0, TOOL_NONE},
/* COOK */ {100, 0, TOOL_NONE},
/* PLANT */ {100, 0, TOOL_NONE},
/* HERBALIST */ {100, 0, TOOL_NONE},
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* FISH */ {100, 0, TOOL_NONE},
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* CLEAN_FISH */ {100, 0, TOOL_NONE},
/* DISSECT_FISH */ {100, 0, TOOL_NONE},
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* HUNT */ {100, 0, TOOL_CROSSBOW},
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
/* SMELT */ {100, 0, TOOL_NONE},
/* FORGE_WEAPON */ {100, 0, TOOL_NONE},
/* FORGE_ARMOR */ {100, 0, TOOL_NONE},
/* FORGE_FURNITURE */ {100, 0, TOOL_NONE},
/* METAL_CRAFT */ {100, 0, TOOL_NONE},
/* CUT_GEM */ {100, 0, TOOL_NONE},
/* ENCRUST_GEM */ {100, 0, TOOL_NONE},
/* WOOD_CRAFT */ {100, 0, TOOL_NONE},
/* STONE_CRAFT */ {100, 0, TOOL_NONE},
/* BONE_CARVE */ {100, 0, TOOL_NONE},
/* GLASSMAKER */ {100, 0, TOOL_NONE},
/* EXTRACT_STRAND */ {100, 0, TOOL_NONE},
/* SIEGECRAFT */ {100, 0, TOOL_NONE},
/* SIEGEOPERATE */ {100, 0, TOOL_NONE},
/* BOWYER */ {100, 0, TOOL_NONE},
/* MECHANIC */ {100, 0, TOOL_NONE},
/* POTASH_MAKING */ {100, 0, TOOL_NONE},
/* LYE_MAKING */ {100, 0, TOOL_NONE},
/* DYER */ {100, 0, TOOL_NONE},
/* BURN_WOOD */ {100, 0, TOOL_NONE},
/* OPERATE_PUMP */ {100, 0, TOOL_NONE},
/* SHEARER */ {100, 0, TOOL_NONE},
/* SPINNER */ {100, 0, TOOL_NONE},
/* POTTERY */ {100, 0, TOOL_NONE},
/* GLAZING */ {100, 0, TOOL_NONE},
/* PRESSING */ {100, 0, TOOL_NONE},
/* BEEKEEPING */ {100, 0, TOOL_NONE},
/* WAX_WORKING */ {100, 0, TOOL_NONE},
/* PUSH_HAUL_VEHICLES */ {100, 0, TOOL_NONE},
/* HAUL_TRADE */ {1000, 0, TOOL_NONE},
/* PULL_LEVER */ {1000, 0, TOOL_NONE},
/* REMOVE_CONSTRUCTION */ {100, 0, TOOL_NONE},
/* HAUL_WATER */ {100, 0, TOOL_NONE},
/* GELD */ {100, 0, TOOL_NONE},
/* BUILD_ROAD */ {100, 0, TOOL_NONE},
/* BUILD_CONSTRUCTION */ {100, 0, TOOL_NONE},
/* PAPERMAKING */ {100, 0, TOOL_NONE},
/* BOOKBINDING */ {100, 0, TOOL_NONE}
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
};
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
void debug (char* fmt, ...);
Turn sorting lambdas into functors in autolabor.
2012-03-29 12:00:26 -06:00
struct dwarf_info_t
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
{
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
df::unit* dwarf;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
dwarf_state state;
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
bool clear_all;
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
bool has_tool[TOOLS_MAX];
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
int high_skill;
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
bool has_children;
Autolabor: busy dwarfs may be reassigned now, but with a strong preference for their current job; armed dwarfs are given preference for outside jobs; include experience gained toward next level in preference weighting
2012-12-10 07:34:11 -07:00
bool armed;
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
df::unit_labor using_labor;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
dwarf_info_t(df::unit* dw) : dwarf(dw), clear_all(false),
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
state(OTHER), high_skill(0), has_children(false), armed(false), using_labor(df::unit_labor::NONE)
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
for (int e = TOOL_NONE; e < TOOLS_MAX; e++)
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
has_tool[e] = false;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
~dwarf_info_t()
{
}
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
/*
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
* Here starts all the complicated stuff to try to deduce labors from jobs.
* This is all way more complicated than it really ought to be, but I have
* not found a way to make it simpler.
*/
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
static df::unit_labor hauling_labor_map[] =
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
df::unit_labor::HAUL_ITEM, /* BAR */
df::unit_labor::HAUL_STONE, /* SMALLGEM */
df::unit_labor::HAUL_ITEM, /* BLOCKS */
df::unit_labor::HAUL_STONE, /* ROUGH */
df::unit_labor::HAUL_STONE, /* BOULDER */
df::unit_labor::HAUL_WOOD, /* WOOD */
df::unit_labor::HAUL_FURNITURE, /* DOOR */
df::unit_labor::HAUL_FURNITURE, /* FLOODGATE */
df::unit_labor::HAUL_FURNITURE, /* BED */
df::unit_labor::HAUL_FURNITURE, /* CHAIR */
df::unit_labor::HAUL_ITEM, /* CHAIN */
df::unit_labor::HAUL_ITEM, /* FLASK */
df::unit_labor::HAUL_ITEM, /* GOBLET */
df::unit_labor::HAUL_ITEM, /* INSTRUMENT */
df::unit_labor::HAUL_ITEM, /* TOY */
df::unit_labor::HAUL_FURNITURE, /* WINDOW */
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
df::unit_labor::HAUL_ANIMALS, /* CAGE */
Fix whitespace issues
2015-02-14 20:53:06 -07:00
df::unit_labor::HAUL_ITEM, /* BARREL */
df::unit_labor::HAUL_ITEM, /* BUCKET */
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
df::unit_labor::HAUL_ANIMALS, /* ANIMALTRAP */
Fix whitespace issues
2015-02-14 20:53:06 -07:00
df::unit_labor::HAUL_FURNITURE, /* TABLE */
df::unit_labor::HAUL_FURNITURE, /* COFFIN */
df::unit_labor::HAUL_FURNITURE, /* STATUE */
df::unit_labor::HAUL_REFUSE, /* CORPSE */
df::unit_labor::HAUL_ITEM, /* WEAPON */
df::unit_labor::HAUL_ITEM, /* ARMOR */
df::unit_labor::HAUL_ITEM, /* SHOES */
df::unit_labor::HAUL_ITEM, /* SHIELD */
df::unit_labor::HAUL_ITEM, /* HELM */
df::unit_labor::HAUL_ITEM, /* GLOVES */
df::unit_labor::HAUL_FURNITURE, /* BOX */
df::unit_labor::HAUL_ITEM, /* BIN */
df::unit_labor::HAUL_FURNITURE, /* ARMORSTAND */
df::unit_labor::HAUL_FURNITURE, /* WEAPONRACK */
df::unit_labor::HAUL_FURNITURE, /* CABINET */
df::unit_labor::HAUL_ITEM, /* FIGURINE */
df::unit_labor::HAUL_ITEM, /* AMULET */
df::unit_labor::HAUL_ITEM, /* SCEPTER */
df::unit_labor::HAUL_ITEM, /* AMMO */
df::unit_labor::HAUL_ITEM, /* CROWN */
df::unit_labor::HAUL_ITEM, /* RING */
df::unit_labor::HAUL_ITEM, /* EARRING */
df::unit_labor::HAUL_ITEM, /* BRACELET */
df::unit_labor::HAUL_ITEM, /* GEM */
df::unit_labor::HAUL_FURNITURE, /* ANVIL */
df::unit_labor::HAUL_REFUSE, /* CORPSEPIECE */
df::unit_labor::HAUL_REFUSE, /* REMAINS */
df::unit_labor::HAUL_FOOD, /* MEAT */
df::unit_labor::HAUL_FOOD, /* FISH */
df::unit_labor::HAUL_FOOD, /* FISH_RAW */
df::unit_labor::HAUL_REFUSE, /* VERMIN */
df::unit_labor::HAUL_ITEM, /* PET */
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
df::unit_labor::HAUL_ITEM, /* SEEDS */
Fix whitespace issues
2015-02-14 20:53:06 -07:00
df::unit_labor::HAUL_FOOD, /* PLANT */
df::unit_labor::HAUL_ITEM, /* SKIN_TANNED */
df::unit_labor::HAUL_FOOD, /* LEAVES */
df::unit_labor::HAUL_ITEM, /* THREAD */
df::unit_labor::HAUL_ITEM, /* CLOTH */
df::unit_labor::HAUL_ITEM, /* TOTEM */
df::unit_labor::HAUL_ITEM, /* PANTS */
df::unit_labor::HAUL_ITEM, /* BACKPACK */
df::unit_labor::HAUL_ITEM, /* QUIVER */
df::unit_labor::HAUL_FURNITURE, /* CATAPULTPARTS */
df::unit_labor::HAUL_FURNITURE, /* BALLISTAPARTS */
df::unit_labor::HAUL_FURNITURE, /* SIEGEAMMO */
df::unit_labor::HAUL_FURNITURE, /* BALLISTAARROWHEAD */
df::unit_labor::HAUL_FURNITURE, /* TRAPPARTS */
df::unit_labor::HAUL_FURNITURE, /* TRAPCOMP */
df::unit_labor::HAUL_FOOD, /* DRINK */
df::unit_labor::HAUL_FOOD, /* POWDER_MISC */
df::unit_labor::HAUL_FOOD, /* CHEESE */
df::unit_labor::HAUL_FOOD, /* FOOD */
df::unit_labor::HAUL_FOOD, /* LIQUID_MISC */
df::unit_labor::HAUL_ITEM, /* COIN */
df::unit_labor::HAUL_FOOD, /* GLOB */
df::unit_labor::HAUL_STONE, /* ROCK */
df::unit_labor::HAUL_FURNITURE, /* PIPE_SECTION */
df::unit_labor::HAUL_FURNITURE, /* HATCH_COVER */
df::unit_labor::HAUL_FURNITURE, /* GRATE */
df::unit_labor::HAUL_FURNITURE, /* QUERN */
df::unit_labor::HAUL_FURNITURE, /* MILLSTONE */
df::unit_labor::HAUL_ITEM, /* SPLINT */
df::unit_labor::HAUL_ITEM, /* CRUTCH */
df::unit_labor::HAUL_FURNITURE, /* TRACTION_BENCH */
df::unit_labor::HAUL_ITEM, /* ORTHOPEDIC_CAST */
df::unit_labor::HAUL_ITEM, /* TOOL */
df::unit_labor::HAUL_FURNITURE, /* SLAB */
df::unit_labor::HAUL_FOOD, /* EGG */
df::unit_labor::HAUL_ITEM, /* BOOK */
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
static df::unit_labor workshop_build_labor[] =
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
/* Carpenters */ df::unit_labor::CARPENTER,
/* Farmers */ df::unit_labor::PROCESS_PLANT,
/* Masons */ df::unit_labor::MASON,
/* Craftsdwarfs */ df::unit_labor::STONE_CRAFT,
/* Jewelers */ df::unit_labor::CUT_GEM,
/* MetalsmithsForge */ df::unit_labor::METAL_CRAFT,
/* MagmaForge */ df::unit_labor::METAL_CRAFT,
/* Bowyers */ df::unit_labor::BOWYER,
/* Mechanics */ df::unit_labor::MECHANIC,
/* Siege */ df::unit_labor::SIEGECRAFT,
/* Butchers */ df::unit_labor::BUTCHER,
/* Leatherworks */ df::unit_labor::LEATHER,
/* Tanners */ df::unit_labor::TANNER,
/* Clothiers */ df::unit_labor::CLOTHESMAKER,
/* Fishery */ df::unit_labor::CLEAN_FISH,
/* Still */ df::unit_labor::BREWER,
/* Loom */ df::unit_labor::WEAVER,
/* Quern */ df::unit_labor::MILLER,
/* Kennels */ df::unit_labor::ANIMALTRAIN,
/* Kitchen */ df::unit_labor::COOK,
/* Ashery */ df::unit_labor::LYE_MAKING,
/* Dyers */ df::unit_labor::DYER,
/* Millstone */ df::unit_labor::MILLER,
/* Custom */ df::unit_labor::NONE,
/* Tool */ df::unit_labor::NONE
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
};
static df::building* get_building_from_job(df::job* j)
{
for (auto r = j->general_refs.begin(); r != j->general_refs.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;
}
labormanager: multimaterial constructions
2016-11-28 19:24:25 -07:00
static df::unit_labor construction_build_labor (df::building_actual* b)
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
labormanager: multimaterial constructions
2016-11-28 19:24:25 -07:00
if (b->getType() == df::building_type::RoadPaved)
return df::unit_labor::BUILD_ROAD;
// For screw pumps contained_items[0] = pipe, 1 corkscrew, 2 block
// For wells 0 mechanism, 1 rope, 2 bucket, 3 block
// Trade depots and bridges use the last one too
Remove redundant cast
2016-11-28 23:22:34 -07:00
df::item* i = b->contained_items.back()->item;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
MaterialInfo matinfo;
Add a guard against an invalid item pointer, and don't try to deduce construction labor for item_lost jobs
2013-01-03 11:24:32 -07:00
if (i && matinfo.decode(i))
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
if (matinfo.material->flags.is_set(df::material_flags::IS_METAL))
return df::unit_labor::METAL_CRAFT;
if (matinfo.material->flags.is_set(df::material_flags::WOOD))
return df::unit_labor::CARPENTER;
}
return df::unit_labor::MASON;
}
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
color_ostream* debug_stream;
Update labormanager for unit.relations removal and fix warnings
2016-08-11 21:42:58 -06:00
void debug (const char* fmt, ...)
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
if (debug_stream)
{
va_list args;
va_start(args,fmt);
debug_stream->vprint(fmt, args);
va_end(args);
}
}
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
void debug_pause ()
{
if (pause_on_error)
{
debug("LABORMANAGER: Game paused so you can investigate the above message.\nUse 'labormanager pause-on-error no' to disable autopausing.\n");
*df::global::pause_state = true;
}
}
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
class JobLaborMapper {
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
private:
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
public:
virtual df::unit_labor get_labor(df::job* j) = 0;
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_const : public jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
private:
df::unit_labor labor;
public:
Fix whitespace issues
2015-02-14 20:53:06 -07:00
df::unit_labor get_labor(df::job* j)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
return labor;
}
jlfunc_const(df::unit_labor l) : labor(l) {};
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_hauling : public jlfunc
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
{
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
public:
df::unit_labor get_labor(df::job* j)
{
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
df::item* item = 0;
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
if (j->job_type == df::job_type::StoreItemInStockpile && j->item_subtype != -1)
return (df::unit_labor) j->item_subtype;
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
for (auto i = j->items.begin(); i != j->items.end(); i++)
{
if ((*i)->role == 7)
{
item = (*i)->item;
break;
}
}
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (item && item->flags.bits.container)
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
{
for (auto a = item->general_refs.begin(); a != item->general_refs.end(); a++)
{
if ((*a)->getType() == df::general_ref_type::CONTAINS_ITEM)
{
int item_id = ((df::general_ref_contains_itemst *) (*a))->item_id;
item = binsearch_in_vector(world->items.all, item_id);
break;
}
}
}
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
df::unit_labor l = item ? hauling_labor_map[item->getType()] : df::unit_labor::HAUL_ITEM;
if (item && l == df::unit_labor::HAUL_REFUSE && item->flags.bits.dead_dwarf)
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
l = df::unit_labor::HAUL_BODY;
return l;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
jlfunc_hauling() {};
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_construct_bld : public jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
public:
df::unit_labor get_labor(df::job* j)
{
Add a guard against an invalid item pointer, and don't try to deduce construction labor for item_lost jobs
2013-01-03 11:24:32 -07:00
if (j->flags.bits.item_lost)
return df::unit_labor::NONE;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
df::building* bld = get_building_from_job (j);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
switch (bld->getType())
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::Hive:
return df::unit_labor::BEEKEEPING;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
case df::building_type::Workshop:
{
autolabor: add ConstructBuilding (Farm); change priority calculation
2012-12-01 16:39:01 -07:00
df::building_workshopst* ws = (df::building_workshopst*) bld;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
if (ws->design && !ws->design->flags.bits.designed)
return df::unit_labor::ARCHITECT;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (ws->type == df::workshop_type::Custom)
autolabor: add ConstructBuilding (Farm); change priority calculation
2012-12-01 16:39:01 -07:00
{
df::building_def* def = df::building_def::find(ws->custom_type);
return def->build_labors[0];
Fix whitespace issues
2015-02-14 20:53:06 -07:00
}
else
autolabor: add ConstructBuilding (Farm); change priority calculation
2012-12-01 16:39:01 -07:00
return workshop_build_labor[ws->type];
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
break;
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
case df::building_type::Construction:
return df::unit_labor::BUILD_CONSTRUCTION;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
case df::building_type::Furnace:
case df::building_type::TradeDepot:
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
case df::building_type::Bridge:
autolabor: add archery targets, improve JobLaborMapper's destructor
2012-12-06 08:39:14 -07:00
case df::building_type::ArcheryTarget:
Autolabor: add build waterwheel.
2012-12-12 07:46:52 -07:00
case df::building_type::WaterWheel:
Autolabor: add paved roads.
2012-12-18 15:23:02 -07:00
case df::building_type::RoadPaved:
Autolabor: change fishery build labor to CLEAN_FISH to control random acts of fish extermination; add build labor for wells.
2012-12-28 06:58:29 -07:00
case df::building_type::Well:
Autolabor: add screw pump build labor
2013-01-14 11:12:56 -07:00
case df::building_type::ScrewPump:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::Wagon:
case df::building_type::Shop:
case df::building_type::Support:
case df::building_type::Windmill:
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
df::building_actual* b = (df::building_actual*) bld;
if (b->design && !b->design->flags.bits.designed)
return df::unit_labor::ARCHITECT;
labormanager: multimaterial constructions
2016-11-28 19:24:25 -07:00
return construction_build_labor(b);
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
}
break;
autolabor: add ConstructBuilding (Farm); change priority calculation
2012-12-01 16:39:01 -07:00
case df::building_type::FarmPlot:
return df::unit_labor::PLANT;
Autolabor: add more building labors
2012-12-02 17:41:20 -07:00
case df::building_type::Chair:
case df::building_type::Bed:
case df::building_type::Table:
case df::building_type::Coffin:
case df::building_type::Door:
case df::building_type::Floodgate:
case df::building_type::Box:
case df::building_type::Weaponrack:
case df::building_type::Armorstand:
case df::building_type::Cabinet:
case df::building_type::Statue:
case df::building_type::WindowGlass:
case df::building_type::WindowGem:
case df::building_type::Cage:
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
case df::building_type::NestBox:
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
case df::building_type::TractionBench:
Autolabor: slabs, animal trainers
2012-12-06 00:38:43 -07:00
case df::building_type::Slab:
Autolabor: add construct chain labor, add destruct trap labor, change overbroad test for military status (was catching uniformed reservists, who are eligible to do civilian labor)
2012-12-12 21:25:23 -07:00
case df::building_type::Chain:
Autolabor: add build floor grate labor, add unbuild screwpump labor, protect pump operators, do not clear labors on already busy dwarfs
2013-01-22 15:34:51 -07:00
case df::building_type::GrateFloor:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::Hatch:
case df::building_type::BarsFloor:
case df::building_type::BarsVertical:
case df::building_type::GrateWall:
labormanager: add labors for bookcase (de)construct
2016-07-11 21:29:38 -06:00
case df::building_type::Bookcase:
make labormanager know building instruments is furniture hauling
2016-11-26 04:34:56 -07:00
case df::building_type::Instrument:
Autolabor: add more building labors
2012-12-02 17:41:20 -07:00
return df::unit_labor::HAUL_FURNITURE;
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
case df::building_type::Trap:
Autolabor: add construct labor for GearAssembly, AxleHorizonal, and AxleVertical (the last is a guess, but probably right)
2012-12-12 08:52:13 -07:00
case df::building_type::GearAssembly:
case df::building_type::AxleHorizontal:
case df::building_type::AxleVertical:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::Rollers:
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
return df::unit_labor::MECHANIC;
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::AnimalTrap:
return df::unit_labor::TRAPPER;
case df::building_type::Civzone:
case df::building_type::Nest:
case df::building_type::Stockpile:
case df::building_type::Weapon:
return df::unit_labor::NONE;
case df::building_type::SiegeEngine:
return df::unit_labor::SIEGECRAFT;
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
case df::building_type::RoadDirt:
return df::unit_labor::BUILD_ROAD;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for construct building job of type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(building_type, bld->getType()).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
return df::unit_labor::NONE;
}
jlfunc_construct_bld() {}
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_destroy_bld : public jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
public:
df::unit_labor get_labor(df::job* j)
{
df::building* bld = get_building_from_job (j);
df::building_type type = bld->getType();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
switch (bld->getType())
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::Hive:
return df::unit_labor::BEEKEEPING;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
case df::building_type::Workshop:
{
df::building_workshopst* ws = (df::building_workshopst*) bld;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (ws->type == df::workshop_type::Custom)
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
df::building_def* def = df::building_def::find(ws->custom_type);
return def->build_labors[0];
Fix whitespace issues
2015-02-14 20:53:06 -07:00
}
else
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
return workshop_build_labor[ws->type];
}
break;
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
case df::building_type::Construction:
return df::unit_labor::REMOVE_CONSTRUCTION;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
case df::building_type::Furnace:
case df::building_type::TradeDepot:
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
case df::building_type::Wagon:
Autolabor: add deconstruct bridge labor
2013-01-06 09:59:20 -07:00
case df::building_type::Bridge:
Autolabor: add build floor grate labor, add unbuild screwpump labor, protect pump operators, do not clear labors on already busy dwarfs
2013-01-22 15:34:51 -07:00
case df::building_type::ScrewPump:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::ArcheryTarget:
case df::building_type::RoadPaved:
case df::building_type::Shop:
case df::building_type::Support:
case df::building_type::WaterWheel:
case df::building_type::Well:
case df::building_type::Windmill:
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
labormanager: multimaterial constructions
2016-11-28 19:24:25 -07:00
auto b = (df::building_actual*) bld;
return construction_build_labor(b);
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
break;
case df::building_type::FarmPlot:
return df::unit_labor::PLANT;
Autolabor: add construct chain labor, add destruct trap labor, change overbroad test for military status (was catching uniformed reservists, who are eligible to do civilian labor)
2012-12-12 21:25:23 -07:00
case df::building_type::Trap:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::AxleHorizontal:
case df::building_type::AxleVertical:
case df::building_type::GearAssembly:
case df::building_type::Rollers:
Autolabor: add construct chain labor, add destruct trap labor, change overbroad test for military status (was catching uniformed reservists, who are eligible to do civilian labor)
2012-12-12 21:25:23 -07:00
return df::unit_labor::MECHANIC;
Autolabor: add a number of destroy furniture labors (all "haul furniture")
2012-12-15 23:03:26 -07:00
case df::building_type::Chair:
case df::building_type::Bed:
case df::building_type::Table:
case df::building_type::Coffin:
case df::building_type::Door:
case df::building_type::Floodgate:
case df::building_type::Box:
case df::building_type::Weaponrack:
case df::building_type::Armorstand:
case df::building_type::Cabinet:
case df::building_type::Statue:
case df::building_type::WindowGlass:
case df::building_type::WindowGem:
Autolabor: add deconstruct labor for cages
2012-12-14 08:34:03 -07:00
case df::building_type::Cage:
Autolabor: add a number of destroy furniture labors (all "haul furniture")
2012-12-15 23:03:26 -07:00
case df::building_type::NestBox:
case df::building_type::TractionBench:
case df::building_type::Slab:
case df::building_type::Chain:
Autolabor: add construction labor for hatch.
2013-01-01 14:12:45 -07:00
case df::building_type::Hatch:
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::BarsFloor:
case df::building_type::BarsVertical:
case df::building_type::GrateFloor:
case df::building_type::GrateWall:
labormanager: add labors for bookcase (de)construct
2016-07-11 21:29:38 -06:00
case df::building_type::Bookcase:
Autolabor: add deconstruct labor for cages
2012-12-14 08:34:03 -07:00
return df::unit_labor::HAUL_FURNITURE;
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::building_type::AnimalTrap:
return df::unit_labor::TRAPPER;
case df::building_type::Civzone:
case df::building_type::Nest:
case df::building_type::RoadDirt:
case df::building_type::Stockpile:
case df::building_type::Weapon:
return df::unit_labor::NONE;
case df::building_type::SiegeEngine:
return df::unit_labor::SIEGECRAFT;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for destroy building job of type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(building_type, bld->getType()).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
return df::unit_labor::NONE;
}
jlfunc_destroy_bld() {}
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_make : public jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
private:
df::unit_labor metaltype;
public:
df::unit_labor get_labor(df::job* j)
{
df::building* bld = get_building_from_job(j);
if (bld->getType() == df::building_type::Workshop)
{
df::workshop_type type = ((df::building_workshopst*)(bld))->type;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
switch (type)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
case df::workshop_type::Craftsdwarfs:
{
df::item_type jobitem = j->job_items[0]->item_type;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
switch (jobitem)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
case df::item_type::BOULDER:
return df::unit_labor::STONE_CRAFT;
case df::item_type::NONE:
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (j->material_category.bits.bone ||
Autolabor: add labor for ivory & horn crafts (yawn)
2012-12-15 20:18:06 -07:00
j->material_category.bits.horn ||
j->material_category.bits.tooth)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
return df::unit_labor::BONE_CARVE;
else
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for make crafts job (not bone)\n");
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
return df::unit_labor::NONE;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
Autolabor: add in the rest of the building construct and deconstruct labors. Also handle wood crafts at the craftdwarf's shop.
2013-02-13 12:07:54 -07:00
case df::item_type::WOOD:
return df::unit_labor::WOOD_CRAFT;
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
case df::item_type::CLOTH:
return df::unit_labor::CLOTHESMAKER;
add a misisng labor rule for leather crafts
2016-10-25 15:45:25 -06:00
case df::item_type::SKIN_TANNED:
return df::unit_labor::LEATHER;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
default:
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for make crafts job, item type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(item_type, jobitem).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
return df::unit_labor::NONE;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
}
case df::workshop_type::Masons:
return df::unit_labor::MASON;
case df::workshop_type::Carpenters:
return df::unit_labor::CARPENTER;
case df::workshop_type::Leatherworks:
return df::unit_labor::LEATHER;
case df::workshop_type::Clothiers:
return df::unit_labor::CLOTHESMAKER;
labormanager: support for jobs in bowyer's shop
2016-11-27 20:25:38 -07:00
case df::workshop_type::Bowyers:
return df::unit_labor::BOWYER;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
case df::workshop_type::MagmaForge:
case df::workshop_type::MetalsmithsForge:
return metaltype;
default:
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for make job, workshop type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(workshop_type, type).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
return df::unit_labor::NONE;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
}
else if (bld->getType() == df::building_type::Furnace)
{
df::furnace_type type = ((df::building_furnacest*)(bld))->type;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
switch (type)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
case df::furnace_type::MagmaGlassFurnace:
case df::furnace_type::GlassFurnace:
return df::unit_labor::GLASSMAKER;
default:
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for make job, furnace type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(furnace_type, type).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
return df::unit_labor::NONE;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
debug ("LABORMANAGER: Cannot deduce labor for make job, building type %s\n",
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
ENUM_KEY_STR(building_type, bld->getType()).c_str());
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
return df::unit_labor::NONE;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
jlfunc_make (df::unit_labor mt) : metaltype(mt) {}
};
Fix whitespace issues
2015-02-14 20:53:06 -07:00
class jlfunc_custom : public jlfunc
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
public:
df::unit_labor get_labor(df::job* j)
{
for (auto r = world->raws.reactions.begin(); r != world->raws.reactions.end(); r++)
{
if ((*r)->code == j->reaction_name)
{
df::job_skill skill = (*r)->skill;
df::unit_labor labor = ENUM_ATTR(job_skill, labor, skill);
return labor;
}
}
return df::unit_labor::NONE;
}
jlfunc_custom() {}
};
map<df::unit_labor, jlfunc*> jlf_cache;
jlfunc* jlf_const(df::unit_labor l) {
jlfunc* jlf;
if (jlf_cache.count(l) == 0)
{
jlf = new jlfunc_const(l);
jlf_cache[l] = jlf;
}
else
jlf = jlf_cache[l];
return jlf;
}
private:
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
std::map<df::job_type,jlfunc*> job_to_labor_table;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
public:
Fix whitespace issues
2015-02-14 20:53:06 -07:00
~JobLaborMapper()
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
std::set<jlfunc*> log;
autolabor: add archery targets, improve JobLaborMapper's destructor
2012-12-06 08:39:14 -07:00
for (auto i = jlf_cache.begin(); i != jlf_cache.end(); i++)
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
{
if (!log.count(i->second))
{
log.insert(i->second);
delete i->second;
}
i->second = 0;
}
FOR_ENUM_ITEMS (job_type, j)
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (j < 0)
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
continue;
autolabor: add archery targets, improve JobLaborMapper's destructor
2012-12-06 08:39:14 -07:00
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
jlfunc* p = job_to_labor_table[j];
if (!log.count(p))
{
log.insert(p);
delete p;
}
job_to_labor_table[j] = 0;
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
Fix whitespace issues
2015-02-14 20:53:06 -07:00
JobLaborMapper()
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
jlfunc* jlf_hauling = new jlfunc_hauling();
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
jlfunc* jlf_make_furniture = new jlfunc_make(df::unit_labor::FORGE_FURNITURE);
jlfunc* jlf_make_object = new jlfunc_make(df::unit_labor::METAL_CRAFT);
jlfunc* jlf_make_armor = new jlfunc_make(df::unit_labor::FORGE_ARMOR);
jlfunc* jlf_make_weapon = new jlfunc_make(df::unit_labor::FORGE_WEAPON);
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
jlfunc* jlf_no_labor = jlf_const(df::unit_labor::NONE);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CarveFortification] = jlf_const(df::unit_labor::DETAIL);
job_to_labor_table[df::job_type::DetailWall] = jlf_const(df::unit_labor::DETAIL);
job_to_labor_table[df::job_type::DetailFloor] = jlf_const(df::unit_labor::DETAIL);
job_to_labor_table[df::job_type::Dig] = jlf_const(df::unit_labor::MINE);
job_to_labor_table[df::job_type::CarveUpwardStaircase] = jlf_const(df::unit_labor::MINE);
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::CarveDownwardStaircase] = jlf_const(df::unit_labor::MINE);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CarveUpDownStaircase] = jlf_const(df::unit_labor::MINE);
job_to_labor_table[df::job_type::CarveRamp] = jlf_const(df::unit_labor::MINE);
job_to_labor_table[df::job_type::DigChannel] = jlf_const(df::unit_labor::MINE);
job_to_labor_table[df::job_type::FellTree] = jlf_const(df::unit_labor::CUTWOOD);
job_to_labor_table[df::job_type::GatherPlants] = jlf_const(df::unit_labor::HERBALIST);
labormanager: fix several job-to-labor mappings
2016-07-07 01:10:43 -06:00
job_to_labor_table[df::job_type::RemoveConstruction] = jlf_const(df::unit_labor::REMOVE_CONSTRUCTION);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CollectWebs] = jlf_const(df::unit_labor::WEAVER);
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
job_to_labor_table[df::job_type::BringItemToDepot] = jlf_const(df::unit_labor::HAUL_TRADE);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::BringItemToShop] = jlf_no_labor;
job_to_labor_table[df::job_type::Eat] = jlf_no_labor;
job_to_labor_table[df::job_type::GetProvisions] = jlf_no_labor;
job_to_labor_table[df::job_type::Drink] = jlf_no_labor;
job_to_labor_table[df::job_type::Drink2] = jlf_no_labor;
job_to_labor_table[df::job_type::FillWaterskin] = jlf_no_labor;
job_to_labor_table[df::job_type::FillWaterskin2] = jlf_no_labor;
job_to_labor_table[df::job_type::Sleep] = jlf_no_labor;
job_to_labor_table[df::job_type::CollectSand] = jlf_const(df::unit_labor::HAUL_ITEM);
job_to_labor_table[df::job_type::Fish] = jlf_const(df::unit_labor::FISH);
job_to_labor_table[df::job_type::Hunt] = jlf_const(df::unit_labor::HUNT);
job_to_labor_table[df::job_type::HuntVermin] = jlf_no_labor;
job_to_labor_table[df::job_type::Kidnap] = jlf_no_labor;
job_to_labor_table[df::job_type::BeatCriminal] = jlf_no_labor;
job_to_labor_table[df::job_type::StartingFistFight] = jlf_no_labor;
job_to_labor_table[df::job_type::CollectTaxes] = jlf_no_labor;
job_to_labor_table[df::job_type::GuardTaxCollector] = jlf_no_labor;
job_to_labor_table[df::job_type::CatchLiveLandAnimal] = jlf_const(df::unit_labor::HUNT);
job_to_labor_table[df::job_type::CatchLiveFish] = jlf_const(df::unit_labor::FISH);
job_to_labor_table[df::job_type::ReturnKill] = jlf_no_labor;
job_to_labor_table[df::job_type::CheckChest] = jlf_no_labor;
job_to_labor_table[df::job_type::StoreOwnedItem] = jlf_no_labor;
job_to_labor_table[df::job_type::PlaceItemInTomb] = jlf_const(df::unit_labor::HAUL_BODY);
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
job_to_labor_table[df::job_type::StoreItemInStockpile] = jlf_hauling;
job_to_labor_table[df::job_type::StoreItemInBag] = jlf_hauling;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::StoreItemInHospital] = jlf_hauling;
job_to_labor_table[df::job_type::StoreWeapon] = jlf_hauling;
job_to_labor_table[df::job_type::StoreArmor] = jlf_hauling;
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
job_to_labor_table[df::job_type::StoreItemInBarrel] = jlf_hauling;
job_to_labor_table[df::job_type::StoreItemInBin] = jlf_hauling;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::SeekArtifact] = jlf_no_labor;
job_to_labor_table[df::job_type::SeekInfant] = jlf_no_labor;
job_to_labor_table[df::job_type::AttendParty] = jlf_no_labor;
job_to_labor_table[df::job_type::GoShopping] = jlf_no_labor;
job_to_labor_table[df::job_type::GoShopping2] = jlf_no_labor;
job_to_labor_table[df::job_type::Clean] = jlf_const(df::unit_labor::CLEAN);
job_to_labor_table[df::job_type::Rest] = jlf_no_labor;
job_to_labor_table[df::job_type::PickupEquipment] = jlf_no_labor;
job_to_labor_table[df::job_type::DumpItem] = jlf_const(df::unit_labor::HAUL_REFUSE);
job_to_labor_table[df::job_type::StrangeMoodCrafter] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodJeweller] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodForge] = jlf_no_labor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::StrangeMoodMagmaForge] = jlf_no_labor;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::StrangeMoodBrooding] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodFell] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodCarpenter] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodMason] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodBowyer] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodTanner] = jlf_no_labor;
job_to_labor_table[df::job_type::StrangeMoodWeaver] = jlf_no_labor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::StrangeMoodGlassmaker] = jlf_no_labor;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::StrangeMoodMechanics] = jlf_no_labor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::ConstructBuilding] = new jlfunc_construct_bld();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::ConstructDoor] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructFloodgate] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructBed] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructThrone] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructCoffin] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructTable] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructChest] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructBin] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructArmorStand] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructWeaponRack] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructCabinet] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructStatue] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructBlocks] = jlf_make_furniture;
job_to_labor_table[df::job_type::MakeRawGlass] = jlf_const(df::unit_labor::GLASSMAKER);
job_to_labor_table[df::job_type::MakeCrafts] = jlf_make_object;
job_to_labor_table[df::job_type::MintCoins] = jlf_const(df::unit_labor::METAL_CRAFT);
job_to_labor_table[df::job_type::CutGems] = jlf_const(df::unit_labor::CUT_GEM);
job_to_labor_table[df::job_type::CutGlass] = jlf_const(df::unit_labor::CUT_GEM);
job_to_labor_table[df::job_type::EncrustWithGems] = jlf_const(df::unit_labor::ENCRUST_GEM);
job_to_labor_table[df::job_type::EncrustWithGlass] = jlf_const(df::unit_labor::ENCRUST_GEM);
job_to_labor_table[df::job_type::DestroyBuilding] = new jlfunc_destroy_bld();
job_to_labor_table[df::job_type::SmeltOre] = jlf_const(df::unit_labor::SMELT);
job_to_labor_table[df::job_type::MeltMetalObject] = jlf_const(df::unit_labor::SMELT);
job_to_labor_table[df::job_type::ExtractMetalStrands] = jlf_const(df::unit_labor::EXTRACT_STRAND);
job_to_labor_table[df::job_type::PlantSeeds] = jlf_const(df::unit_labor::PLANT);
job_to_labor_table[df::job_type::HarvestPlants] = jlf_const(df::unit_labor::PLANT);
job_to_labor_table[df::job_type::TrainHuntingAnimal] = jlf_const(df::unit_labor::ANIMALTRAIN);
job_to_labor_table[df::job_type::TrainWarAnimal] = jlf_const(df::unit_labor::ANIMALTRAIN);
job_to_labor_table[df::job_type::MakeWeapon] = jlf_make_weapon;
job_to_labor_table[df::job_type::ForgeAnvil] = jlf_make_furniture;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::ConstructCatapultParts] = jlf_const(df::unit_labor::SIEGECRAFT);
job_to_labor_table[df::job_type::ConstructBallistaParts] = jlf_const(df::unit_labor::SIEGECRAFT);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::MakeArmor] = jlf_make_armor;
job_to_labor_table[df::job_type::MakeHelm] = jlf_make_armor;
job_to_labor_table[df::job_type::MakePants] = jlf_make_armor;
job_to_labor_table[df::job_type::StudWith] = jlf_make_object;
job_to_labor_table[df::job_type::ButcherAnimal] = jlf_const(df::unit_labor::BUTCHER);
job_to_labor_table[df::job_type::PrepareRawFish] = jlf_const(df::unit_labor::CLEAN_FISH);
job_to_labor_table[df::job_type::MillPlants] = jlf_const(df::unit_labor::MILLER);
job_to_labor_table[df::job_type::BaitTrap] = jlf_const(df::unit_labor::TRAPPER);
job_to_labor_table[df::job_type::MilkCreature] = jlf_const(df::unit_labor::MILK);
job_to_labor_table[df::job_type::MakeCheese] = jlf_const(df::unit_labor::MAKE_CHEESE);
job_to_labor_table[df::job_type::ProcessPlants] = jlf_const(df::unit_labor::PROCESS_PLANT);
job_to_labor_table[df::job_type::ProcessPlantsVial] = jlf_const(df::unit_labor::PROCESS_PLANT);
job_to_labor_table[df::job_type::ProcessPlantsBarrel] = jlf_const(df::unit_labor::PROCESS_PLANT);
job_to_labor_table[df::job_type::PrepareMeal] = jlf_const(df::unit_labor::COOK);
job_to_labor_table[df::job_type::WeaveCloth] = jlf_const(df::unit_labor::WEAVER);
job_to_labor_table[df::job_type::MakeGloves] = jlf_make_armor;
job_to_labor_table[df::job_type::MakeShoes] = jlf_make_armor;
job_to_labor_table[df::job_type::MakeShield] = jlf_make_armor;
job_to_labor_table[df::job_type::MakeCage] = jlf_make_furniture;
job_to_labor_table[df::job_type::MakeChain] = jlf_make_object;
job_to_labor_table[df::job_type::MakeFlask] = jlf_make_object;
job_to_labor_table[df::job_type::MakeGoblet] = jlf_make_object;
job_to_labor_table[df::job_type::MakeToy] = jlf_make_object;
job_to_labor_table[df::job_type::MakeAnimalTrap] = jlf_const(df::unit_labor::TRAPPER);
job_to_labor_table[df::job_type::MakeBarrel] = jlf_make_furniture;
job_to_labor_table[df::job_type::MakeBucket] = jlf_make_furniture;
job_to_labor_table[df::job_type::MakeWindow] = jlf_make_furniture;
job_to_labor_table[df::job_type::MakeTotem] = jlf_const(df::unit_labor::BONE_CARVE);
job_to_labor_table[df::job_type::MakeAmmo] = jlf_make_weapon;
job_to_labor_table[df::job_type::DecorateWith] = jlf_make_object;
job_to_labor_table[df::job_type::MakeBackpack] = jlf_make_object;
job_to_labor_table[df::job_type::MakeQuiver] = jlf_make_armor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::MakeBallistaArrowHead] = jlf_make_weapon;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::AssembleSiegeAmmo] = jlf_const(df::unit_labor::SIEGECRAFT);
job_to_labor_table[df::job_type::LoadCatapult] = jlf_const(df::unit_labor::SIEGEOPERATE);
job_to_labor_table[df::job_type::LoadBallista] = jlf_const(df::unit_labor::SIEGEOPERATE);
job_to_labor_table[df::job_type::FireCatapult] = jlf_const(df::unit_labor::SIEGEOPERATE);
job_to_labor_table[df::job_type::FireBallista] = jlf_const(df::unit_labor::SIEGEOPERATE);
job_to_labor_table[df::job_type::ConstructMechanisms] = jlf_const(df::unit_labor::MECHANIC);
labormanager: trap components
2016-11-28 16:12:40 -07:00
job_to_labor_table[df::job_type::MakeTrapComponent] = jlf_make_weapon;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::LoadCageTrap] = jlf_const(df::unit_labor::MECHANIC) ;
job_to_labor_table[df::job_type::LoadStoneTrap] = jlf_const(df::unit_labor::MECHANIC) ;
job_to_labor_table[df::job_type::LoadWeaponTrap] = jlf_const(df::unit_labor::MECHANIC) ;
job_to_labor_table[df::job_type::CleanTrap] = jlf_const(df::unit_labor::MECHANIC) ;
job_to_labor_table[df::job_type::CastSpell] = jlf_no_labor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::LinkBuildingToTrigger] = jlf_const(df::unit_labor::MECHANIC) ;
labormanager: fix several job-to-labor mappings
2016-07-07 01:10:43 -06:00
job_to_labor_table[df::job_type::PullLever] = jlf_const(df::unit_labor::PULL_LEVER);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::ExtractFromPlants] = jlf_const(df::unit_labor::HERBALIST) ;
job_to_labor_table[df::job_type::ExtractFromRawFish] = jlf_const(df::unit_labor::DISSECT_FISH) ;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::ExtractFromLandAnimal] = jlf_const(df::unit_labor::DISSECT_VERMIN) ;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::TameVermin] = jlf_const(df::unit_labor::ANIMALTRAIN) ;
job_to_labor_table[df::job_type::TameAnimal] = jlf_const(df::unit_labor::ANIMALTRAIN) ;
labormanager: fix several job-to-labor mappings
2016-07-07 01:10:43 -06:00
job_to_labor_table[df::job_type::ChainAnimal] = jlf_const(df::unit_labor::HAUL_ANIMALS);
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
job_to_labor_table[df::job_type::UnchainAnimal] = jlf_const(df::unit_labor::HAUL_ANIMALS);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::UnchainPet] = jlf_no_labor;
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
job_to_labor_table[df::job_type::ReleaseLargeCreature] = jlf_const(df::unit_labor::HAUL_ANIMALS);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::ReleasePet] = jlf_no_labor;
job_to_labor_table[df::job_type::ReleaseSmallCreature] = jlf_no_labor;
job_to_labor_table[df::job_type::HandleSmallCreature] = jlf_no_labor;
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
job_to_labor_table[df::job_type::HandleLargeCreature] = jlf_const(df::unit_labor::HAUL_ANIMALS);
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
job_to_labor_table[df::job_type::CageLargeCreature] = jlf_const(df::unit_labor::HAUL_ANIMALS);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CageSmallCreature] = jlf_no_labor;
job_to_labor_table[df::job_type::RecoverWounded] = jlf_const(df::unit_labor::RECOVER_WOUNDED);
job_to_labor_table[df::job_type::DiagnosePatient] = jlf_const(df::unit_labor::DIAGNOSE) ;
job_to_labor_table[df::job_type::ImmobilizeBreak] = jlf_const(df::unit_labor::BONE_SETTING) ;
job_to_labor_table[df::job_type::DressWound] = jlf_const(df::unit_labor::DRESSING_WOUNDS) ;
job_to_labor_table[df::job_type::CleanPatient] = jlf_const(df::unit_labor::DRESSING_WOUNDS) ;
job_to_labor_table[df::job_type::Surgery] = jlf_const(df::unit_labor::SURGERY) ;
job_to_labor_table[df::job_type::Suture] = jlf_const(df::unit_labor::SUTURING);
job_to_labor_table[df::job_type::SetBone] = jlf_const(df::unit_labor::BONE_SETTING) ;
job_to_labor_table[df::job_type::PlaceInTraction] = jlf_const(df::unit_labor::BONE_SETTING) ;
job_to_labor_table[df::job_type::DrainAquarium] = jlf_no_labor;
job_to_labor_table[df::job_type::FillAquarium] = jlf_no_labor;
job_to_labor_table[df::job_type::FillPond] = jlf_no_labor;
job_to_labor_table[df::job_type::GiveWater] = jlf_const(df::unit_labor::FEED_WATER_CIVILIANS) ;
job_to_labor_table[df::job_type::GiveFood] = jlf_const(df::unit_labor::FEED_WATER_CIVILIANS) ;
job_to_labor_table[df::job_type::GiveWater2] = jlf_no_labor;
job_to_labor_table[df::job_type::GiveFood2] = jlf_no_labor;
job_to_labor_table[df::job_type::RecoverPet] = jlf_no_labor;
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
job_to_labor_table[df::job_type::PitLargeAnimal] = jlf_const(df::unit_labor::HAUL_ANIMALS);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::PitSmallAnimal] = jlf_no_labor;
job_to_labor_table[df::job_type::SlaughterAnimal] = jlf_const(df::unit_labor::BUTCHER);
job_to_labor_table[df::job_type::MakeCharcoal] = jlf_const(df::unit_labor::BURN_WOOD);
job_to_labor_table[df::job_type::MakeAsh] = jlf_const(df::unit_labor::BURN_WOOD);
job_to_labor_table[df::job_type::MakeLye] = jlf_const(df::unit_labor::LYE_MAKING);
job_to_labor_table[df::job_type::MakePotashFromLye] = jlf_const(df::unit_labor::POTASH_MAKING);
job_to_labor_table[df::job_type::FertilizeField] = jlf_const(df::unit_labor::PLANT);
job_to_labor_table[df::job_type::MakePotashFromAsh] = jlf_const(df::unit_labor::POTASH_MAKING);
job_to_labor_table[df::job_type::DyeThread] = jlf_const(df::unit_labor::DYER);
job_to_labor_table[df::job_type::DyeCloth] = jlf_const(df::unit_labor::DYER);
job_to_labor_table[df::job_type::SewImage] = jlf_make_object;
job_to_labor_table[df::job_type::MakePipeSection] = jlf_make_furniture;
job_to_labor_table[df::job_type::OperatePump] = jlf_const(df::unit_labor::OPERATE_PUMP);
job_to_labor_table[df::job_type::ManageWorkOrders] = jlf_no_labor;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::UpdateStockpileRecords] = jlf_no_labor;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::TradeAtDepot] = jlf_no_labor;
job_to_labor_table[df::job_type::ConstructHatchCover] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructGrate] = jlf_make_furniture;
job_to_labor_table[df::job_type::RemoveStairs] = jlf_const(df::unit_labor::MINE);
job_to_labor_table[df::job_type::ConstructQuern] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructMillstone] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructSplint] = jlf_make_furniture;
job_to_labor_table[df::job_type::ConstructCrutch] = jlf_make_furniture;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::ConstructTractionBench] = jlf_const(df::unit_labor::MECHANIC);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CleanSelf] = jlf_no_labor;
job_to_labor_table[df::job_type::BringCrutch] = jlf_const(df::unit_labor::BONE_SETTING);
job_to_labor_table[df::job_type::ApplyCast] = jlf_const(df::unit_labor::BONE_SETTING);
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
job_to_labor_table[df::job_type::CustomReaction] = new jlfunc_custom();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::ConstructSlab] = jlf_make_furniture;
job_to_labor_table[df::job_type::EngraveSlab] = jlf_const(df::unit_labor::DETAIL);
job_to_labor_table[df::job_type::ShearCreature] = jlf_const(df::unit_labor::SHEARER);
job_to_labor_table[df::job_type::SpinThread] = jlf_const(df::unit_labor::SPINNER);
labormanager: fix several job-to-labor mappings
2016-07-07 01:10:43 -06:00
job_to_labor_table[df::job_type::PenLargeAnimal] = jlf_const(df::unit_labor::HAUL_ANIMALS);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::PenSmallAnimal] = jlf_no_labor;
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
job_to_labor_table[df::job_type::MakeTool] = jlf_make_object;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
job_to_labor_table[df::job_type::CollectClay] = jlf_const(df::unit_labor::POTTERY);
job_to_labor_table[df::job_type::InstallColonyInHive] = jlf_const(df::unit_labor::BEEKEEPING);
job_to_labor_table[df::job_type::CollectHiveProducts] = jlf_const(df::unit_labor::BEEKEEPING);
job_to_labor_table[df::job_type::CauseTrouble] = jlf_no_labor;
job_to_labor_table[df::job_type::DrinkBlood] = jlf_no_labor;
job_to_labor_table[df::job_type::ReportCrime] = jlf_no_labor;
job_to_labor_table[df::job_type::ExecuteCriminal] = jlf_no_labor;
job_to_labor_table[df::job_type::TrainAnimal] = jlf_const(df::unit_labor::ANIMALTRAIN);
job_to_labor_table[df::job_type::CarveTrack] = jlf_const(df::unit_labor::DETAIL);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
job_to_labor_table[df::job_type::PushTrackVehicle] = jlf_const(df::unit_labor::HANDLE_VEHICLES);
job_to_labor_table[df::job_type::PlaceTrackVehicle] = jlf_const(df::unit_labor::HANDLE_VEHICLES);
job_to_labor_table[df::job_type::StoreItemInVehicle] = jlf_const(df::unit_labor::HANDLE_VEHICLES);
add new jobs to autolabor
2016-02-22 10:40:52 -07:00
job_to_labor_table[df::job_type::GeldAnimal] = jlf_const(df::unit_labor::GELD);
job_to_labor_table[df::job_type::MakeFigurine] = jlf_make_object;
job_to_labor_table[df::job_type::MakeAmulet] = jlf_make_object;
job_to_labor_table[df::job_type::MakeScepter] = jlf_make_object;
job_to_labor_table[df::job_type::MakeCrown] = jlf_make_object;
job_to_labor_table[df::job_type::MakeRing] = jlf_make_object;
job_to_labor_table[df::job_type::MakeEarring] = jlf_make_object;
job_to_labor_table[df::job_type::MakeBracelet] = jlf_make_object;
job_to_labor_table[df::job_type::MakeGem] = jlf_make_object;
labormanager: add StoreItemInLocation labor, reduce tool churn Note: this commit requires updated df-structures (77968973b28d0e828f880d119a700abb079f3521 or later)
2016-07-05 12:16:34 -06:00
job_to_labor_table[df::job_type::StoreItemInLocation] = jlf_no_labor; // StoreItemInLocation
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
};
df::unit_labor find_job_labor(df::job* j)
{
if (j->job_type == df::job_type::CustomReaction)
{
for (auto r = world->raws.reactions.begin(); r != world->raws.reactions.end(); r++)
{
if ((*r)->code == j->reaction_name)
{
df::job_skill skill = (*r)->skill;
return ENUM_ATTR(job_skill, labor, skill);
}
}
return df::unit_labor::NONE;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
df::unit_labor labor;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (job_to_labor_table.count(j->job_type) == 0)
{
labormanager: add StoreItemInLocation labor, reduce tool churn Note: this commit requires updated df-structures (77968973b28d0e828f880d119a700abb079f3521 or later)
2016-07-05 12:16:34 -06:00
debug("LABORMANAGER: job has no job to labor table entry: %s (%d)\n", ENUM_KEY_STR(job_type, j->job_type).c_str(), j->job_type);
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labor = df::unit_labor::NONE;
} else {
labor = job_to_labor_table[j->job_type]->get_labor(j);
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
return labor;
}
};
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
/* End of labor deducer */
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
static JobLaborMapper* labor_mapper = 0;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
static bool initialized = false;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
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()
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
enable_labormanager = false;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
labor_infos.clear();
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
initialized = false;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
static void reset_labor(df::unit_labor labor)
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
labor_infos[labor].set_priority(default_labor_infos[labor].priority);
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
labor_infos[labor].set_maximum_dwarfs(default_labor_infos[labor].maximum_dwarfs);
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
static void init_state()
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
config = World::GetPersistentData("labormanager/2.0/config");
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
if (config.isValid() && config.ival(0) == -1)
config.ival(0) = 0;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
enable_labormanager = isOptionEnabled(CF_ENABLED);
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
return;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
// Load labors from save
labor_infos.resize(ARRAY_COUNT(default_labor_infos));
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
std::vector<PersistentDataItem> items;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
World::GetPersistentData(&items, "labormanager/2.0/labors/", true);
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
for (auto p = items.begin(); p != items.end(); p++)
{
string key = p->key();
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
df::unit_labor labor = (df::unit_labor) atoi(key.substr(strlen("labormanager/2.0/labors/")).c_str());
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
if (labor >= 0 && labor <= labor_infos.size())
{
labor_infos[labor].config = *p;
labor_infos[labor].active_dwarfs = 0;
}
}
// Add default labors for those not in save
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
for (int i = 0; i < ARRAY_COUNT(default_labor_infos); i++) {
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
if (labor_infos[i].config.isValid())
continue;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
std::stringstream name;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
name << "labormanager/2.0/labors/" << i;
Better config persistence.
2012-04-05 21:34:06 -06:00
Dissolve the World module class into a namespace. It made accessing persistent data way too cumbersome.
2012-10-06 03:46:20 -06:00
labor_infos[i].config = World::AddPersistentData(name.str());
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
labor_infos[i].mark_assigned();
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
labor_infos[i].active_dwarfs = 0;
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
reset_labor((df::unit_labor) i);
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
initialized = true;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
static df::job_skill labor_to_skill[ENUM_LAST_ITEM(unit_labor) + 1];
static void generate_labor_to_skill_map()
{
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
// Generate labor -> skill mapping
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
for (int i = 0; i <= ENUM_LAST_ITEM(unit_labor); i++)
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
labor_to_skill[i] = job_skill::NONE;
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
FOR_ENUM_ITEMS(job_skill, skill)
{
int labor = ENUM_ATTR(job_skill, labor, skill);
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
if (labor != unit_labor::NONE)
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
{
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
/*
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
assert(labor >= 0);
assert(labor < ARRAY_COUNT(labor_to_skill));
*/
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
labor_to_skill[labor] = skill;
}
}
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
struct skill_attr_weight {
int phys_attr_weights [6];
int mental_attr_weights [13];
};
static struct skill_attr_weight skill_attr_weights[ENUM_LAST_ITEM(job_skill) + 1] =
{
// S A T E R D AA F W C I P M LA SS M KS E SA
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* MINING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WOODCUTTING */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CARPENTRY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DETAILSTONE */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MASONRY */,
{ { 0, 1, 1, 1, 0, 0 }, { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0 } } /* ANIMALTRAIN */,
{ { 0, 1, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0 } } /* ANIMALCARE */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DISSECT_FISH */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DISSECT_VERMIN */,
{ { 0, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PROCESSFISH */,
{ { 0, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BUTCHER */,
{ { 0, 1, 0, 0, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* TRAPPING */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* TANNER */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WEAVING */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BREWING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* ALCHEMY */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* CLOTHESMAKING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MILLING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PROCESSPLANTS */,
{ { 1, 1, 0, 1, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CHEESEMAKING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MILK */,
{ { 0, 1, 0, 0, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* COOK */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PLANT */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 } } /* HERBALISM */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 } } /* FISH */,
{ { 1, 0, 1, 1, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SMELT */,
{ { 1, 1, 0, 1, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* EXTRACT_STRAND */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* FORGE_WEAPON */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* FORGE_ARMOR */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* FORGE_FURNITURE */,
{ { 0, 1, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CUTGEM */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* ENCRUSTGEM */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WOODCRAFT */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* STONECRAFT */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* METALCRAFT */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* GLASSMAKER */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* LEATHERWORK */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* BONECARVE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* AXE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SWORD */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* DAGGER */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* MACE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* HAMMER */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SPEAR */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* CROSSBOW */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SHIELD */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* ARMOR */,
{ { 1, 1, 0, 1, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SIEGECRAFT */,
{ { 1, 0, 1, 1, 0, 0 }, { 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SIEGEOPERATE */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BOWYER */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* PIKE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WHIP */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* BOW */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* BLOWGUN */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* THROW */,
{ { 1, 1, 0, 1, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MECHANICS */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MAGIC_NATURE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SNEAK */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* DESIGNBUILDING */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0 } } /* DRESS_WOUNDS */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 } } /* DIAGNOSE */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SURGERY */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SET_BONE */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SUTURE */,
{ { 0, 1, 0, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* CRUTCH_WALK */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* WOOD_BURNING */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* LYE_MAKING */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SOAP_MAKING */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* POTASH_MAKING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DYER */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* OPERATE_PUMP */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SWIMMING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* PERSUASION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* NEGOTIATION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1 } } /* JUDGING_INTENT */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 } } /* APPRAISAL */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 } } /* ORGANIZATION */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 } } /* RECORD_KEEPING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } /* LYING */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 } } /* INTIMIDATION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* CONVERSATION */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 } } /* COMEDY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* FLATTERY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 } } /* CONSOLE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* PACIFY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* TRACKING */,
{ { 0, 1, 0, 0, 0, 0 }, { 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 } } /* KNOWLEDGE_ACQUISITION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 } } /* CONCENTRATION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DISCIPLINE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SITUATIONAL_AWARENESS */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* WRITING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PROSE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* POETRY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* READING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SPEAKING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* COORDINATION */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BALANCE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* LEADERSHIP */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 } } /* TEACHING */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* MELEE_COMBAT */,
{ { 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* RANGED_COMBAT */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WRESTLING */,
{ { 1, 0, 1, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* BITE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* GRASP_STRIKE */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* STANCE_STRIKE */,
{ { 0, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* DODGING */,
{ { 1, 1, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* MISC_WEAPON */,
{ { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* KNAPPING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MILITARY_TACTICS */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SHEARING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* SPINNING */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* POTTERY */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* GLAZING */,
{ { 1, 1, 0, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PRESSING */,
{ { 1, 1, 0, 1, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BEEKEEPING */,
{ { 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 } } /* WAX_WORKING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CLIMBING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* GELD */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* DANCE */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MAKE_MUSIC */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* SING_MUSIC */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PLAY_KEYBOARD_INSTRUMENT */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PLAY_STRINGED_INSTRUMENT */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PLAY_WIND_INSTRUMENT */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PLAY_PERCUSSION_INSTRUMENT */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CRITICAL_THINKING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* LOGIC */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* MATHEMATICS */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* ASTRONOMY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* CHEMISTRY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* GEOGRAPHY */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* OPTICS_ENGINEER */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* FLUID_ENGINEER */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* PAPERMAKING */,
{ { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } /* BOOKBINDING */
};
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
static void enable_plugin(color_ostream &out)
{
if (!config.isValid())
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
config = World::AddPersistentData("labormanager/2.0/config");
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
config.ival(0) = 0;
}
setOptionEnabled(CF_ENABLED, true);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
enable_labormanager = true;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
out << "Enabling the plugin." << endl;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
cleanup_state();
init_state();
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
}
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
{
More fixes Include unistd.h in linux process file Fix assert in autolabor Don't print 'script missing' error on DF start
2012-03-28 18:49:44 -06:00
// initialize labor infos table from default table
if(ARRAY_COUNT(default_labor_infos) != ENUM_LAST_ITEM(unit_labor) + 1)
return CR_FAILURE;
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
More fixes Include unistd.h in linux process file Fix assert in autolabor Don't print 'script missing' error on DF start
2012-03-28 18:49:44 -06:00
// Fill the command list with your commands.
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
commands.push_back(PluginCommand(
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
"labormanager", "Automatically manage dwarf labors.",
labormanager, false, /* true means that the command can't be used from non-interactive user interface */
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
// Extended help string. Used by CR_WRONG_USAGE and the help command:
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager enable\n"
" labormanager disable\n"
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
" Enables or disables the plugin.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager max <labor> <maximum>\n"
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
" Set max number of dwarves assigned to a labor.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager max <labor> none\n"
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
" Unrestrict the number of dwarves assigned to a labor.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager priority <labor> <priority>\n"
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
" Change the assignment priority of a labor (default is 100)\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager reset <labor>\n"
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
" Return a labor to the default handling.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager reset-all\n"
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
" Return all labors to the default handling.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager list\n"
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
" List current status of all labors.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" labormanager status\n"
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
" Show basic status information.\n"
"Function:\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" When enabled, labormanager periodically checks your dwarves and enables or\n"
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
" disables labors. Generally, each dwarf will be assigned exactly one labor.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" Warning: labormanager will override any manual changes you make to labors\n"
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
" while it is enabled. Do not try to run both autolabor and labormanager at\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
" the same time.\n"
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
));
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
generate_labor_to_skill_map();
labor_mapper = new JobLaborMapper();
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
init_state();
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
return CR_OK;
}
DFhackCExport command_result plugin_shutdown ( color_ostream &out )
{
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
cleanup_state();
Make autolabor accept "enable" and "disable" as well as "0" or "1". Add ability to set target number of miners in autolabor with "autolabor miners".
2012-03-28 09:25:36 -06:00
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
delete labor_mapper;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
return CR_OK;
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
class AutoLaborManager {
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
color_ostream& out;
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
public:
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
AutoLaborManager(color_ostream& o) : out(o)
{
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
dwarf_info.clear();
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
~AutoLaborManager()
{
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
for (auto d = dwarf_info.begin(); d != dwarf_info.end(); d++)
{
delete (*d);
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
dwarf_info_t* add_dwarf(df::unit* u)
{
dwarf_info_t* dwarf = new dwarf_info_t(u);
dwarf_info.push_back(dwarf);
return dwarf;
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
private:
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
bool has_butchers;
bool has_fishery;
bool trader_requested;
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
int dig_count;
int tree_count;
int plant_count;
int detail_count;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
bool labors_changed;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
int tool_count[TOOLS_MAX];
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
int tool_in_use[TOOLS_MAX];
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
int cnt_recover_wounded;
int cnt_diagnosis;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
int cnt_immobilize;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
int cnt_dressing;
int cnt_cleaning;
int cnt_surgery;
int cnt_suture;
int cnt_setting;
int cnt_traction;
int cnt_crutch;
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
int need_food_water;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
int priority_food;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
std::map<df::unit_labor, int> labor_needed;
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
std::map<df::unit_labor, int> labor_in_use;
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
std::map<df::unit_labor, bool> labor_outside;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
std::vector<dwarf_info_t*> dwarf_info;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
std::list<dwarf_info_t*> available_dwarfs;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
std::list<dwarf_info_t*> busy_dwarfs;
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
private:
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
void set_labor (dwarf_info_t* dwarf, df::unit_labor labor, bool value)
{
if (labor >= 0 && labor <= ENUM_LAST_ITEM(unit_labor))
{
bool old = dwarf->dwarf->status.labors[labor];
dwarf->dwarf->status.labors[labor] = value;
if (old != value)
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
{
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
labors_changed = true;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
tools_enum tool = default_labor_infos[labor].tool;
if (tool != TOOL_NONE)
tool_in_use[tool] += value ? 1 : -1;
}
}
}
void process_job (df::job* j)
{
if (j->flags.bits.suspend || j->flags.bits.item_lost)
return;
int worker = -1;
int bld = -1;
for (int r = 0; r < j->general_refs.size(); ++r)
{
if (j->general_refs[r]->getType() == df::general_ref_type::UNIT_WORKER)
worker = ((df::general_ref_unit_workerst *)(j->general_refs[r]))->unit_id;
if (j->general_refs[r]->getType() == df::general_ref_type::BUILDING_HOLDER)
bld = ((df::general_ref_building_holderst *)(j->general_refs[r]))->building_id;
}
if (bld != -1)
{
df::building* b = binsearch_in_vector(world->buildings.all, bld);
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
// check if this job is the first nonsuspended job on this building; if not, ignore it
// (except for farms and trade depots)
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (b->getType() != df::building_type::FarmPlot &&
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
b->getType() != df::building_type::TradeDepot)
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
{
int fjid = -1;
for (int jn = 0; jn < b->jobs.size(); jn++)
{
if (b->jobs[jn]->flags.bits.suspend)
continue;
fjid = b->jobs[jn]->id;
break;
}
if (fjid != j->id)
return;
}
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
}
df::unit_labor labor = labor_mapper->find_job_labor (j);
if (labor != df::unit_labor::NONE)
{
labor_needed[labor]++;
if (worker == -1)
{
if (j->pos.isValid())
{
df::tile_designation* d = Maps::getTileDesignation(j->pos);
if (d->bits.outside)
labor_outside[labor] = true;
}
} else {
labor_infos[labor].mark_assigned();
labor_in_use[labor]++;
}
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
}
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
void scan_buildings()
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
has_butchers = false;
has_fishery = false;
trader_requested = false;
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
labors_changed = false;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
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;
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
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");
}
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
}
}
void count_map_designations()
{
dig_count = 0;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
tree_count = 0;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
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;
for (int x = 0; x < 16; x++)
for (int y = 0; y < 16; y++)
{
Autolabor: do not count designations in hidden squares (since your dwarves can't reach them anyway). Also apply an assignment penalty for assigning a dwarf to a labor other than the one the dwarf is doing
2012-12-12 09:37:09 -07:00
if (bl->designation[x][y].bits.hidden)
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
{
df::coord p = bl->map_pos;
df::coord c(p.x, p.y, p.z-1);
if (Maps::getTileDesignation(c)->bits.hidden)
continue;
}
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
df::tile_dig_designation dig = bl->designation[x][y].bits.dig;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dig != df::enums::tile_dig_designation::No)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
{
df::tiletype tt = bl->tiletype[x][y];
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
df::tiletype_material ttm = ENUM_ATTR(tiletype, material, tt);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
df::tiletype_shape tts = ENUM_ATTR(tiletype, shape, tt);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (ttm == df::enums::tiletype_material::TREE)
tree_count++;
else if (tts == df::enums::tiletype_shape::SHRUB)
plant_count++;
else
dig_count++;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
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()
{
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
for (int e = TOOL_NONE; e < TOOLS_MAX; e++)
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
{
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
tool_count[e] = 0;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
tool_in_use[e] = 0;
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
priority_food = 0;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
df::item_flags bad_flags;
bad_flags.whole = 0;
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
#define F(x) bad_flags.bits.x = true;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
F(dump); F(forbid); F(garbage_collect);
F(hostile); F(on_fire); F(rotten); F(trader);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
F(in_building); F(construction);
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
#undef F
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Autolabor: Items marked for dump now generate haul refuse demand. Also corrected labor for dump item jobs.
2012-12-04 00:59:44 -07:00
auto& v = world->items.all;
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
for (auto i = v.begin(); i != v.end(); i++)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
df::item* item = *i;
Autolabor: Items marked for dump now generate haul refuse demand. Also corrected labor for dump item jobs.
2012-12-04 00:59:44 -07:00
if (item->flags.bits.dump)
labor_needed[df::unit_labor::HAUL_REFUSE]++;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
if (item->flags.whole & bad_flags.whole)
continue;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
df::item_type t = item->getType();
if (item->materialRots() && t != df::item_type::CORPSEPIECE && t != df::item_type::CORPSE && item->getRotTimer() > 1)
priority_food++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (!item->isWeapon())
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
continue;
df::itemdef_weaponst* weapondef = ((df::item_weaponst*)item)->subtype;
df::job_skill weaponsk = (df::job_skill) weapondef->skill_melee;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
df::job_skill weaponsk2 = (df::job_skill) weapondef->skill_ranged;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
if (weaponsk == df::job_skill::AXE)
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
tool_count[TOOL_AXE]++;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
else if (weaponsk == df::job_skill::MINING)
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
tool_count[TOOL_PICK]++;
else if (weaponsk2 = df::job_skill::CROSSBOW)
tool_count[TOOL_CROSSBOW]++;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
void collect_job_list()
{
for (df::job_list_link* jll = world->job_list.next; jll; jll = jll->next)
{
df::job* j = jll->item;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (!j)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
continue;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
process_job(j);
}
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
for (auto jp = world->job_postings.begin(); jp != world->job_postings.end(); jp++)
{
if ((*jp)->flags.bits.dead)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
continue;
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
process_job((*jp)->job);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
void collect_dwarf_list()
{
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
for (auto u = world->units.active.begin(); u != world->units.active.end(); ++u)
{
df::unit* cre = *u;
if (Units::isCitizen(cre))
{
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;
Update structures and fix broken things.
2014-04-04 12:34:39 -06:00
bool p1 = act->unit_actor == dwarf->dwarf;
bool p2 = act->unit_noble == dwarf->dwarf;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
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;
}
}
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
// check to see if dwarf has minor children
for (auto u2 = world->units.active.begin(); u2 != world->units.active.end(); ++u2)
{
Update labormanager for unit.relations removal and fix warnings
2016-08-11 21:42:58 -06:00
if ((*u2)->relationship_ids[df::unit_relationship_type::Mother] == dwarf->dwarf->id &&
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
!(*u2)->flags1.bits.dead &&
((*u2)->profession == df::profession::CHILD || (*u2)->profession == df::profession::BABY))
{
dwarf->has_children = true;
if (print_debug)
out.print("Dwarf %s has minor children\n", dwarf->dwarf->name.first_name.c_str());
break;
}
}
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
// 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())
{
dwarf->armed = true;
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_tool[TOOL_AXE] = true;
}
else if (weaponsk == df::job_skill::MINING)
{
dwarf->has_tool[TOOL_PICK] = true;
}
else if (rangesk == df::job_skill::CROSSBOW)
{
dwarf->has_tool[TOOL_CROSSBOW] = true;
}
}
}
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
// Find the activity state for each dwarf
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
bool is_migrant = false;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
dwarf_state state = OTHER;
for (auto p = dwarf->dwarf->status.misc_traits.begin(); p < dwarf->dwarf->status.misc_traits.end(); p++)
{
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
if ((*p)->id == misc_trait_type::Migrant)
is_migrant = true;
}
if (dwarf->dwarf->social_activities.size() > 0)
{
if (print_debug)
out.print ("Dwarf %s is engaged in a social activity. Info only.\n", dwarf->dwarf->name.first_name.c_str());
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
if (dwarf->dwarf->profession == profession::BABY ||
dwarf->dwarf->profession == profession::CHILD ||
dwarf->dwarf->profession == profession::DRUNK)
{
state = CHILD;
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
Autolabor: add construct chain labor, add destruct trap labor, change overbroad test for military status (was catching uniformed reservists, who are eligible to do civilian labor)
2012-12-12 21:25:23 -07:00
else if (ENUM_ATTR(profession, military, dwarf->dwarf->profession))
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
state = MILITARY;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
else if (dwarf->dwarf->burrows.size() > 0)
state = OTHER; // dwarfs assigned to burrows are treated as if permanently busy
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
else if (dwarf->dwarf->job.current_job == NULL)
{
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
if (is_migrant || dwarf->dwarf->flags1.bits.chained || dwarf->dwarf->flags1.bits.caged)
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
{
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
state = OTHER;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
dwarf->clear_all = true;
}
Correct autolabor2 for changes in structures.
2013-02-13 15:00:09 -07:00
else if (dwarf->dwarf->status2.limbs_grasp_count == 0)
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
state = OTHER; // dwarfs unable to grasp are incapable of nearly all labors
dwarf->clear_all = true;
Autolabor: fix unitialized variable bug causing broker to be inappropriately excluded from work
2012-12-08 20:14:23 -07:00
if (print_debug)
out.print ("Dwarf %s is disabled, will not be assigned labors\n", dwarf->dwarf->name.first_name.c_str());
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
else
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
{
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
state = IDLE;
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
else
{
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
df::job_type job = dwarf->dwarf->job.current_job->job_type;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
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);
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
debug_pause();
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
state = OTHER;
}
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
if (state == BUSY)
{
df::unit_labor labor = labor_mapper->find_job_labor(dwarf->dwarf->job.current_job);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
dwarf->using_labor = labor;
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
if (labor != df::unit_labor::NONE)
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labor_infos[labor].busy_dwarfs++;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
if (default_labor_infos[labor].tool != TOOL_NONE)
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
{
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
tool_in_use[default_labor_infos[labor].tool]++;
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
}
}
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
dwarf->state = state;
Autolabor: adjust idle clawback to deal with "pickup equipment" for miners.
2013-01-01 16:53:24 -07:00
FOR_ENUM_ITEMS(unit_labor, l)
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (l == df::unit_labor::NONE)
Autolabor: adjust idle clawback to deal with "pickup equipment" for miners.
2013-01-01 16:53:24 -07:00
continue;
if (dwarf->dwarf->status.labors[l])
if (state == IDLE)
labor_infos[l].idle_dwarfs++;
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
if (print_debug)
Autolabor: fix unitialized variable bug causing broker to be inappropriately excluded from work
2012-12-08 20:14:23 -07:00
out.print("Dwarf \"%s\": state %s %d\n", dwarf->dwarf->name.first_name.c_str(), state_names[dwarf->state], dwarf->clear_all);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
// determine if dwarf has medical needs
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
// babies cannot currently receive health care even if they need it
if (dwarf->dwarf->profession != profession::BABY && dwarf->dwarf->health)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.needs_recovery)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_recover_wounded++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_diagnosis)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_diagnosis++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_immobilize)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_immobilize++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_dressing)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_dressing++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_cleaning)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_cleaning++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_surgery)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_surgery++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_suture)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_suture++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_setting)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_setting++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_traction)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_traction++;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->dwarf->health->flags.bits.rq_crutch)
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_crutch++;
}
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
if (dwarf->dwarf->counters2.hunger_timer > 60000 || dwarf->dwarf->counters2.thirst_timer > 40000)
need_food_water++;
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
// find dwarf's highest effective skill
int high_skill = 0;
Autolabor: only care about skills that are used for labors, when determining a dwarf's highest skill.
2012-12-07 14:41:39 -07:00
FOR_ENUM_ITEMS (unit_labor, labor)
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
if (labor == df::unit_labor::NONE)
continue;
Autolabor: only care about skills that are used for labors, when determining a dwarf's highest skill.
2012-12-07 14:41:39 -07:00
df::job_skill skill = labor_to_skill[labor];
if (skill != df::job_skill::NONE)
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
int skill_level = Units::getNominalSkill(dwarf->dwarf, skill, false);
Autolabor: only care about skills that are used for labors, when determining a dwarf's highest skill.
2012-12-07 14:41:39 -07:00
high_skill = std::max(high_skill, skill_level);
}
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
}
dwarf->high_skill = high_skill;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
// clear labors of dwarfs with clear_all set
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (dwarf->clear_all)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
{
FOR_ENUM_ITEMS(unit_labor, labor)
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (labor == unit_labor::NONE)
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
continue;
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(dwarf, labor, false);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
} else {
if (state == IDLE)
available_dwarfs.push_back(dwarf);
if (state == BUSY)
busy_dwarfs.push_back(dwarf);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
}
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
void release_dwarf_list()
{
while (!dwarf_info.empty()) {
auto d = dwarf_info.begin();
delete *d;
dwarf_info.erase(d);
}
available_dwarfs.clear();
busy_dwarfs.clear();
}
int score_labor (dwarf_info_t* d, df::unit_labor labor)
{
int skill_level = 0;
int xp = 0;
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
int attr_weight = 0;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (labor != df::unit_labor::NONE)
{
df::job_skill skill = labor_to_skill[labor];
if (skill != df::job_skill::NONE)
{
skill_level = Units::getEffectiveSkill(d->dwarf, skill);
xp = Units::getExperience(d->dwarf, skill, false);
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
for (int pa = 0; pa < 6; pa++)
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
attr_weight += (skill_attr_weights[skill].phys_attr_weights[pa]) * (d->dwarf->body.physical_attrs[pa].value - 1000);
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
for (int ma = 0; ma < 13; ma++)
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
attr_weight += (skill_attr_weights[skill].mental_attr_weights[ma]) * (d->dwarf->status.current_soul->mental_attrs[ma].value - 1000);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
int score = skill_level * 1000 - (d->high_skill - skill_level) * 2000 + (xp / (skill_level + 5) * 10) + attr_weight;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (labor != df::unit_labor::NONE)
{
if (d->dwarf->status.labors[labor])
if (labor == df::unit_labor::OPERATE_PUMP)
score += 50000;
else
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
score += 25000;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (default_labor_infos[labor].tool != TOOL_NONE &&
d->has_tool[default_labor_infos[labor].tool])
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
score += 10000000;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (d->has_children && labor_outside[labor])
score -= 15000;
if (d->armed && labor_outside[labor])
score += 5000;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
Use attributes in calculating assignment weight
2016-11-26 16:37:26 -07:00
score -= Units::computeMovementSpeed(d->dwarf);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
return score;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
public:
void process()
{
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
if (*df::global::process_dig || *df::global::process_jobs)
return;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
release_dwarf_list();
Autolabor: track labors actually being used (to avoid "gone fishing" bug); fix several wrong labor map entries; add several special cases for hauling (still not all there yet); add debug warning if job deduction appears wrong; flail about mightily trying to resolve heap corruption on unload
2012-12-08 01:42:22 -07:00
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
dig_count = tree_count = plant_count = detail_count = 0;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
cnt_recover_wounded = cnt_diagnosis = cnt_immobilize = cnt_dressing = cnt_cleaning = cnt_surgery = cnt_suture =
cnt_setting = cnt_traction = cnt_crutch = 0;
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
need_food_water = 0;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
labor_needed.clear();
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
for (int e = 0; e < TOOLS_MAX; e++)
tool_count[e] = 0;
Autolabor: fix unitialized variable bug causing broker to be inappropriately excluded from work
2012-12-08 20:14:23 -07:00
trader_requested = false;
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
FOR_ENUM_ITEMS(unit_labor, l)
{
if (l == df::unit_labor::NONE)
continue;
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
labor_infos[l].active_dwarfs = labor_infos[l].busy_dwarfs = labor_infos[l].idle_dwarfs = 0;
Autolabor: add labors for construct bridge, construct nestbox, construct trap, deconstruct wagon; fix error in labor for deconstruct furnace/tradedepot/construction; actually update the "active dwarf" numbers displayed in "autolabor list"; increase assignment penalty for dwarfs using skills lower than their best skill; increase assignment bonus for continuing in the same labor and for having the right tool for the job.
2012-12-03 00:41:02 -07:00
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
// scan for specific buildings of interest
scan_buildings();
// count number of squares designated for dig, wood cutting, detailing, and plant harvesting
count_map_designations();
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
// collect current job list
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
collect_job_list();
Assorted progress on new autolabor. Still lots of issues.
2012-11-30 19:22:58 -07:00
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
// count number of picks and axes available for use
count_tools();
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
// collect list of dwarfs
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
collect_dwarf_list();
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
// add job entries for designation-related jobs
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
labor_needed[df::unit_labor::MINE] += dig_count;
labor_needed[df::unit_labor::CUTWOOD] += tree_count;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
labor_needed[df::unit_labor::DETAIL] += detail_count;
labor_needed[df::unit_labor::HERBALIST] += plant_count;
// add job entries for health care
labor_needed[df::unit_labor::RECOVER_WOUNDED] += cnt_recover_wounded;
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
labor_needed[df::unit_labor::DIAGNOSE] += cnt_diagnosis;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
labor_needed[df::unit_labor::BONE_SETTING] += cnt_immobilize;
labor_needed[df::unit_labor::DRESSING_WOUNDS] += cnt_dressing;
Autolabor: fix wound cleaning labor.
2012-12-11 08:06:37 -07:00
labor_needed[df::unit_labor::DRESSING_WOUNDS] += cnt_cleaning;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
labor_needed[df::unit_labor::SURGERY] += cnt_surgery;
labor_needed[df::unit_labor::SUTURING] += cnt_suture;
labor_needed[df::unit_labor::BONE_SETTING] += cnt_setting;
labor_needed[df::unit_labor::BONE_SETTING] += cnt_traction;
Autolabor: fix bring-crutch labor
2012-12-11 08:19:38 -07:00
labor_needed[df::unit_labor::BONE_SETTING] += cnt_crutch;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
labor_needed[df::unit_labor::FEED_WATER_CIVILIANS] += need_food_water;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
// add entries for hauling jobs
labor_needed[df::unit_labor::HAUL_STONE] += world->stockpile.num_jobs[1];
labor_needed[df::unit_labor::HAUL_WOOD] += world->stockpile.num_jobs[2];
labor_needed[df::unit_labor::HAUL_ITEM] += world->stockpile.num_jobs[3];
Fix whitespace issues
2015-02-14 20:53:06 -07:00
labor_needed[df::unit_labor::HAUL_ITEM] += world->stockpile.num_jobs[4];
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
labor_needed[df::unit_labor::HAUL_BODY] += world->stockpile.num_jobs[5];
labor_needed[df::unit_labor::HAUL_FOOD] += world->stockpile.num_jobs[6];
labor_needed[df::unit_labor::HAUL_REFUSE] += world->stockpile.num_jobs[7];
labor_needed[df::unit_labor::HAUL_FURNITURE] += world->stockpile.num_jobs[8];
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labor_needed[df::unit_labor::HAUL_ANIMALS] += world->stockpile.num_jobs[9];
labor_needed[df::unit_labor::HAUL_STONE] += (world->stockpile.num_jobs[1] >= world->stockpile.num_haulers[1]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_WOOD] += (world->stockpile.num_jobs[2] >= world->stockpile.num_haulers[2]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_ITEM] += (world->stockpile.num_jobs[3] >= world->stockpile.num_haulers[3]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_BODY] += (world->stockpile.num_jobs[5] >= world->stockpile.num_haulers[5]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_FOOD] += (world->stockpile.num_jobs[6] >= world->stockpile.num_haulers[6]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_REFUSE] += (world->stockpile.num_jobs[7] >= world->stockpile.num_haulers[7]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_FURNITURE] += (world->stockpile.num_jobs[8] >= world->stockpile.num_haulers[8]) ? 1 : 0;
labor_needed[df::unit_labor::HAUL_ANIMALS] += (world->stockpile.num_jobs[9] >= world->stockpile.num_haulers[9]) ? 1 : 0;
int binjobs = world->stockpile.num_jobs[4] + ((world->stockpile.num_jobs[4] >= world->stockpile.num_haulers[4]) ? 1 : 0);
labor_needed[df::unit_labor::HAUL_ITEM] += binjobs;
labor_needed[df::unit_labor::HAUL_FOOD] += priority_food;
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
// add entries for vehicle hauling
for (auto v = world->vehicles.all.begin(); v != world->vehicles.all.end(); v++)
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if ((*v)->route_id != -1)
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labor_needed[df::unit_labor::HANDLE_VEHICLES]++;
Autolabor: splints and crutches are furniture (at least at a forge); remove test that excludes pet owners from being given jobs when they're idle; add test for hungry/thirsty dwarves to trigger a feed/water civilians requirement; add a vehicle hauling requirement based on the existence of hauling routes
2012-12-03 03:28:08 -07:00
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
// add fishing & hunting
Fix whitespace issues
2015-02-14 20:53:06 -07:00
labor_needed[df::unit_labor::FISH] =
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
(isOptionEnabled(CF_ALLOW_FISHING) && has_fishery) ? 1 : 0;
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
labor_needed[df::unit_labor::HUNT] =
(isOptionEnabled(CF_ALLOW_HUNTING) && has_butchers) ? 1 : 0;
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
Autolabor: slabs, animal trainers
2012-12-06 00:38:43 -07:00
/* add animal trainers */
for (auto a = df::global::ui->equipment.training_assignments.begin();
a != df::global::ui->equipment.training_assignments.end();
a++)
{
labor_needed[df::unit_labor::ANIMALTRAIN]++;
// note: this doesn't test to see if the trainer is actually needed, and thus will overallocate trainers. bleah.
}
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
/* set requirements to zero for labors with currently idle dwarfs, and remove from requirement dwarfs actually working */
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
FOR_ENUM_ITEMS(unit_labor, l) {
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
if (l == df::unit_labor::NONE)
continue;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
int before = labor_needed[l];
labormanager: fix several job-to-labor mappings
2016-07-07 01:10:43 -06:00
labor_needed[l] = max(0, labor_needed[l] - labor_in_use[l]);
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
if (default_labor_infos[l].tool != TOOL_NONE)
labor_needed[l] = std::min(labor_needed[l], tool_count[default_labor_infos[l].tool] - tool_in_use[default_labor_infos[l].tool]);
if (print_debug && before != labor_needed[l])
out.print ("labor %s reduced from %d to %d\n", ENUM_KEY_STR(unit_labor, l).c_str(), before, labor_needed[l]);
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
/* assign food haulers for rotting food items */
if (priority_food > 0 && labor_infos[df::unit_labor::HAUL_FOOD].idle_dwarfs > 0)
priority_food = 1;
if (print_debug)
out.print ("priority food count = %d\n", priority_food);
while (!available_dwarfs.empty() && priority_food > 0)
{
std::list<dwarf_info_t*>::iterator bestdwarf = available_dwarfs.begin();
int best_score = INT_MIN;
for (std::list<dwarf_info_t*>::iterator k = available_dwarfs.begin(); k != available_dwarfs.end(); k++)
Autolabor: fix idle stepdown (seems to work much better), change some scoring weights, change autolabor list output to include busy and idle counters
2013-01-01 15:35:09 -07:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
dwarf_info_t* d = (*k);
Autolabor: adjust idle clawback to deal with "pickup equipment" for miners.
2013-01-01 16:53:24 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
int score = score_labor(d, df::unit_labor::HAUL_FOOD);
if (score > best_score)
{
bestdwarf = k;
best_score = score;
}
}
if (best_score > INT_MIN)
{
Autolabor: fix idle stepdown (seems to work much better), change some scoring weights, change autolabor list output to include busy and idle counters
2013-01-01 15:35:09 -07:00
if (print_debug)
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
out.print("LABORMANAGER: assign \"%s\" labor %s score=%d (priority food)\n", (*bestdwarf)->dwarf->name.first_name.c_str(), ENUM_KEY_STR(unit_labor, df::unit_labor::HAUL_FOOD).c_str(), best_score);
FOR_ENUM_ITEMS(unit_labor, l)
{
if (l == df::unit_labor::NONE)
continue;
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor (*bestdwarf, l, l == df::unit_labor::HAUL_FOOD);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
available_dwarfs.erase(bestdwarf);
priority_food--;
Autolabor: fix idle stepdown (seems to work much better), change some scoring weights, change autolabor list output to include busy and idle counters
2013-01-01 15:35:09 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
else
break;
Autolabor: fix dig-from-below bug regaring mining jobs, add overallocation detection and remediation, fix fishing and hunting
2012-12-27 01:52:54 -07:00
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
if (print_debug)
{
for (auto i = labor_needed.begin(); i != labor_needed.end(); i++)
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
out.print ("labor_needed [%s] = %d, busy = %d, outside = %d, idle = %d\n", ENUM_KEY_STR(unit_labor, i->first).c_str(), i->second,
labor_infos[i->first].busy_dwarfs, labor_outside[i->first], labor_infos[i->first].idle_dwarfs);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
}
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
std::map<df::unit_labor, int> base_priority;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
priority_queue<pair<int, df::unit_labor>> pq;
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
priority_queue<pair<int, df::unit_labor>> pq2;
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
for (auto i = labor_needed.begin(); i != labor_needed.end(); i++)
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
df::unit_labor l = i->first;
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
if (l == df::unit_labor::NONE)
labormanager: fix stupid
2016-06-28 22:28:44 -06:00
continue;
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
if (labor_infos[l].maximum_dwarfs() > 0 &&
i->second > labor_infos[l].maximum_dwarfs())
i->second = labor_infos[l].maximum_dwarfs();
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
int priority = labor_infos[l].priority();
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
priority += labor_infos[l].time_since_last_assigned()/12;
priority -= labor_infos[l].busy_dwarfs;
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
base_priority[l] = priority;
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (i->second > 0)
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
pq.push(make_pair(priority, l));
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Autolabor: add health awareness, fix initialization crash, fix idle dwarf loop crash
2012-12-01 13:08:15 -07:00
autolabor: exclude "item lost" jobs, exclude jobs that are not first-in-queue at workshop, improve debug messages
2012-12-01 15:09:52 -07:00
if (print_debug)
Autolabor: remove some debug spam, and fix an error in computing preference scoring
2012-12-02 08:47:15 -07:00
out.print("available count = %d, distinct labors needed = %d\n", available_dwarfs.size(), pq.size());
autolabor: exclude "item lost" jobs, exclude jobs that are not first-in-queue at workshop, improve debug messages
2012-12-01 15:09:52 -07:00
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
std::map<df::unit_labor, int> to_assign;
to_assign.clear();
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
int av = available_dwarfs.size();
Fix whitespace issues
2015-02-14 20:53:06 -07:00
while (!pq.empty() && av > 0)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
{
df::unit_labor labor = pq.top().second;
int priority = pq.top().first;
to_assign[labor]++;
pq.pop();
av--;
if (print_debug)
out.print("Will assign: %s priority %d (%d)\n", ENUM_KEY_STR(unit_labor, labor).c_str(), priority, to_assign[labor]);
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (--labor_needed[labor] > 0)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
{
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
priority-=10;
pq2.push(make_pair(priority, labor));
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
}
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
if (pq.empty())
while(!pq2.empty())
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
{
pq.push(pq2.top());
pq2.pop();
}
}
while (!pq2.empty())
{
pq.push(pq2.top());
pq2.pop();
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
}
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
int canary = (1 << df::unit_labor::HAUL_STONE) |
(1 << df::unit_labor::HAUL_WOOD) |
(1 << df::unit_labor::HAUL_BODY) |
(1 << df::unit_labor::HAUL_FOOD) |
(1 << df::unit_labor::HAUL_REFUSE) |
(1 << df::unit_labor::HAUL_ITEM) |
(1 << df::unit_labor::HAUL_FURNITURE) |
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
(1 << df::unit_labor::HAUL_ANIMALS);
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
while (!available_dwarfs.empty())
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
{
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
std::list<dwarf_info_t*>::iterator bestdwarf = available_dwarfs.begin();
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Autolabor: identify labors that may involve going outside and apply an assignment penalty for such labors to dwarfs who have minor children (in order to keep the kids inside)
2012-12-08 09:55:44 -07:00
int best_score = INT_MIN;
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
df::unit_labor best_labor = df::unit_labor::NONE;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Fix whitespace issues
2015-02-14 20:53:06 -07:00
for (auto j = to_assign.begin(); j != to_assign.end(); j++)
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
Fix whitespace issues
2015-02-14 20:53:06 -07:00
if (j->second <= 0)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
continue;
df::unit_labor labor = j->first;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
for (std::list<dwarf_info_t*>::iterator k = available_dwarfs.begin(); k != available_dwarfs.end(); k++)
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
{
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
dwarf_info_t* d = (*k);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
int score = score_labor(d, labor);
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
if (score > best_score)
{
bestdwarf = k;
best_score = score;
best_labor = labor;
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
}
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
if (best_labor == df::unit_labor::NONE)
break;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
if (print_debug)
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
out.print("assign \"%s\" labor %s score=%d\n", (*bestdwarf)->dwarf->name.first_name.c_str(), ENUM_KEY_STR(unit_labor, best_labor).c_str(), best_score);
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
FOR_ENUM_ITEMS(unit_labor, l)
{
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
if (l == df::unit_labor::NONE)
continue;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
tools_enum t = default_labor_infos[l].tool;
if (l == best_labor && ( t == TOOL_NONE || tool_in_use[t] < tool_count[t]) )
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
{
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(*bestdwarf, l, true);
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (t != TOOL_NONE && !((*bestdwarf)->has_tool[t]))
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
{
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
df::job_type j;
j = df::job_type::NONE;
if ((*bestdwarf)->dwarf->job.current_job)
j = (*bestdwarf)->dwarf->job.current_job->job_type;
if (print_debug)
out.print("LABORMANAGER: asking %s to pick up tools, current job %s\n", (*bestdwarf)->dwarf->name.first_name.c_str(), ENUM_KEY_STR(job_type, j).c_str());
(*bestdwarf)->dwarf->military.pickup_flags.bits.update = true;
labors_changed = true;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
}
}
Autolabor: add build floor grate labor, add unbuild screwpump labor, protect pump operators, do not clear labors on already busy dwarfs
2013-01-22 15:34:51 -07:00
else if ((*bestdwarf)->state == IDLE)
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
{
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(*bestdwarf, l, false);
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
}
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (best_labor == df::unit_labor::HAUL_FOOD && priority_food > 0)
priority_food--;
if (best_labor >= df::unit_labor::HAUL_STONE && best_labor <= df::unit_labor::HAUL_ANIMALS)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
canary &= ~(1 << best_labor);
Autolabor: more tweaks to hauling labor decoding, fix heap corruption due to array underflow
2012-12-08 02:51:07 -07:00
if (best_labor != df::unit_labor::NONE)
{
labor_infos[best_labor].active_dwarfs++;
to_assign[best_labor]--;
}
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
busy_dwarfs.push_back(*bestdwarf);
Autolabor: generating haulers based on unstockpiled items (less than ideal). Fix wrong build labor for Farmer's workshop. Add build labor function for constructions (also works for furnaces and trade depots). Add architect detection. Use a different mechanism for selecting dwarfs for labors.
2012-12-01 22:12:41 -07:00
available_dwarfs.erase(bestdwarf);
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
for (auto d = busy_dwarfs.begin(); d != busy_dwarfs.end(); d++)
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
int current_score = score_labor (*d, (*d)->using_labor);
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
FOR_ENUM_ITEMS (unit_labor, l)
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (l == df::unit_labor::NONE)
continue;
if (l == (*d)->using_labor)
continue;
if (labor_needed[l] <= 0)
continue;
int score = score_labor (*d, l);
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (l == df::unit_labor::HAUL_FOOD && priority_food > 0)
score += 1000000;
if (score > current_score)
{
tools_enum t = default_labor_infos[l].tool;
if (t == TOOL_NONE || (*d)->has_tool[t])
{
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(*d, l, true);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
if ((*d)->using_labor != df::unit_labor::NONE &&
(score > current_score + 5000 || base_priority[(*d)->using_labor] < base_priority[l]) &&
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
default_labor_infos[(*d)->using_labor].tool == TOOL_NONE)
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
set_labor(*d, (*d)->using_labor, false);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
}
}
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
dwarf_info_t* canary_dwarf = 0;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
for (auto di = busy_dwarfs.begin(); di != busy_dwarfs.end(); di++)
if (!(*di)->clear_all)
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
{
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
canary_dwarf = *di;
break;
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
}
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
if (canary_dwarf)
{
FOR_ENUM_ITEMS (unit_labor, l)
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
{
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
if (l >= df::unit_labor::HAUL_STONE && l <= df::unit_labor::HAUL_ANIMALS &&
canary & (1 << l))
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(canary_dwarf, l, true);
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
/* Also set the canary to remove constructions, because we have no way yet to tell if there are constructions needing removal */
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
set_labor(canary_dwarf, df::unit_labor::REMOVE_CONSTRUCTION, true);
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
if (print_debug)
out.print ("Setting %s as the hauling canary\n", canary_dwarf->dwarf->name.first_name.c_str());
}
else
{
if (print_debug)
out.print ("No dwarf available to set as the hauling canary!\n");
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
}
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
/* Assign any leftover dwarfs to "standard" labors */
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (print_debug)
out.print ("After assignment, %d dwarfs left over\n", available_dwarfs.size());
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
for (auto d = available_dwarfs.begin(); d != available_dwarfs.end(); d++)
{
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
FOR_ENUM_ITEMS (unit_labor, l)
{
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (l == df::unit_labor::NONE)
continue;
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
set_labor(*d, l,
(l >= df::unit_labor::HAUL_STONE && l <= df::unit_labor::HAUL_ANIMALS) ||
l == df::unit_labor::CLEAN ||
l == df::unit_labor::REMOVE_CONSTRUCTION ||
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
l == df::unit_labor::PULL_LEVER ||
l == df::unit_labor::HAUL_TRADE);
}
labormanager: whitespace MSVC is evil.
2016-06-28 21:57:12 -06:00
}
labormanager: more tweaks to bring up to date This update fixes some labors and attempts to address changes in the way DF maintains the job list.
2016-06-28 21:36:45 -06:00
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
/* check for dwarfs assigned no labors and assign them the bucket list if there are */
for (auto d = dwarf_info.begin(); d != dwarf_info.end(); d++)
{
labormanager: whitespace
2016-08-11 15:58:35 -06:00
if ((*d)->state == CHILD)
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
continue;
bool any = false;
FOR_ENUM_ITEMS (unit_labor, l)
{
labormanager: whitespace
2016-08-11 15:58:35 -06:00
if (l == df::unit_labor::NONE)
labormanager: small tweaks Handle cloth crafts correctly; handle pit jobs correctly; handle bookcase construction correctly; deal with new break behavior better; change assignment of clean labor; tweak hauling assignments slightly to avoid overallocation; assign pull lever to everyone and clean to all nonbusy dwarfs
2016-08-11 15:56:34 -06:00
continue;
if ((*d)->dwarf->status.labors[l])
{
any = true;
break;
}
}
set_labor (*d, df::unit_labor::PULL_LEVER, true);
if (any) continue;
FOR_ENUM_ITEMS (unit_labor, l)
{
if (l == df::unit_labor::NONE)
continue;
if (to_assign[l] > 0 || l == df::unit_labor::CLEAN)
set_labor(*d, l, true);
}
}
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
/* set reequip on any dwarfs who are carrying tools needed by others */
for (auto d = dwarf_info.begin(); d != dwarf_info.end(); d++)
{
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
if ((*d)->dwarf->job.current_job && (*d)->dwarf->job.current_job->job_type == df::job_type::PickupEquipment)
continue;
if ((*d)->dwarf->military.pickup_flags.bits.update)
continue;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
FOR_ENUM_ITEMS (unit_labor, l)
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (l == df::unit_labor::NONE)
continue;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
tools_enum t = default_labor_infos[l].tool;
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
if (t == TOOL_NONE)
continue;
bool has_tool = (*d)->has_tool[t];
bool needs_tool = (*d)->dwarf->status.labors[l];
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if ((needs_tool && !has_tool) ||
(has_tool && !needs_tool && tool_in_use[t] >= tool_count[t]))
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
{
labormanager: significant restructuring to use job posting list Updated here to get potential jobs off the job posting lists, which is apparently where certain map-designated live after being designated but before they move to the actual job list. Also changes to how tools are handled, and lever pulling is assigned by default to all idle dwarfs.
2016-06-30 22:58:56 -06:00
df::job_type j = df::job_type::NONE;
if ((*d)->dwarf->job.current_job)
j = (*d)->dwarf->job.current_job->job_type;
if (print_debug)
out.print("LABORMANAGER: asking %s to %s tools, current job %s, %d %d \n", (*d)->dwarf->name.first_name.c_str(), (has_tool) ? "drop" : "pick up", ENUM_KEY_STR(job_type, j).c_str(), has_tool, needs_tool);
(*d)->dwarf->military.pickup_flags.bits.update = true;
labors_changed = true;
if (needs_tool)
tool_in_use[t]++;
Autolabor: rework tool management to try to reduce tool litter
2012-12-12 13:28:11 -07:00
}
}
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
release_dwarf_list();
labormanager: rework for better behavior with 43.03 The main thing here is that the process loop exits if the DF process_job or process_dig flags are set since if these are set the job list is going to change soon anyway. The plugin also sets these flags when it changes any labors, which has the side effect of effectively disabling the process loop while DF is paused, which prevents flapping while editing job preferences in-game, and also allows changing job preferences in game (although such changes may not last when the clock starts up again).
2016-06-29 13:54:03 -06:00
if (labors_changed)
{
*df::global::process_dig = true;
*df::global::process_jobs = true;
}
Autolabor: Tell DF to immediately process jobs after each run.
2013-01-04 12:14:20 -07:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
if (print_debug) {
*df::global::pause_state = true;
}
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
print_debug = 0;
}
Progress commit of a rewrite of autolabor to draw from the jobs list and other world information. A lot still to do on this. DO NOT MERGE INTO THE MAIN BRANCH. This code is incomplete and only vaguely tested.
2012-10-01 16:48:47 -06:00
};
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
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;
}
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
DFhackCExport command_result plugin_onupdate ( color_ostream &out )
{
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
static int step_count = 0;
Tweaks! Check map presence in autolabor and fastdwarf onupdate() functions Game state tracking in kittens plugin now respects on/off switch
2012-03-31 19:46:17 -06:00
// check run conditions
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if(!initialized || !world || !world->map.block_index || !enable_labormanager)
Tweaks! Check map presence in autolabor and fastdwarf onupdate() functions Game state tracking in kittens plugin now respects on/off switch
2012-03-31 19:46:17 -06:00
{
// give up if we shouldn't be running'
return CR_OK;
}
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
// if (++step_count < 60)
// return CR_OK;
fix white space to make travis happy
2016-11-26 17:08:48 -07:00
if (*df::global::process_jobs)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
return CR_OK;
Better job assignment algorithm for labormanager.
2016-11-08 11:01:24 -07:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
step_count = 0;
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Autolabor: Add debugging messages from the labor deduction module; add deduction rules for some building destroy jobs; automatically exclude handless dwarfs from labor poor; use DF's own hauling job counts to compute hauling demand (and arrange for the "hauling canary" so that this always works)
2012-12-02 01:02:16 -07:00
debug_stream = &out;
Autolabor: improve (hopefully) the functionality for mapping jobs to labors. Still some gaps to fill, but not many.
2012-12-01 01:26:06 -07:00
AutoLaborManager alm(out);
alm.process();
Make logic closer to C# version. Address code comments from peterix.
2012-03-22 01:33:18 -06:00
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
return CR_OK;
}
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
void print_labor (df::unit_labor labor, color_ostream &out)
Add commands to change how autolabor handles specific jobs, and to list the current settings. Changes are not saved with the current world (yet).
2012-04-02 23:12:06 -06:00
{
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
string labor_name = ENUM_KEY_STR(unit_labor, labor);
out << labor_name << ": ";
for (int i = 0; i < 20 - (int)labor_name.length(); i++)
out << ' ';
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
out << "priority " << labor_infos[labor].priority()
<< ", maximum " << labor_infos[labor].maximum_dwarfs()
Autolabor: fix idle stepdown (seems to work much better), change some scoring weights, change autolabor list output to include busy and idle counters
2013-01-01 15:35:09 -07:00
<< ", currently " << labor_infos[labor].active_dwarfs << " dwarfs ("
Fix whitespace issues
2015-02-14 20:53:06 -07:00
<< labor_infos[labor].busy_dwarfs << " busy, "
Autolabor: fix idle stepdown (seems to work much better), change some scoring weights, change autolabor list output to include busy and idle counters
2013-01-01 15:35:09 -07:00
<< labor_infos[labor].idle_dwarfs << " idle)"
<< endl;
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
}
df::unit_labor lookup_labor_by_name (std::string& name)
{
df::unit_labor labor = df::unit_labor::NONE;
FOR_ENUM_ITEMS(unit_labor, test_labor)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
if (name == ENUM_KEY_STR(unit_labor, test_labor))
labor = test_labor;
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
}
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
return labor;
Add commands to change how autolabor handles specific jobs, and to list the current settings. Changes are not saved with the current world (yet).
2012-04-02 23:12:06 -06:00
}
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
DFhackCExport command_result plugin_enable ( color_ostream &out, bool enable )
{
if (!Core::getInstance().isWorldLoaded()) {
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
out.printerr("World is not loaded: please load a fort first.\n");
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
return CR_FAILURE;
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (enable && !enable_labormanager)
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
{
enable_plugin(out);
}
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
else if(!enable && enable_labormanager)
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
enable_labormanager = false;
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
setOptionEnabled(CF_ENABLED, false);
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
out << "LaborManager is disabled." << endl;
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
}
return CR_OK;
}
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
command_result labormanager (color_ostream &out, std::vector <std::string> & parameters)
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
{
Persist autolabor config in the savefile.
2012-04-05 00:33:26 -06:00
CoreSuspender suspend;
if (!Core::getInstance().isWorldLoaded()) {
out.printerr("World is not loaded: please load a game first.\n");
return CR_FAILURE;
}
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
if (parameters.size() == 1 &&
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
(parameters[0] == "enable" || parameters[0] == "disable"))
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
{
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
bool enable = (parameters[0] == "enable");
Add built-in enable and disable commands.
2013-09-30 03:19:51 -06:00
return plugin_enable(out, enable);
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
}
Fix whitespace issues
2015-02-14 20:53:06 -07:00
else if (parameters.size() == 3 &&
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
(parameters[0] == "max" || parameters[0] == "priority"))
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
df::unit_labor labor = lookup_labor_by_name(parameters[1]);
if (labor == df::unit_labor::NONE)
{
out.printerr("Could not find labor %s.\n", parameters[0].c_str());
return CR_WRONG_USAGE;
}
int v;
if (parameters[2] == "none")
v = 0;
Fix whitespace issues
2015-02-14 20:53:06 -07:00
else
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
v = atoi (parameters[2].c_str());
if (parameters[0] == "max")
labor_infos[labor].set_maximum_dwarfs(v);
else if (parameters[0] == "priority")
labor_infos[labor].set_priority(v);
print_labor(labor, out);
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
return CR_OK;
}
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
else if (parameters.size() == 2 && parameters[0] == "reset")
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
df::unit_labor labor = lookup_labor_by_name(parameters[1]);
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
if (labor == df::unit_labor::NONE)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
out.printerr("Could not find labor %s.\n", parameters[0].c_str());
return CR_WRONG_USAGE;
}
to new assignment algorithm. Add priority boost for labors based on how long it's been since they were last used, to avoid labor starvation. Move persistent configuration to "autolabor/2.0" to avoid conflicting with older versions.
2012-12-02 13:27:13 -07:00
reset_labor(labor);
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
print_labor(labor, out);
return CR_OK;
}
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
else if (parameters.size() == 1 && (parameters[0] == "allow-fishing" || parameters[0] == "forbid-fishing"))
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
setOptionEnabled(CF_ALLOW_FISHING, (parameters[0] == "allow-fishing"));
return CR_OK;
}
else if (parameters.size() == 1 && (parameters[0] == "allow-hunting" || parameters[0] == "forbid-hunting"))
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Add 'allow fishing' and 'allow hunting' config options. Protect against accidentially trying to set or unset the NONE labor or any other invalid labor value (which corrupts DF). Add traction benches. Change prioritization around quite a bit.
2012-12-04 19:23:19 -07:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
setOptionEnabled(CF_ALLOW_HUNTING, (parameters[0] == "allow-hunting"));
return CR_OK;
}
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
else if (parameters.size() == 1 && parameters[0] == "reset-all")
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
for (int i = 0; i < labor_infos.size(); i++)
{
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
reset_labor((df::unit_labor) i);
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
}
out << "All labors reset." << endl;
return CR_OK;
}
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
else if (parameters.size() == 1 && parameters[0] == "list" || parameters[0] == "status")
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
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)
{
Cleanup autolabor+cleanowned, fix depends/clsocket
2012-09-13 13:42:17 -06:00
if (labor == unit_labor::NONE)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
continue;
print_labor(labor, out);
}
}
return CR_OK;
}
labormanager improvements Add some debugging facilities. Change some hauling, construction, and deconstruction labors to reflect changes in DF since 34.11.
2016-06-27 19:58:38 -06:00
else if (parameters.size() == 2 && parameters[0] == "pause-on-error")
{
if (!enable_labormanager)
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
pause_on_error = parameters[1] == "yes" || parameters[1] == "true";
return CR_OK;
}
Merge https://github.com/ab9rf/dfhack Conflicts: plugins/autolabor.cpp
2012-08-02 09:32:25 -06:00
else if (parameters.size() == 1 && parameters[0] == "debug")
{
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
if (!enable_labormanager)
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
{
out << "Error: The plugin is not enabled." << endl;
return CR_FAILURE;
}
print_debug = 1;
return CR_OK;
}
else
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
{
out.print("Automatically assigns labors to dwarves.\n"
Rename autolabor2 to labormanager and bring up to date with current
2016-06-27 11:04:51 -06:00
"Activate with 'labormanager enable', deactivate with 'labormanager disable'.\n"
"Current state: %s.\n", enable_labormanager ? "enabled" : "disabled");
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
Make indentation consistent (spaces), only display "not enabled" error if you actually try to do something
2012-07-17 09:27:30 -06:00
return CR_OK;
}
Initial Autolabor code.
2012-03-16 22:45:52 -06:00
}
Autolabor: dwarves who are scheduled for a meeting are automatically cleared of all labors. Labor to skill map is now generated at plugin start rather than with every iteration. Also partially refactored the code; no behavioral changes from that.
2012-07-22 11:16:50 -06:00