/plugins/zone.cpp
C++ | 3548 lines | 3015 code | 314 blank | 219 comment | 883 complexity | 7628d49699e466c2871b2d4bd2c748f4 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.1
- // Intention: help with activity zone management (auto-pasture animals, auto-pit goblins, ...)
- //
- // the following things would be nice:
- // - dump info about pastures, pastured animals, count non-pastured tame animals, print gender info
- // - help finding caged dwarves? (maybe even allow to build their cages for fast release)
- // - dump info about caged goblins, animals, ...
- // - count grass tiles on pastures, move grazers to new pasture if old pasture is empty
- // move hungry unpastured grazers to pasture with grass
- //
- // What is working so far:
- // - print detailed info about activity zone and units under cursor (mostly for checking refs and stuff)
- // - mark a zone which is used for future assignment commands
- // - assign single selected creature to a zone
- // - mass-assign creatures using filters
- // - unassign single creature under cursor from current zone
- // - pitting own dwarves :)
- // - full automation of handling mini-pastures over nestboxes:
- // go through all pens, check if they are empty and placed over a nestbox
- // find female tame egg-layer who is not assigned to another pen and assign it to nestbox pasture
- // maybe check for minimum age? it's not that useful to fill nestboxes with freshly hatched birds
- // state and sleep setting is saved the first time autonestbox is started (to avoid writing stuff if the plugin is never used)
- // - full automation of marking live-stock for slaughtering
- // races can be added to a watchlist and it can be set how many male/female kids/adults are left alive
- // adding to the watchlist can be automated as well.
- // config for autobutcher (state and sleep setting) is saved the first time autobutcher is started
- // config for watchlist entries is saved when they are created or modified
- #include <iostream>
- #include <iomanip>
- #include <climits>
- #include <vector>
- #include <algorithm>
- #include <string>
- #include <sstream>
- #include <ctime>
- #include <cstdio>
- using namespace std;
- #include "Core.h"
- #include "Console.h"
- #include "Export.h"
- #include "PluginManager.h"
- #include "modules/Units.h"
- #include "modules/Maps.h"
- #include "modules/Gui.h"
- #include "modules/Materials.h"
- #include "modules/MapCache.h"
- #include "modules/Buildings.h"
- #include "modules/World.h"
- #include "MiscUtils.h"
- #include <df/ui.h>
- #include "df/world.h"
- #include "df/world_raws.h"
- #include "df/building_def.h"
- #include "df/building_civzonest.h"
- #include "df/building_cagest.h"
- #include "df/building_chainst.h"
- #include "df/building_nest_boxst.h"
- #include "df/general_ref_building_civzone_assignedst.h"
- #include <df/creature_raw.h>
- #include <df/caste_raw.h>
- using std::vector;
- using std::string;
- using namespace DFHack;
- using namespace df::enums;
- using df::global::world;
- using df::global::cursor;
- using df::global::ui;
- using namespace DFHack::Gui;
- command_result df_zone (color_ostream &out, vector <string> & parameters);
- command_result df_autonestbox (color_ostream &out, vector <string> & parameters);
- command_result df_autobutcher(color_ostream &out, vector <string> & parameters);
- DFHACK_PLUGIN("zone");
- const string zone_help =
- "Allows easier management of pens/pastures, pits and cages.\n"
- "Options:\n"
- " set - set zone under cursor as default for future assigns\n"
- " assign - assign creature(s) to a pen or pit\n"
- " if no filters are used, a single unit must be selected.\n"
- " can be followed by valid building id which will then be set.\n"
- " building must be a pen/pasture, pit or cage.\n"
- " slaughter - mark creature(s) for slaughter\n"
- " if no filters are used, a single unit must be selected.\n"
- " with filters named units are ignored unless specified.\n"
- " unassign - unassign selected creature(s) from it's zone or cage\n"
- " nick - give unit(s) nicknames (e.g. all units in a cage)\n"
- " remnick - remove nicknames\n"
- " tocages - assign to (multiple) built cages inside a pen/pasture\n"
- " spreads creatures evenly among cages for faster hauling.\n"
- " uinfo - print info about selected unit\n"
- " zinfo - print info about zone(s) under cursor\n"
- " verbose - print some more info, mostly useless debug stuff\n"
- " filters - print list of supported filters\n"
- " examples - print some usage examples\n"
- ;
- const string zone_help_filters =
- "Filters (to be used in combination with 'all' or 'count'):\n"
- "These filters can not be used with the prefix 'not':"
- " all - in combinations with zinfo/uinfo: print all zones/units\n"
- " in combination with assign: process all units\n"
- " should be used in combination with further filters\n"
- " count - must be followed by number. process X units\n"
- " should be used in combination with further filters\n"
- " unassigned - not assigned to zone, chain or built cage\n"
- " age - exact age. must be followed by number\n"
- " minage - minimum age. must be followed by number\n"
- " maxage - maximum age. must be followed by number\n"
- "These filters can be used with the prefix 'not' (e.g. 'not own'):"
- " race - must be followed by a race raw id (e.g. BIRD_TURKEY)\n"
- " caged - in a built cage\n"
- " own - from own civilization\n"
- " war - trained war creature\n"
- " tamed - tamed\n"
- " named - has name or nickname\n"
- " can be used to mark named units for slaughter\n"
- " merchant - is a merchant / belongs to a merchant\n"
- " can be used to pit merchants and slaughter their animals\n"
- " (could have weird effects during trading, be careful)\n"
- " trained - obvious\n"
- " trainablewar - can be trained for war (and is not already trained)\n"
- " trainablehunt- can be trained for hunting (and is not already trained)\n"
- " male - obvious\n"
- " female - obvious\n"
- " egglayer - race lays eggs (use together with 'female')\n"
- " grazer - is a grazer\n"
- " milkable - race is milkable (use together with 'female')\n"
- ;
- const string zone_help_examples =
- "Example for assigning single units:\n"
- " (ingame) move cursor to a pen/pasture or pit zone\n"
- " (dfhack) 'zone set' to use this zone for future assignments\n"
- " (dfhack) map 'zone assign' to a hotkey of your choice\n"
- " (ingame) select unit with 'v', 'k' or from unit list or inside a cage\n"
- " (ingame) press hotkey to assign unit to it's new home (or pit)\n"
- "Examples for assigning with filters:\n"
- " (this assumes you have already set up a target zone)\n"
- " zone assign all own grazer maxage 10\n"
- " zone assign all own milkable not grazer\n"
- " zone assign count 5 own female milkable\n"
- " zone assign all own race DWARF maxage 2\n"
- " throw all useless kids into a pit :)\n"
- "Notes:\n"
- " Unassigning per filters ignores built cages and chains currently. Usually you\n"
- " should always use the filter 'own' (which implies tame) unless you want to\n"
- " use the zone tool for pitting hostiles. 'own' ignores own dwarves unless you\n"
- " specify 'race DWARF' and it ignores merchants and their animals unless you\n"
- " specify 'merchant' (so it's safe to use 'assign all own' to one big pasture\n"
- " if you want to have all your animals at the same place).\n"
- " 'egglayer' and 'milkable' should be used together with 'female'\n"
- " well, unless you have a mod with egg-laying male elves who give milk...\n";
- const string autonestbox_help =
- "Assigns unpastured female egg-layers to nestbox zones.\n"
- "Requires that you create pen/pasture zones above nestboxes.\n"
- "If the pen is bigger than 1x1 the nestbox must be in the top left corner.\n"
- "Only 1 unit will be assigned per pen, regardless of the size.\n"
- "The age of the units is currently not checked, most birds grow up quite fast.\n"
- "When called without options autonestbox will instantly run once.\n"
- "Options:\n"
- " start - run every X frames (df simulation ticks)\n"
- " default: X=6000 (~60 seconds at 100fps)\n"
- " stop - stop running automatically\n"
- " sleep X - change timer to sleep X frames between runs.\n";
- const string autobutcher_help =
- "Assigns your lifestock for slaughter once it reaches a specific count. Requires\n"
- "that you add the target race(s) to a watch list. Only tame units will be\n"
- "processed. Named units will be completely ignored (you can give animals\n"
- "nicknames with the tool 'rename unit' to protect them from getting slaughtered\n"
- "automatically. Trained war or hunting pets will be ignored.\n"
- "Once you have too much adults, the oldest will be butchered first.\n"
- "Once you have too much kids, the youngest will be butchered first.\n"
- "If you don't set a target count the following default will be used:\n"
- "1 male kid, 5 female kids, 1 male adult, 5 female adults.\n"
- "Options:\n"
- " start - run every X frames (df simulation ticks)\n"
- " default: X=6000 (~60 seconds at 100fps)\n"
- " stop - stop running automatically\n"
- " sleep X - change timer to sleep X frames between runs.\n"
- " watch R - start watching race(s)\n"
- " R = valid race RAW id (ALPACA, BIRD_TURKEY, etc)\n"
- " or a list of RAW ids seperated by spaces\n"
- " or the keyword 'all' which affects your whole current watchlist.\n"
- " unwatch R - stop watching race(s)\n"
- " the current target settings will be remembered\n"
- " forget R - unwatch race(s) and forget target settings for it/them\n"
- " autowatch - automatically adds all new races (animals you buy\n"
- " from merchants, tame yourself or get from migrants)\n"
- " to the watch list using default target count\n"
- " noautowatch - stop auto-adding new races to the watch list\n"
- " list - print status and watchlist\n"
- " list_export - print status and watchlist in batchfile format\n"
- " can be used to copy settings into another savegame\n"
- " usage: 'dfhack-run autobutcher list_export > xyz.bat' \n"
- " target fk mk fa ma R\n"
- " - set target count for specified race:\n"
- " fk = number of female kids\n"
- " mk = number of male kids\n"
- " fa = number of female adults\n"
- " ma = number of female adults\n"
- " R = 'all' sets count for all races on the current watchlist\n"
- " including the races which are currenly set to 'unwatched'\n"
- " and sets the new default for future watch commands\n"
- " R = 'new' sets the new default for future watch commands\n"
- " without changing your current watchlist\n"
- " example - print some usage examples\n";
- const string autobutcher_help_example =
- "Examples:\n"
- " autobutcher target 4 3 2 1 ALPACA BIRD_TURKEY\n"
- " autobutcher watch ALPACA BIRD_TURKEY\n"
- " autobutcher start\n"
- " This means you want to have max 7 kids (4 female, 3 male) and max 3 adults\n"
- " (2 female, 1 male) of the races alpaca and turkey. Once the kids grow up the\n"
- " oldest adults will get slaughtered. Excess kids will get slaughtered starting\n"
- " the the youngest to allow that the older ones grow into adults.\n"
- " autobutcher target 0 0 0 0 new\n"
- " autobutcher autowatch\n"
- " autobutcher start\n"
- " This tells autobutcher to automatically put all new races onto the watchlist\n"
- " and mark unnamed tame units for slaughter as soon as they arrive in your\n"
- " fortress. Settings already made for some races will be left untouched.\n";
- command_result init_autobutcher(color_ostream &out);
- command_result cleanup_autobutcher(color_ostream &out);
- command_result start_autobutcher(color_ostream &out);
- command_result init_autonestbox(color_ostream &out);
- command_result cleanup_autonestbox(color_ostream &out);
- command_result start_autonestbox(color_ostream &out);
- DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
- {
- commands.push_back(PluginCommand(
- "zone", "manage activity zones.",
- df_zone, false,
- zone_help.c_str()
- ));
- commands.push_back(PluginCommand(
- "autonestbox", "auto-assign nestbox zones.",
- df_autonestbox, false,
- autonestbox_help.c_str()
- ));
- commands.push_back(PluginCommand(
- "autobutcher", "auto-assign lifestock for butchering.",
- df_autobutcher, false,
- autobutcher_help.c_str()
- ));
- init_autobutcher(out);
- init_autonestbox(out);
- return CR_OK;
- }
- DFhackCExport command_result plugin_shutdown ( color_ostream &out )
- {
- cleanup_autobutcher(out);
- cleanup_autonestbox(out);
- return CR_OK;
- }
- ///////////////
- // stuff for autonestbox and autobutcher
- // should be moved to own plugin once the tool methods it shares with the zone plugin are moved to Unit.h / Building.h
- command_result autoNestbox( color_ostream &out, bool verbose );
- command_result autoButcher( color_ostream &out, bool verbose );
- static bool enable_autonestbox = false;
- static bool enable_autobutcher = false;
- static bool enable_autobutcher_autowatch = false;
- static size_t sleep_autonestbox = 6000;
- static size_t sleep_autobutcher = 6000;
- static bool autonestbox_did_complain = false; // avoids message spam
- static PersistentDataItem config_autobutcher;
- static PersistentDataItem config_autonestbox;
- DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
- {
- switch (event)
- {
- case DFHack::SC_MAP_LOADED:
- // initialize from the world just loaded
- init_autobutcher(out);
- init_autonestbox(out);
- break;
- case DFHack::SC_MAP_UNLOADED:
- enable_autonestbox = false;
- enable_autobutcher = false;
- // cleanup
- cleanup_autobutcher(out);
- cleanup_autonestbox(out);
- break;
- default:
- break;
- }
- return CR_OK;
- }
- DFhackCExport command_result plugin_onupdate ( color_ostream &out )
- {
- static size_t ticks_autonestbox = 0;
- static size_t ticks_autobutcher = 0;
- if(enable_autonestbox)
- {
- if(++ticks_autonestbox >= sleep_autonestbox)
- {
- ticks_autonestbox = 0;
- autoNestbox(out, false);
- }
- }
- if(enable_autobutcher)
- {
- if(++ticks_autobutcher >= sleep_autobutcher)
- {
- ticks_autobutcher= 0;
- autoButcher(out, false);
- }
- }
- return CR_OK;
- }
- ///////////////
- // Various small tool functions
- // probably many of these should be moved to Unit.h and Building.h sometime later...
- int32_t getUnitAge(df::unit* unit);
- bool isTame(df::unit* unit);
- bool isTrained(df::unit* unit);
- bool isWar(df::unit* unit);
- bool isHunter(df::unit* unit);
- bool isOwnCiv(df::unit* unit);
- bool isMerchant(df::unit* unit);
- bool isForest(df::unit* unit);
- bool isActivityZone(df::building * building);
- bool isPenPasture(df::building * building);
- bool isPitPond(df::building * building);
- bool isActive(df::building * building);
- int32_t findBuildingIndexById(int32_t id);
- int32_t findPenPitAtCursor();
- int32_t findCageAtCursor();
- int32_t findChainAtCursor();
- df::general_ref_building_civzone_assignedst * createCivzoneRef();
- bool unassignUnitFromBuilding(df::unit* unit);
- command_result assignUnitToZone(color_ostream& out, df::unit* unit, df::building* building, bool verbose);
- void unitInfo(color_ostream & out, df::unit* creature, bool verbose);
- void zoneInfo(color_ostream & out, df::building* building, bool verbose);
- void cageInfo(color_ostream & out, df::building* building, bool verbose);
- void chainInfo(color_ostream & out, df::building* building, bool verbose);
- bool isBuiltCageAtPos(df::coord pos);
- bool isInBuiltCageRoom(df::unit*);
- bool isNaked(df::unit *);
- bool isTamable(df::unit *);
- int32_t getUnitAge(df::unit* unit)
- {
- // If the birthday this year has not yet passed, subtract one year.
- // ASSUMPTION: birth_time is on the same scale as cur_year_tick
- int32_t yearDifference = *df::global::cur_year - unit->relations.birth_year;
- if (unit->relations.birth_time >= *df::global::cur_year_tick)
- yearDifference--;
- return yearDifference;
- }
- bool isDead(df::unit* unit)
- {
- return unit->flags1.bits.dead;
- }
- // ignore vampires, they should be treated like normal dwarves
- bool isUndead(df::unit* unit)
- {
- return (unit->flags3.bits.ghostly ||
- ( (unit->curse.add_tags1.bits.OPPOSED_TO_LIFE || unit->curse.add_tags1.bits.NOT_LIVING)
- && !unit->curse.add_tags1.bits.BLOODSUCKER ));
- }
- bool isMerchant(df::unit* unit)
- {
- return unit->flags1.bits.merchant;
- }
- bool isForest(df::unit* unit)
- {
- return unit->flags1.bits.forest;
- }
- bool isMarkedForSlaughter(df::unit* unit)
- {
- return unit->flags2.bits.slaughter;
- }
- void doMarkForSlaughter(df::unit* unit)
- {
- unit->flags2.bits.slaughter = 1;
- }
- // check if creature is tame
- bool isTame(df::unit* creature)
- {
- bool tame = false;
- if(creature->flags1.bits.tame)
- {
- switch (creature->training_level)
- {
- case df::animal_training_level::SemiWild: //??
- case df::animal_training_level::Trained:
- case df::animal_training_level::WellTrained:
- case df::animal_training_level::SkilfullyTrained:
- case df::animal_training_level::ExpertlyTrained:
- case df::animal_training_level::ExceptionallyTrained:
- case df::animal_training_level::MasterfullyTrained:
- case df::animal_training_level::Domesticated:
- tame=true;
- break;
- case df::animal_training_level::Unk8: //??
- case df::animal_training_level::WildUntamed:
- default:
- tame=false;
- break;
- }
- }
- return tame;
- }
- // check if creature is domesticated
- // seems to be the only way to really tell if it's completely safe to autonestbox it (training can revert)
- bool isDomesticated(df::unit* creature)
- {
- bool tame = false;
- if(creature->flags1.bits.tame)
- {
- switch (creature->training_level)
- {
- case df::animal_training_level::Domesticated:
- tame=true;
- break;
- default:
- tame=false;
- break;
- }
- }
- return tame;
- }
- // check if trained (might be useful if pasturing war dogs etc)
- bool isTrained(df::unit* unit)
- {
- // case a: trained for war/hunting (those don't have a training level, strangely)
- if(isWar(unit) || isHunter(unit))
- return true;
- // case b: tamed and trained wild creature, gets a training level
- bool trained = false;
- switch (unit->training_level)
- {
- case df::animal_training_level::Trained:
- case df::animal_training_level::WellTrained:
- case df::animal_training_level::SkilfullyTrained:
- case df::animal_training_level::ExpertlyTrained:
- case df::animal_training_level::ExceptionallyTrained:
- case df::animal_training_level::MasterfullyTrained:
- //case df::animal_training_level::Domesticated:
- trained = true;
- break;
- default:
- break;
- }
- return trained;
- }
- // check for profession "war creature"
- bool isWar(df::unit* unit)
- {
- if( unit->profession == df::profession::TRAINED_WAR
- || unit->profession2 == df::profession::TRAINED_WAR)
- return true;
- else
- return false;
- }
- // check for profession "hunting creature"
- bool isHunter(df::unit* unit)
- {
- if( unit->profession == df::profession::TRAINED_HUNTER
- || unit->profession2 == df::profession::TRAINED_HUNTER)
- return true;
- else
- return false;
- }
- // check if creature belongs to the player's civilization
- // (don't try to pasture/slaughter random untame animals)
- bool isOwnCiv(df::unit* unit)
- {
- return unit->civ_id == ui->civ_id;
- }
- // check if creature belongs to the player's race
- // (in combination with check for civ helps to filter out own dwarves)
- bool isOwnRace(df::unit* unit)
- {
- return unit->race == ui->race_id;
- }
- string getRaceName(int32_t id)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[id];
- return raw->creature_id;
- }
- string getRaceName(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- return raw->creature_id;
- }
- string getRaceBabyName(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- return raw->general_baby_name[0];
- }
- string getRaceChildName(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- return raw->general_child_name[0];
- }
- bool isBaby(df::unit* unit)
- {
- return unit->profession == df::profession::BABY;
- }
- bool isChild(df::unit* unit)
- {
- return unit->profession == df::profession::CHILD;
- }
- bool isAdult(df::unit* unit)
- {
- return !isBaby(unit) && !isChild(unit);
- }
- bool isEggLayer(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if( caste->flags.is_set(caste_raw_flags::LAYS_EGGS)
- || caste->flags.is_set(caste_raw_flags::LAYS_UNUSUAL_EGGS))
- return true;
- }
- return false;
- }
- bool isGrazer(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if(caste->flags.is_set(caste_raw_flags::GRAZER))
- return true;
- }
- return false;
- }
- bool isMilkable(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if(caste->flags.is_set(caste_raw_flags::MILKABLE))
- return true;
- }
- return false;
- }
- bool isTrainableWar(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if(caste->flags.is_set(caste_raw_flags::TRAINABLE_WAR))
- return true;
- }
- return false;
- }
- bool isTrainableHunting(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if(caste->flags.is_set(caste_raw_flags::TRAINABLE_HUNTING))
- return true;
- }
- return false;
- }
- bool isTamable(df::unit* unit)
- {
- df::creature_raw *raw = df::global::world->raws.creatures.all[unit->race];
- size_t sizecas = raw->caste.size();
- for (size_t j = 0; j < sizecas;j++)
- {
- df::caste_raw *caste = raw->caste[j];
- if(caste->flags.is_set(caste_raw_flags::PET) ||
- caste->flags.is_set(caste_raw_flags::PET_EXOTIC))
- return true;
- }
- return false;
- }
- bool isMale(df::unit* unit)
- {
- return unit->sex == 1;
- }
- bool isFemale(df::unit* unit)
- {
- return unit->sex == 0;
- }
- // found a unit with weird position values on one of my maps (negative and in the thousands)
- // it didn't appear in the animal stocks screen, but looked completely fine otherwise (alive, tame, own, etc)
- // maybe a rare bug, but better avoid assigning such units to zones or slaughter etc.
- bool hasValidMapPos(df::unit* unit)
- {
- if( unit->pos.x >=0 && unit->pos.y >= 0 && unit->pos.z >= 0
- && unit->pos.x < world->map.x_count
- && unit->pos.y < world->map.y_count
- && unit->pos.z < world->map.z_count)
- return true;
- else
- return false;
- }
- bool isNaked(df::unit* unit)
- {
- return (unit->inventory.empty());
- }
- int getUnitIndexFromId(df::unit* unit_)
- {
- for (size_t i=0; i < world->units.all.size(); i++)
- {
- df::unit* unit = world->units.all[i];
- if(unit->id == unit_->id)
- return i;
- }
- return -1;
- }
- // dump some unit info
- void unitInfo(color_ostream & out, df::unit* unit, bool verbose = false)
- {
- out.print("Unit %d ", unit->id); //race %d, civ %d,", creature->race, creature->civ_id
- if(unit->name.has_name)
- {
- // units given a nick with the rename tool might not have a first name (animals etc)
- string firstname = unit->name.first_name;
- if(firstname.size() > 0)
- {
- firstname[0] = toupper(firstname[0]);
- out << "Name: " << firstname;
- }
- if(unit->name.nickname.size() > 0)
- out << " '" << unit->name.nickname << "'";
- out << ", ";
- }
- if(isAdult(unit))
- out << "adult";
- else if(isBaby(unit))
- out << "baby";
- else if(isChild(unit))
- out << "child";
- out << " ";
- // sometimes empty even in vanilla RAWS, sometimes contains full race name (e.g. baby alpaca)
- // all animals I looked at don't have babies anyways, their offspring starts as CHILD
- //out << getRaceBabyName(unit);
- //out << getRaceChildName(unit);
- out << getRaceName(unit) << " (";
- switch(unit->sex)
- {
- case 0:
- out << "female";
- break;
- case 1:
- out << "male";
- break;
- case -1:
- default:
- out << "n/a";
- break;
- }
- out << ")";
- out << ", age: " << getUnitAge(unit);
- if(isTame(unit))
- out << ", tame";
- if(isOwnCiv(unit))
- out << ", owned";
- if(isWar(unit))
- out << ", war";
- if(isHunter(unit))
- out << ", hunter";
- if(isMerchant(unit))
- out << ", merchant";
- if(isForest(unit))
- out << ", forest";
- if(isEggLayer(unit))
- out << ", egglayer";
- if(isGrazer(unit))
- out << ", grazer";
- if(isMilkable(unit))
- out << ", milkable";
- if(verbose)
- {
- out << ". Pos: ("<<unit->pos.x << "/"<< unit->pos.y << "/" << unit->pos.z << ") " << endl;
- out << "index in units vector: " << getUnitIndexFromId(unit) << endl;
- }
- out << endl;
- if(!verbose)
- return;
- //out << "number of refs: " << creature->general_refs.size() << endl;
- for(size_t r = 0; r<unit->general_refs.size(); r++)
- {
- df::general_ref* ref = unit->general_refs.at(r);
- df::general_ref_type refType = ref->getType();
- out << " ref#" << r <<" refType#" << refType << " "; //endl;
- switch(refType)
- {
- case df::general_ref_type::BUILDING_CIVZONE_ASSIGNED:
- {
- out << "assigned to zone";
- df::building_civzonest * civAss = (df::building_civzonest *) ref->getBuilding();
- out << " #" << civAss->id;
- }
- break;
- case df::general_ref_type::CONTAINED_IN_ITEM:
- out << "contained in item";
- break;
- case df::general_ref_type::BUILDING_CAGED:
- out << "caged";
- break;
- case df::general_ref_type::BUILDING_CHAIN:
- out << "chained";
- break;
- default:
- //out << "unhandled reftype";
- break;
- }
- out << endl;
- }
- if(isInBuiltCageRoom(unit))
- {
- out << "in a room." << endl;
- }
- }
- bool isActivityZone(df::building * building)
- {
- if( building->getType() == building_type::Civzone
- && building->getSubtype() == (short)civzone_type::ActivityZone)
- return true;
- else
- return false;
- }
- bool isPenPasture(df::building * building)
- {
- if(!isActivityZone(building))
- return false;
- df::building_civzonest * civ = (df::building_civzonest *) building;
- if(civ->zone_flags.bits.pen_pasture)
- return true;
- else
- return false;
- }
- bool isPitPond(df::building * building)
- {
- if(!isActivityZone(building))
- return false;
- df::building_civzonest * civ = (df::building_civzonest *) building;
- if(civ->zone_flags.bits.pit_pond) // && civ->pit_flags==0)
- return true;
- else
- return false;
- }
- bool isCage(df::building * building)
- {
- return building->getType() == building_type::Cage;
- }
- bool isChain(df::building * building)
- {
- return building->getType() == building_type::Chain;
- }
- bool isActive(df::building * building)
- {
- if(!isActivityZone(building))
- return false;
- df::building_civzonest * civ = (df::building_civzonest *) building;
- if(civ->zone_flags.bits.active)
- return true;
- else
- return false;
- }
- int32_t findBuildingIndexById(int32_t id)
- {
- for (size_t b = 0; b < world->buildings.all.size(); b++)
- {
- if(world->buildings.all.at(b)->id == id)
- return b;
- }
- return -1;
- }
- int32_t findUnitIndexById(int32_t id)
- {
- for (size_t i = 0; i < world->units.all.size(); i++)
- {
- if(world->units.all.at(i)->id == id)
- return i;
- }
- return -1;
- }
- df::unit* findUnitById(int32_t id)
- {
- int32_t index = findUnitIndexById(id);
- if(index != -1)
- return world->units.all[index];
- else
- return NULL;
- }
- // returns id of pen/pit at cursor position (-1 if nothing found)
- int32_t findPenPitAtCursor()
- {
- int32_t foundID = -1;
- if(cursor->x == -30000)
- return -1;
- for (size_t b = 0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- // find zone under cursor
- if (!(building->x1 <= cursor->x && cursor->x <= building->x2 &&
- building->y1 <= cursor->y && cursor->y <= building->y2 &&
- building->z == cursor->z))
- continue;
- if(isPenPasture(building) || isPitPond(building))
- {
- foundID = building->id;
- break;
- }
- }
- return foundID;
- }
- // returns id of cage at cursor position (-1 if nothing found)
- int32_t findCageAtCursor()
- {
- int32_t foundID = -1;
- if(cursor->x == -30000)
- return -1;
- for (size_t b = 0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if (!(building->x1 <= cursor->x && cursor->x <= building->x2 &&
- building->y1 <= cursor->y && cursor->y <= building->y2 &&
- building->z == cursor->z))
- continue;
- // don't set id if cage is not constructed yet
- if(building->getBuildStage()!=building->getMaxBuildStage())
- break;
- if(isCage(building))
- {
- foundID = building->id;
- break;
- }
- }
- return foundID;
- }
- int32_t findChainAtCursor()
- {
- int32_t foundID = -1;
- if(cursor->x == -30000)
- return -1;
- for (size_t b = 0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- // find zone under cursor
- if (!(building->x1 <= cursor->x && cursor->x <= building->x2 &&
- building->y1 <= cursor->y && cursor->y <= building->y2 &&
- building->z == cursor->z))
- continue;
- if(isChain(building))
- {
- foundID = building->id;
- break;
- }
- }
- return foundID;
- }
- df::general_ref_building_civzone_assignedst * createCivzoneRef()
- {
- static bool vt_initialized = false;
- df::general_ref_building_civzone_assignedst* newref = NULL;
- // after having run successfully for the first time it's safe to simply create the object
- if(vt_initialized)
- {
- newref = (df::general_ref_building_civzone_assignedst*)
- df::general_ref_building_civzone_assignedst::_identity.instantiate();
- return newref;
- }
- // being called for the first time, need to initialize the vtable
- for(size_t i = 0; i < world->units.all.size(); i++)
- {
- df::unit * creature = world->units.all[i];
- for(size_t r = 0; r<creature->general_refs.size(); r++)
- {
- df::general_ref* ref;
- ref = creature->general_refs.at(r);
- if(ref->getType() == df::general_ref_type::BUILDING_CIVZONE_ASSIGNED)
- {
- if (strict_virtual_cast<df::general_ref_building_civzone_assignedst>(ref))
- {
- // !! calling new() doesn't work, need _identity.instantiate() instead !!
- newref = (df::general_ref_building_civzone_assignedst*)
- df::general_ref_building_civzone_assignedst::_identity.instantiate();
- vt_initialized = true;
- break;
- }
- }
- }
- if(vt_initialized)
- break;
- }
- return newref;
- }
- bool isInBuiltCage(df::unit* unit);
- // check if assigned to pen, pit, (built) cage or chain
- // note: BUILDING_CAGED is not set for animals (maybe it's used for dwarves who get caged as sentence)
- // animals in cages (no matter if built or on stockpile) get the ref CONTAINED_IN_ITEM instead
- // removing them from cages on stockpiles is no problem even without clearing the ref
- // and usually it will be desired behavior to do so.
- bool isAssigned(df::unit* unit)
- {
- bool assigned = false;
- for (size_t r=0; r < unit->general_refs.size(); r++)
- {
- df::general_ref * ref = unit->general_refs[r];
- auto rtype = ref->getType();
- if( rtype == df::general_ref_type::BUILDING_CIVZONE_ASSIGNED
- || rtype == df::general_ref_type::BUILDING_CAGED
- || rtype == df::general_ref_type::BUILDING_CHAIN
- || (rtype == df::general_ref_type::CONTAINED_IN_ITEM && isInBuiltCage(unit))
- )
- {
- assigned = true;
- break;
- }
- }
- return assigned;
- }
- // check if assigned to a chain or built cage
- // (need to check if the ref needs to be removed, until then touching them is forbidden)
- bool isChained(df::unit* unit)
- {
- bool contained = false;
- for (size_t r=0; r < unit->general_refs.size(); r++)
- {
- df::general_ref * ref = unit->general_refs[r];
- auto rtype = ref->getType();
- if(rtype == df::general_ref_type::BUILDING_CHAIN)
- {
- contained = true;
- break;
- }
- }
- return contained;
- }
- // check if contained in item (e.g. animals in cages)
- bool isContainedInItem(df::unit* unit)
- {
- bool contained = false;
- for (size_t r=0; r < unit->general_refs.size(); r++)
- {
- df::general_ref * ref = unit->general_refs[r];
- auto rtype = ref->getType();
- if(rtype == df::general_ref_type::CONTAINED_IN_ITEM)
- {
- contained = true;
- break;
- }
- }
- return contained;
- }
- bool isInBuiltCage(df::unit* unit)
- {
- bool caged = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( building->getType() == building_type::Cage)
- {
- df::building_cagest* cage = (df::building_cagest*) building;
- for(size_t c=0; c<cage->assigned_creature.size(); c++)
- {
- if(cage->assigned_creature[c] == unit->id)
- {
- caged = true;
- break;
- }
- }
- }
- if(caged)
- break;
- }
- return caged;
- }
- // built cage defined as room (supposed to detect zoo cages)
- bool isInBuiltCageRoom(df::unit* unit)
- {
- bool caged_room = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- // !!! building->isRoom() returns true if the building can be made a room but currently isn't
- // !!! except for coffins/tombs which always return false
- // !!! using the bool is_room however gives the correct state/value
- if(!building->is_room)
- continue;
- if(building->getType() == building_type::Cage)
- {
- df::building_cagest* cage = (df::building_cagest*) building;
- for(size_t c=0; c<cage->assigned_creature.size(); c++)
- {
- if(cage->assigned_creature[c] == unit->id)
- {
- caged_room = true;
- break;
- }
- }
- }
- if(caged_room)
- break;
- }
- return caged_room;
- }
- // check a map position for a built cage
- // animals in cages are CONTAINED_IN_ITEM, no matter if they are on a stockpile or inside a built cage
- // if they are on animal stockpiles they should count as unassigned to allow pasturing them
- // if they are inside built cages they should be ignored in case the cage is a zoo or linked to a lever or whatever
- bool isBuiltCageAtPos(df::coord pos)
- {
- bool cage = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( building->getType() == building_type::Cage
- && building->x1 == pos.x
- && building->y1 == pos.y
- && building->z == pos.z )
- {
- cage = true;
- break;
- }
- }
- return cage;
- }
- df::building * getBuiltCageAtPos(df::coord pos)
- {
- df::building* cage = NULL;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( building->getType() == building_type::Cage
- && building->x1 == pos.x
- && building->y1 == pos.y
- && building->z == pos.z )
- {
- // don't set pointer if not constructed yet
- if(building->getBuildStage()!=building->getMaxBuildStage())
- break;
- cage = building;
- break;
- }
- }
- return cage;
- }
- bool isNestboxAtPos(int32_t x, int32_t y, int32_t z)
- {
- bool found = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( building->getType() == building_type::NestBox
- && building->x1 == x
- && building->y1 == y
- && building->z == z )
- {
- found = true;
- break;
- }
- }
- return found;
- }
- bool isFreeNestboxAtPos(int32_t x, int32_t y, int32_t z)
- {
- bool found = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( building->getType() == building_type::NestBox
- && building->x1 == x
- && building->y1 == y
- && building->z == z )
- {
- df::building_nest_boxst* nestbox = (df::building_nest_boxst*) building;
- if(nestbox->claimed_by == -1 && nestbox->contained_items.size() == 1)
- {
- found = true;
- break;
- }
- }
- }
- return found;
- }
- bool isEmptyPasture(df::building* building)
- {
- if(!isPenPasture(building))
- return false;
- df::building_civzonest * civ = (df::building_civzonest *) building;
- if(civ->assigned_creature.size() == 0)
- return true;
- else
- return false;
- }
- df::building* findFreeNestboxZone()
- {
- df::building * free_building = NULL;
- bool cage = false;
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- df::building* building = world->buildings.all[b];
- if( isEmptyPasture(building) &&
- isActive(building) &&
- isFreeNestboxAtPos(building->x1, building->y1, building->z))
- {
- free_building = building;
- break;
- }
- }
- return free_building;
- }
- bool isFreeEgglayer(df::unit * unit)
- {
- if( !isDead(unit) && !isUndead(unit)
- && isFemale(unit)
- && isTame(unit)
- && isOwnCiv(unit)
- && isEggLayer(unit)
- && !isAssigned(unit)
- && !isGrazer(unit) // exclude grazing birds because they're messy
- && !isMerchant(unit) // don't steal merchant mounts
- && !isForest(unit) // don't steal birds from traders, they hate that
- )
- return true;
- else
- return false;
- }
- df::unit * findFreeEgglayer()
- {
- df::unit* free_unit = NULL;
- for (size_t i=0; i < world->units.all.size(); i++)
- {
- df::unit* unit = world->units.all[i];
- if(isFreeEgglayer(unit))
- {
- free_unit = unit;
- break;
- }
- }
- return free_unit;
- }
- size_t countFreeEgglayers()
- {
- size_t count = 0;
- for (size_t i=0; i < world->units.all.size(); i++)
- {
- df::unit* unit = world->units.all[i];
- if(isFreeEgglayer(unit))
- count ++;
- }
- return count;
- }
- // check if unit is already assigned to a zone, remove that ref from unit and old zone
- // check if unit is already assigned to a cage, remove that ref from the cage
- // returns false if no cage or pasture information was found
- // helps as workaround for http://www.bay12games.com/dwarves/mantisbt/view.php?id=4475 by the way
- // (pastured animals assigned to chains will get hauled back and forth because the pasture ref is not deleted)
- bool unassignUnitFromBuilding(df::unit* unit)
- {
- bool success = false;
- for (std::size_t idx = 0; idx < unit->general_refs.size(); idx++)
- {
- df::general_ref * oldref = unit->general_refs[idx];
- switch(oldref->getType())
- {
- case df::general_ref_type::BUILDING_CIVZONE_ASSIGNED:
- {
- unit->general_refs.erase(unit->general_refs.begin() + idx);
- df::building_civzonest * oldciv = (df::building_civzonest *) oldref->getBuilding();
- for(size_t oc=0; oc<oldciv->assigned_creature.size(); oc++)
- {
- if(oldciv->assigned_creature[oc] == unit->id)
- {
- oldciv->assigned_creature.erase(oldciv->assigned_creature.begin() + oc);
- break;
- }
- }
- delete oldref;
- success = true;
- break;
- }
- case df::general_ref_type::CONTAINED_IN_ITEM:
- {
- // game does not erase the ref until creature gets removed from cage
- //unit->general_refs.erase(unit->general_refs.begin() + idx);
- // walk through buildings, check cages for inhabitants, compare ids
- for (size_t b=0; b < world->buildings.all.size(); b++)
- {
- bool found = false;
- df::building* building = world->buildings.all[b];
- if(isCage(building))
- {
- df::building_cagest* oldcage = (df::building_cagest*) building;
- for(size_t oc=0; oc<oldcage->assigned_creature.size(); oc++)
- {
- if(oldcage->assigned_creature[oc] == unit->id)
- {
- oldcage->assigned_creature.erase(oldcage->assigned_creature.begin() + oc);
- found = true;
- break;
- }
- }
- }
- if(found)
- break;
- }
- success = true;
- break;
- }
- case df::general_ref_type::BUILDING_CHAIN:
- {
- // try not erasing the ref and see what happens
- //unit->general_refs.erase(unit->general_refs.begin() + idx);
- // probably need to delete chain reference here
- //success = true;
- break;
- }
- case df::general_ref_type::BUILDING_CAGED:
- {
- // not sure what to do here, doesn't seem to get used by the game
- //unit->general_refs.erase(unit->general_refs.begin() + idx);
- //success = true;
- break;
- }
- default:
- {
- // some reference which probably shouldn't get deleted
- // (animals who are historical figures and have a NEMESIS reference or whatever)
- break;
- }
- }
- }
- return success;
- }
- // assign to pen or pit
- command_result assignUnitToZone(color_ostream& out, df::unit* unit, df::building* building, bool verbose = false)
- {
- // building must be a pen/pasture or pit
- if(!isPenPasture(building) && !isPitPond(building))
- {
- out << "Invalid building type. This is not a pen/pasture or pit/pond." << endl;
- return CR_WRONG_USAGE;
- }
- // try to get a fresh civzone ref
- df::general_ref_building_civzone_assignedst * ref = createCivzoneRef();
- if(!ref)
- {
- out << "Could not find a clonable activity zone reference" << endl
- << "You need to pen/pasture/pit at least one creature" << endl
- << "before using 'assign' for the first time." << endl;
- return CR_WRONG_USAGE;
- }
- // check if unit is already pastured, remove that ref from unit and old pasture
- // testing showed that removing the ref from the unit only seems to be necessary for pastured creatures
- // if they are in cages on stockpiles the game unassigns them automatically
- // if they are in built cages the pointer to the creature needs to be removed from the cage
- // TODO: check what needs to be done for chains
- bool cleared_old = unassignUnitFromBuilding(unit);
- if(verbose)
- {
- if(cleared_old)
- out << "old zone info cleared.";
- else
- out << "no old zone info found.";
- }
- ref->building_id = building->id;
- unit->general_refs.push_back(ref);
- df::building_civzonest * civz = (df::building_civzonest *) building;
- civz->assigned_creature.push_back(unit->id);
- out << "Unit " << unit->id
- << "(" << getRaceName(unit) << ")"
- << " assigned to zone " << building->id;
- if(isPitPond(building))
- out << " (pit/pond).";
- if(isPenPasture(building))
- out << " (pen/pasture).";
- out << endl;
- return CR_OK;
- }
- command_result assignUnitToCage(color_ostream& out, df::unit* unit, df::building* building, bool verbose)
- {
- // building must be a pen/pasture or pit
- if(!isCage(building))
- {
- out << "Invalid building type. This is not a cage." << endl;
- return CR_WRONG_USAGE;
- }
- // don't assign owned pets to a cage. the owner will release them, resulting into infinite hauling (df bug)
- if(unit->relations.pet_owner_id != -1)
- return CR_OK;
- // check if unit is already pastured or caged, remove refs where necessary
- bool cleared_old = unassignUnitFromBuilding(unit);
- if(verbose)
- {
- if(cleared_old)
- out << "old zone info cleared.";
- else
- out << "no old zone info found.";
- }
- //ref->building_id = building->id;
- //unit->general_refs.push_back(ref);
- df::building_cagest* civz = (df::building_cagest*) building;
- civz->assigned_creature.push_back(unit->id);
- out << "Unit " << unit->id
- << "(" << getRaceName(unit) << ")"
- << " assigned to cage " << building->id;
- out << endl;
- return CR_OK;
- }
- command_result assignUnitToChain(color_ostream& out, df::unit* unit, df::building* building, bool verbose)
- {
- out << "sorry. assigning to chains is not possible yet." << endl;
- return CR_WRONG_USAGE;
- }
- command_result assignUnitToBuilding(color_ostream& out, df::unit* unit, df::building* building, bool verbose)
- {
- command_result result = CR_WRONG_USAGE;
- if(isActivityZone(building))
- result = assignUnitToZone(out, unit, building, verbose);
- else if(isCage(building))
- result = assignUnitToCage(out, unit, building, verbose);
- else if(isChain(building))
- result = assignUnitToChain(out, unit, building, verbose);
- else
- out << "Cannot assign units to this type of building!" << endl;
- return result;
- }
- command_result assignUnitsToCagezone(color_ostream& out, vector<df::unit*> units, df::building* building, bool verbose)
- {
- command_result result = CR_WRONG_USAGE;
- if(!isPenPasture(building))
- {
- out << "A cage zone needs to be a pen/pasture containing at least one cage!" << endl;
- return CR_WRONG_USAGE;
- }
- int32_t x1 = building->x1;
- int32_t x2 = building->x2;
- int32_t y1 = building->y1;
- int32_t y2 = building->y2;
- int32_t z = building->z;
- vector <df::building_cagest*> cages;
- for (int32_t x = x1; x<=x2; x++)
- {
- for (int32_t y = y1; y<=y2; y++)
- {
- df::building* cage = getBuiltCageAtPos(df::coord(x,y,z));
- if(cage)
- {
- df::building_cagest* cagest = (df::building_cagest*) cage;
- cages.push_back(cagest);
- }
- }
- }
- if(!cages.size())
- {
- out << "No cages found in this zone!" << endl;
- return CR_WRONG_USAGE;
- }
- else
- {
- out << "Number of cages: " << cages.size() << endl;
- }
- while(units.size())
- {
- // hrm, better use sort() instead?
- df::building_cagest * bestcage = cages[0];
- size_t lowest = cages[0]->assigned_creature.size();
- for(size_t i=1; i<cages.size(); i++)
- {
- if(cages[i]->assigned_creature.size()<lowest)
- {
- lowest = cages[i]->assigned_creature.size();
- bestcage = cages[i];
- }
- }
- df::unit* unit = units.back();
- units.pop_back();
- command_result result = assignUnitToCage(out, unit, (df::building*) bestcage, verbose);
- if(result!=CR_OK)
- return result;
- }
- return CR_OK;
- }
- command_result nickUnitsInZone(color_ostream& out, df::building* building, string nick)
- {
- // building must be a pen/pasture or pit
- if(!isPenPasture(building) && !isPitPond(building))
- {
- out << "Invalid building type. This is not a pen/pasture or pit/pond." << endl;
- return CR_WRONG_USAGE;
- }
- df::building_civzonest * civz = (df::building_civzonest *) building;
- for(size_t i = 0; i < civz->assigned_creature.size(); i++)
- {
- df::unit* unit = findUnitById(civz->assigned_creature[i]);
- if(unit)
- Units::setNickname(unit, nick);
- }
- return CR_OK;
- }
- command_result nickUnitsInCage(color_ostream& out, df::building* building, string nick)
- {
- // building must be a pen/pasture or pit
- if(!isCage(building))
- {
- out << "Invalid building type. This is not a cage." << endl;
- return CR_WRONG_USAGE;
- }
- df::building_cagest* cage = (df::building_cagest*) building;
- for(size_t i=0; i<cage->assigned_creature.size(); i++)
- {
- df::unit* unit = findUnitById(cage->assigned_creature[i]);
- if(unit)
- Units::setNickname(unit, nick);
- }
- return CR_OK;
- }
- command_result nickUnitsInChain(color_ostream& out, df::building* building, string nick)
- {
- out << "sorry. nicknaming chained units is not possible yet." << endl;
- return CR_WRONG_USAGE;
- }
- // give all units inside a pasture or cage the same nickname
- // (usage example: protect them from being autobutchered)
- command_result nickUnitsInBuilding(color_ostream& out, df::building* building, string nick)
- {
- command_result result = CR_WRONG_USAGE;
- if(isActivityZone(building))
- result = nickUnitsInZone(out, building, nick);
- else if(isCage(building))
- result = nickUnitsInCage(out, building, nick);
- else if(isChain(building))
- result = nickUnitsInChain(out, building, nick);
- else
- out << "Cannot nickname units in this type of building!" << endl;
- return result;
- }
- // dump some zone info
- void zoneInfo(color_ostream & out, df::building* building, bool verbose)
- {
- if(building->getType()!= building_type::Civzone)
- return;
- if(building->getSubtype() != (short)civzone_type::ActivityZone)
- return;
- string name;
- building->getName(&name);
- out.print("Building %i - \"%s\" - type %s (%i)",
- building->id,
- name.c_str(),
- ENUM_KEY_STR(building_type, building->getType()).c_str(),
- building->getType());
- out.print(", subtype %s (%i)",
- ENUM_KEY_STR(civzone_type, (df::civzone_type)building->getSubtype()).c_str(),
- building->getSubtype());
- out.print("\n");
- df::building_civzonest * civ = (df::building_civzonest *) building;
- if(civ->zone_flags.bits.active)
- out << "active";
- else
- out << "not active";
- if(civ->zone_flags.bits.pen_pasture)
- out << ", pen/pasture";
- else if (civ->zone_flags.bits.pit_pond)
- {
- out << " (pit flags:" << civ->pit_flags.whole << ")";
- if(civ->pit_flags.bits.is_pond)
- out << ", pond";
- else
- out << ", pit";
- }
- out << endl;
- out << "x1:" <<building->x1
- << " x2:" <<building->x2
- << " y1:" <<building->y1
- << " y2:" <<building->y2
- << " z:" <<building->z
- << endl;
- int32_t creaturecount = civ->assigned_creature.size();
- out << "Creatures in this zone: " << creaturecount << endl;
- for(size_t c = 0; c < creaturecount; c++)
- {
- int32_t cindex = civ->assigned_creature.at(c);
- // print list of all units assigned to that zone
- for(size_t i = 0; i < world->units.all.size(); i++)
- {
- df::unit * creature = world->units.all[i];
- if(creature->id != cindex)
- continue;
- unitInfo(out, creature, verbose);
- }
- }
- }
- // dump some cage info
- void cageInfo(color_ostream & out, df::building* building, bool verbose)
- {
- if(!isCage(building))
- return;
- string name;
- building->getName(&name);
- out.print("Building %i - \"%s\" - type %s (%i)",
- building->id,
- name.c_str(),
- ENUM_KEY_STR(building_type, building->getType()).c_str(),
- building->getType());
- out.print("\n");
- out << "x:" << building->x1
- << " y:" << building->y1
- << " z:" << building->z
- << endl;
- df::building_cagest * cage = (df::building_cagest*) building;
- int32_t creaturecount = cage->assigned_creature.size();
- out << "Creatures in this cage: " << creaturecount << endl;
- for(size_t c = 0; c < creaturecount; c++)
- {
- int32_t cindex = cage->assigned_creature.at(c);
- // print list of all units assigned to that cage
- for(size_t i = 0; i < world->units.all.size(); i++)
- {
- df::unit * creature = world->units.all[i];
- if(creature->id != cindex)
- continue;
- unitInfo(out, creature, verbose);
- }
- }
- }
- // dump some chain/restraint info
- void chainInfo(color_ostream & out, df::building* building, bool list_refs = false)
- {
- if(!isChain(building))
- return;
- string name;
- building->getName(&name);
- out.print("Building %i - \"%s\" - type %s (%i)",
- building->id,
- name.c_str(),
- ENUM_KEY_STR(building_type, building->getType()).c_str(),
- building->getType());
- out.print("\n");
- df::building_chainst* chain = (df::building_chainst*) building;
- if(chain->assigned)
- {
- out << "assigned: ";
- unitInfo(out, chain->assigned, true);
- }
- if(chain->chained)
- {
- out << "chained: ";
- unitInfo(out, chain->chained, true);
- }
- }
- command_result df_zone (color_ostream &out, vector <string> & parameters)
- {
- CoreSuspender suspend;
- bool need_cursor = false; // for zone_info, zone_assign, ...
- bool unit_info = false;
- bool zone_info = false;
- //bool cage_info = false;
- //bool chain_info = false;
- bool invert_filter = false;
- bool find_unassigned = false;
- bool find_caged = false;
- bool find_not_caged = false;
- bool find_trainable_war = false;
- bool find_not_trainable_war = false;
- bool find_trainable_hunting = false;
- bool find_not_trainable_hunting = false;
- bool find_trained = false;
- bool find_not_trained = false;
- bool find_war = false;
- bool find_not_war = false;
- bool find_hunter = false;
- bool find_not_hunter = false;
- bool find_own = false;
- bool find_not_own = false;
- bool find_tame = false;
- bool find_not_tame = false;
- bool find_merchant = false;
- bool find_not_merchant = false;
- bool find_male = false;
- bool find_not_male = false;
- bool find_female = false;
- bool find_not_female = false;
- bool find_egglayer = false;
- bool find_not_egglayer = false;
- bool find_grazer = false;
- bool find_not_grazer = false;
- bool find_milkable = false;
- bool find_not_milkable = false;
- bool find_named = false;
- bool find_not_named = false;
- bool find_naked = false;
- bool find_not_naked = false;
- bool find_tamable = false;
- bool find_not_tamable = false;
- bool find_agemin = false;
- bool find_agemax = false;
- int target_agemin = 0;
- int target_agemax = 0;
- bool find_count = false;
- size_t target_count = 0;
- bool find_race = false;
- bool find_not_race = false;
- string target_race = "";
- bool building_assign = false;
- bool building_unassign = false;
- bool building_set = false;
- bool cagezone_assign = false;
- bool verbose = false;
- bool all = false;
- bool unit_slaughter = false;
- static int target_building = -1;
- bool nick_set = false;
- string target_nick = "";
- for (size_t i = 0; i < parameters.size(); i++)
- {
- string & p = parameters[i];
- if (p == "help" || p == "?")
- {
- out << zone_help << endl;
- return CR_OK;
- }
- if (p == "filters")
- {
- out << zone_help_filters << endl;
- return CR_OK;
- }
- if (p == "examples")
- {
- out << zone_help_examples << endl;
- return CR_OK;
- }
- else if(p == "zinfo")
- {
- zone_info = true;
- invert_filter=false;
- }
- else if(p == "uinfo")
- {
- unit_info = true;
- invert_filter=false;
- }
- else if(p == "verbose")
- {
- verbose = true;
- if(invert_filter)
- {
- verbose = false;
- invert_filter=false;
- }
- }
- else if(p == "unassign")
- {
- if(invert_filter)
- {
- out << "'not unassign' makes no sense." << endl;
- return CR_WRONG_USAGE;
- }
- building_unassign = true;
- }
- else if(p == "assign")
- {
- if(invert_filter)
- {
- out << "'not assign' makes no sense. (did you want to use unassign?)" << endl;
- return CR_WRONG_USAGE;
- }
- // if followed by another parameter, check if it's numeric
- if(i < parameters.size()-1)
- {
- auto & str = parameters[i+1];
- if(str.size() > 0 && str[0] >= '0' && str[0] <= '9')
- {
- stringstream ss(parameters[i+1]);
- int new_building = -1;
- ss >> new_building;
- if(new_building != -1)
- {
- i++;
- target_building = new_building;
- out << "Assign selected unit(s) to building #" << target_building <<std::endl;
- }
- }
- }
- if(target_building == -1)
- {
- out.printerr("No building id specified and current one is invalid!\n");
- return CR_WRONG_USAGE;
- }
- else
- {
- out << "No buiding id specified. Will try to use #" << target_building << endl;
- building_assign = true;
- }
- }
- else if(p == "tocages")
- {
- if(invert_filter)
- {
- out << "'not tocages' makes no sense." << endl;
- return CR_WRONG_USAGE;
- }
- // if followed by another parameter, check if it's numeric
- if(i < parameters.size()-1)
- {
- stringstream ss(parameters[i+1]);
- int new_building = -1;
- ss >> new_building;
- if(new_building != -1)
- {
- i++;
- target_building = new_building;
- out << "Assign selected unit(s) to cagezone #" << target_building <<std::endl;
- }
- }
- if(target_building == -1)
- {
- out.printerr("No building id specified and current one is invalid!\n");
- return CR_WRONG_USAGE;
- }
- else
- {
- out << "No buiding id specified. Will try to use #" << target_building << endl;
- cagezone_assign = true;
- }
- }
- else if(p == "race" && !invert_filter)
- {
- if(i == parameters.size()-1)
- {
- out.printerr("No race id specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- target_race = parameters[i+1];
- i++;
- out << "Filter by race " << target_race << endl;
- find_race = true;
- }
- }
- else if(p == "race" && invert_filter)
- {
- if(i == parameters.size()-1)
- {
- out.printerr("No race id specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- target_race = parameters[i+1];
- i++;
- out << "Excluding race: " << target_race << endl;
- find_not_race = true;
- }
- invert_filter = false;
- }
- else if(p == "not")
- {
- invert_filter = true;
- }
- else if(p == "unassigned")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- out << "Filter by 'unassigned'." << endl;
- find_unassigned = true;
- }
- else if(p == "caged" && !invert_filter)
- {
- out << "Filter by 'caged' (ignores built cages)." << endl;
- find_caged = true;
- }
- else if(p == "caged" && invert_filter)
- {
- out << "Filter by 'not caged'." << endl;
- find_not_caged = true;
- invert_filter = false;
- }
- else if(p == "trained" && !invert_filter)
- {
- out << "Filter by 'trained'." << endl;
- find_trained = true;
- }
- else if(p == "trained" && invert_filter)
- {
- out << "Filter by 'untrained'." << endl;
- find_not_trained = true;
- invert_filter = false;
- }
- else if(p == "trainablewar" && !invert_filter)
- {
- out << "Filter by 'trainable for war'." << endl;
- find_trainable_war = true;
- }
- else if(p == "trainablewar" && invert_filter)
- {
- out << "Filter by 'not trainable for war'." << endl;
- find_not_trainable_war = true;
- invert_filter = false;
- }
- else if(p == "trainablehunt"&& !invert_filter)
- {
- out << "Filter by 'trainable for hunting'." << endl;
- find_trainable_hunting = true;
- }
- else if(p == "trainablehunt"&& invert_filter)
- {
- out << "Filter by 'not trainable for hunting'." << endl;
- find_not_trainable_hunting = true;
- invert_filter = false;
- }
- else if(p == "war" && !invert_filter)
- {
- out << "Filter by 'trained war creature'." << endl;
- find_war = true;
- }
- else if(p == "war" && invert_filter)
- {
- out << "Filter by 'not a trained war creature'." << endl;
- find_not_war = true;
- invert_filter = false;
- }
- else if(p == "hunting" && !invert_filter)
- {
- out << "Filter by 'trained hunting creature'." << endl;
- find_hunter = true;
- }
- else if(p == "hunting" && invert_filter)
- {
- out << "Filter by 'not a trained hunting creature'." << endl;
- find_not_hunter = true;
- invert_filter = false;
- }else if(p == "own"&& !invert_filter)
- {
- out << "Filter by 'own civilization'." << endl;
- find_own = true;
- }
- else if(p == "own" && invert_filter)
- {
- out << "Filter by 'not own' (i.e. not from the fortress civ, can be a dwarf)." << endl;
- find_not_own = true;
- invert_filter = false;
- }
- else if(p == "tame" && !invert_filter)
- {
- out << "Filter by 'tame'." << endl;
- find_tame = true;
- }
- else if(p == "tame" && invert_filter)
- {
- out << "Filter by 'not tame'." << endl;
- find_not_tame = true;
- invert_filter=false;
- }
- else if(p == "named" && !invert_filter)
- {
- out << "Filter by 'has name or nickname'." << endl;
- find_named = true;
- }
- else if(p == "named" && invert_filter)
- {
- out << "Filter by 'has no name or nickname'." << endl;
- find_not_named = true;
- invert_filter=false;
- }
- else if(p == "slaughter")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- out << "Assign animals for slaughter." << endl;
- unit_slaughter = true;
- }
- else if(p == "count")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- if(i == parameters.size()-1)
- {
- out.printerr("No count specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- stringstream ss(parameters[i+1]);
- i++;
- ss >> target_count;
- if(target_count <= 0)
- {
- out.printerr("Invalid count specified (must be > 0)!");
- return CR_WRONG_USAGE;
- }
- find_count = true;
- out << "Process up to " << target_count << " units." << endl;
- }
- }
- else if(p == "age")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- if(i == parameters.size()-1)
- {
- out.printerr("No age specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- stringstream ss(parameters[i+1]);
- i++;
- ss >> target_agemin;
- ss >> target_agemax;
- find_agemin = true;
- find_agemax = true;
- out << "Filter by exact age of " << target_agemin << endl;
- }
- }
- else if(p == "minage")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- if(i == parameters.size()-1)
- {
- out.printerr("No age specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- stringstream ss(parameters[i+1]);
- i++;
- ss >> target_agemin;
- find_agemin = true;
- out << "Filter by minimum age of " << target_agemin << endl;
- }
- }
- else if(p == "maxage")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- if(i == parameters.size()-1)
- {
- out.printerr("No age specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- stringstream ss(parameters[i+1]);
- i++;
- ss >> target_agemax;
- find_agemax = true;
- out << "Filter by maximum age of " << target_agemax << endl;
- }
- }
- else if(p == "male" && !invert_filter)
- {
- find_male = true;
- }
- else if(p == "female" && !invert_filter)
- {
- find_female = true;
- }
- else if(p == "egglayer" && !invert_filter)
- {
- find_egglayer = true;
- }
- else if(p == "egglayer" && invert_filter)
- {
- find_not_egglayer = true;
- invert_filter=false;
- }
- else if(p == "naked" && !invert_filter)
- {
- find_naked = true;
- }
- else if(p == "naked" && invert_filter)
- {
- find_not_naked = true;
- invert_filter=false;
- }
- else if(p == "tamable" && !invert_filter)
- {
- find_tamable = true;
- }
- else if(p == "tamable" && invert_filter)
- {
- find_not_tamable = true;
- invert_filter=false;
- }
- else if(p == "grazer" && !invert_filter)
- {
- find_grazer = true;
- }
- else if(p == "grazer" && invert_filter)
- {
- find_not_grazer = true;
- invert_filter=false;
- }
- else if(p == "merchant" && !invert_filter)
- {
- find_merchant = true;
- }
- else if(p == "merchant" && invert_filter)
- {
- // actually 'not merchant' is pointless since merchant units are ignored by default
- find_not_merchant = true;
- invert_filter=false;
- }
- else if(p == "milkable" && !invert_filter)
- {
- find_milkable = true;
- }
- else if(p == "milkable" && invert_filter)
- {
- find_not_milkable = true;
- invert_filter=false;
- }
- else if(p == "set")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- building_set = true;
- }
- else if(p == "nick")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- if(i == parameters.size()-1)
- {
- out.printerr("No nickname specified! Use 'remnick' to remove nicknames!");
- return CR_WRONG_USAGE;
- }
- nick_set = true;
- target_nick = parameters[i+1];
- i++;
- out << "Set nickname to: " << target_nick << endl;
- }
- else if(p == "remnick")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- nick_set = true;
- target_nick = "";
- i++;
- out << "Remove nickname." << endl;
- }
- else if(p == "all")
- {
- if(invert_filter)
- return CR_WRONG_USAGE;
- out << "Filter: all" << endl;
- all = true;
- }
- else
- {
- out << "Unknown command: " << p << endl;
- return CR_WRONG_USAGE;
- }
- }
- if (!Maps::IsValid())
- {
- out.printerr("Map is not available!\n");
- return CR_FAILURE;
- }
- if((zone_info && !all) || building_set)
- need_cursor = true;
- if(need_cursor && cursor->x == -30000)
- {
- out.printerr("No cursor; place cursor over activity zone.\n");
- return CR_FAILURE;
- }
- // search for male and not male is exclusive, so drop the flags if both are specified
- if(find_male && find_not_male)
- {
- find_male=false;
- find_not_male=false;
- }
- // search for female and not female is exclusive, so drop the flags if both are specified
- if(find_female && find_not_female)
- {
- find_female=false;
- find_not_female=false;
- }
- // search for male and female is exclusive, so drop the flags if both are specified
- if(find_male && find_female)
- {
- find_male=false;
- find_female=false;
- }
- // search for trained and untrained is exclusive, so drop the flags if both are specified
- if(find_trained && find_not_trained)
- {
- find_trained=false;
- find_not_trained=false;
- }
- // search for grazer and nograzer is exclusive, so drop the flags if both are specified
- if(find_grazer && find_not_grazer)
- {
- find_grazer=false;
- find_not_grazer=false;
- }
- // todo: maybe add this type of sanity check for all remaining bools, maybe not (lots of code just to avoid parsing dumb input)
- // try to cope with user dumbness
- if(target_agemin > target_agemax)
- {
- out << "Invalid values for minage/maxage specified! I'll swap them." << endl;
- int oldmin = target_agemin;
- target_agemin = target_agemax;
- target_agemax = oldmin;
- }
- // give info on zone(s), chain or cage under cursor
- // (doesn't use the findXyzAtCursor() methods because zones might overlap and contain a cage or chain)
- if(zone_info) // || chain_info || cage_info)
- {
- for (size_t b = 0; b < world->buildings.all.size(); b++)
- {
- df::building * building = world->buildings.all[b];
- // find building under cursor
- if (!all &&
- !(building->x1 <= cursor->x && cursor->x <= building->x2 &&
- building->y1 <= cursor->y && cursor->y <= building->y2 &&
- building->z == cursor->z))
- continue;
- zoneInfo(out, building, verbose);
- chainInfo(out, building, verbose);
- cageInfo(out, building, verbose);
- }
- return CR_OK;
- }
- // set building at cursor position to be new target building
- if(building_set)
- {
- // cagezone wants a pen/pit as starting point
- if(!cagezone_assign)
- target_building = findCageAtCursor();
- if(target_building != -1)
- {
- out << "Target building type: cage." << endl;
- }
- else
- {
- target_building = findPenPitAtCursor();
- if(target_building == -1)
- {
- out << "No pen/pasture or pit under cursor!" << endl;
- return CR_WRONG_USAGE;
- }
- else
- {
- out << "Target building type: pen/pasture or pit." << endl;
- }
- }
- out << "Current building set to #" << target_building << endl;
- return CR_OK;
- }
- if(building_assign || cagezone_assign || unit_info || unit_slaughter || nick_set)
- {
- df::building * building;
- if(building_assign || cagezone_assign || (nick_set && !all && !find_count))
- {
- // try to get building index from the id
- int32_t index = findBuildingIndexById(target_building);
- if(index == -1)
- {
- out << "Invalid building id." << endl;
- target_building = -1;
- return CR_WRONG_USAGE;
- }
- building = world->buildings.all.at(index);
- if(nick_set && !building_assign)
- {
- out << "Renaming all units in target building." << endl;
- return nickUnitsInBuilding(out, building, target_nick);
- }
- }
- if(all || find_count)
- {
- vector <df::unit*> units_for_cagezone;
- size_t count = 0;
- for(size_t c = 0; c < world->units.all.size(); c++)
- {
- df::unit *unit = world->units.all[c];
- // ignore dead and undead units
- if (isDead(unit) || isUndead(unit))
- continue;
- // ignore merchant units by default
- if (!find_merchant && (isMerchant(unit) || isForest(unit)))
- continue;
- // but allow pitting them and stealing from them if specified :)
- if (find_merchant && !isMerchant(unit) && !isForest(unit))
- continue;
- if(find_race && getRaceName(unit) != target_race)
- continue;
- if(find_not_race && getRaceName(unit) == target_race)
- continue;
- // ignore own dwarves by default
- if(isOwnCiv(unit) && isOwnRace(unit))
- {
- if(!find_race)
- {
- continue;
- }
- }
- if( (find_unassigned && isAssigned(unit))
- // avoid tampering with creatures who are currently being hauled to a built cage
- || (isContainedInItem(unit) && (find_not_caged || isInBuiltCage(unit)))
- || (isChained(unit))
- || (find_caged && !isContainedInItem(unit))
- || (find_not_caged && isContainedInItem(unit))
- || (find_own && !isOwnCiv(unit))
- || (find_not_own && isOwnCiv(unit))
- || (find_tame && !isTame(unit))
- || (find_not_tame && isTame(unit))
- || (find_trained && !isTrained(unit))
- || (find_not_trained && isTrained(unit))
- || (find_war && !isWar(unit))
- || (find_not_war && isWar(unit))
- || (find_hunter && !isHunter(unit))
- || (find_not_hunter && isHunter(unit))
- || (find_agemin && getUnitAge(unit)<target_agemin)
- || (find_agemax && getUnitAge(unit)>target_agemax)
- || (find_grazer && !isGrazer(unit))
- || (find_not_grazer && isGrazer(unit))
- || (find_egglayer && !isEggLayer(unit))
- || (find_not_egglayer && isEggLayer(unit))
- || (find_milkable && !isMilkable(unit))
- || (find_not_milkable && isMilkable(unit))
- || (find_male && !isMale(unit))
- || (find_not_male && isMale(unit))
- || (find_female && !isFemale(unit))
- || (find_not_female && isFemale(unit))
- || (find_named && !unit->name.has_name)
- || (find_not_named && unit->name.has_name)
- || (find_naked && !isNaked(unit))
- || (find_not_naked && isNaked(unit))
- || (find_tamable && !isTamable(unit))
- || (find_not_tamable && isTamable(unit))
- || (find_trainable_war && (isWar(unit) || isHunter(unit) || !isTrainableWar(unit)))
- || (find_not_trainable_war && isTrainableWar(unit)) // hm, is this check enough?
- || (find_trainable_hunting && (isWar(unit) || isHunter(unit) || !isTrainableHunting(unit)))
- || (find_not_trainable_hunting && isTrainableHunting(unit)) // hm, is this check enough?
- )
- continue;
- // animals bought in cages have an invalid map pos until they are freed for the first time
- // but if they are not in a cage and have an invalid pos it's better not to touch them
- if(!isContainedInItem(unit) && !hasValidMapPos(unit))
- {
- if(verbose)
- {
- out << "----------"<<endl;
- out << "invalid unit pos but not in cage either. will skip this unit." << endl;
- unitInfo(out, unit, verbose);
- out << "----------"<<endl;
- }
- continue;
- }
- if(unit_info)
- {
- unitInfo(out, unit, verbose);
- continue;
- }
- if(nick_set)
- {
- Units::setNickname(unit, target_nick);
- }
- if(cagezone_assign)
- {
- units_for_cagezone.push_back(unit);
- }
- else if(building_assign)
- {
- command_result result = assignUnitToBuilding(out, unit, building, verbose);
- if(result != CR_OK)
- return result;
- }
- if(unit_slaughter)
- {
- // don't slaughter named creatures unless told to do so
- if(!unit->name.has_name || find_named)
- doMarkForSlaughter(unit);
- }
- count++;
- if(find_count && count >= target_count)
- break;
- }
- if(cagezone_assign)
- {
- command_result result = assignUnitsToCagezone(out, units_for_cagezone, building, verbose);
- if(result != CR_OK)
- return result;
- }
- out << "Processed creatures: " << count << endl;
- }
- else
- {
- // must have unit selected
- df::unit *unit = getSelectedUnit(out, true);
- if (!unit)
- return CR_WRONG_USAGE;
- if(unit_info)
- {
- unitInfo(out, unit, verbose);
- return CR_OK;
- }
- else if(building_assign)
- {
- return assignUnitToBuilding(out, unit, building, verbose);
- }
- else if(unit_slaughter)
- {
- // by default behave like the game? only allow slaughtering of named war/hunting pets
- //if(unit->name.has_name && !find_named && !(isWar(unit)||isHunter(unit)))
- //{
- // out << "Slaughter of named unit denied. Use the filter 'named' to override this check." << endl;
- // return CR_OK;
- //}
- doMarkForSlaughter(unit);
- return CR_OK;
- }
- }
- }
- // de-assign from pen or pit
- // using the zone tool to free creatures from cages or chains
- // is pointless imo since that is already quite easy using the ingame UI.
- // but it's easy to implement so I might as well add it later
- if(building_unassign)
- {
- // must have unit selected
- df::unit *unit = getSelectedUnit(out, true);
- if (!unit)
- return CR_WRONG_USAGE;
- // remove assignment reference from unit and old zone
- if(unassignUnitFromBuilding(unit))
- out << "Unit unassigned." << endl;
- else
- out << "Unit is not assigned to an activity zone!" << endl;
- return CR_OK;
- }
- return CR_OK;
- }
- ////////////////////
- // autonestbox stuff
- command_result df_autonestbox(color_ostream &out, vector <string> & parameters)
- {
- CoreSuspender suspend;
- bool verbose = false;
- for (size_t i = 0; i < parameters.size(); i++)
- {
- string & p = parameters[i];
- if (p == "help" || p == "?")
- {
- out << autonestbox_help << endl;
- return CR_OK;
- }
- if (p == "start")
- {
- autonestbox_did_complain = false;
- start_autonestbox(out);
- return autoNestbox(out, verbose);
- }
- if (p == "stop")
- {
- enable_autonestbox = false;
- if(config_autonestbox.isValid())
- config_autonestbox.ival(0) = 0;
- out << "Autonestbox stopped." << endl;
- return CR_OK;
- }
- else if(p == "verbose")
- {
- verbose = true;
- }
- else if(p == "sleep")
- {
- if(i == parameters.size()-1)
- {
- out.printerr("No duration specified!");
- return CR_WRONG_USAGE;
- }
- else
- {
- size_t ticks = 0;
- stringstream ss(parameters[i+1]);
- i++;
- ss >> ticks;
- if(ticks <= 0)
- {
- out.printerr("Invalid duration specified (must be > 0)!");
- return CR_WRONG_USAGE;
- }
- sleep_autonestbox = ticks;
- if(config_autonestbox.isValid())
- config_autonestbox.ival(1) = sleep_autonestbox;
- out << "New sleep timer for autonestbox: " << ticks << " ticks." << endl;
- return CR_OK;
- }
- }
- else
- {
- out << "Unknown command: " << p << endl;
- return CR_WRONG_USAGE;
- }
- }
- return autoNestbox(out, verbose);
- }
- command_result autoNestbox( color_ostream &out, bool verbose = false )
- {
- bool stop = false;
- size_t processed = 0;
- if (!Maps::IsValid())
- {
- out.printerr("Map is not available!\n");
- enable_autonestbox = false;
- return CR_FAILURE;
- }
- do
- {
- df::building * free_building = findFreeNestboxZone();
- df::unit * free_unit = findFreeEgglayer();
- if(free_building && free_unit)
- {
- command_result result = assignUnitToBuilding(out, free_unit, free_building, verbose);
- if(result != CR_OK)
- return result;
- processed ++;
- }
- else
- {
- stop = true;
- if(free_unit && !free_building)
- {
- static size_t old_count = 0;
- size_t freeEgglayers = countFreeEgglayers();
- // avoid spamming the same message
- if(old_count != freeEgglayers)
- autonestbox_did_complain = false;
- old_count = freeEgglayers;
- if(!autonestbox_did_complain)
- {
- stringstream ss;
- ss << freeEgglayers;
- string announce = "Not enough free nestbox zones found! You need " + ss.str() + " more.";
- Gui::showAnnouncement(announce, 6, true);
- out << announce << endl;
- autonestbox_did_complain = true;
- }
- }
- }
- } while (!stop);
- if(processed > 0)
- {
- stringstream ss;
- ss << processed;
- string announce;
- announce = ss.str() + " nestboxes were assigned.";
- Gui::showAnnouncement(announce, 2, false);
- out << announce << endl;
- // can complain again
- // (might lead to spamming the same message twice, but catches the case
- // where for example 2 new egglayers hatched right after 2 zones were created and assigned)
- autonestbox_did_complain = false;
- }
- return CR_OK;
- }
- ////////////////////
- // autobutcher stuff
- // getUnitAge() returns 0 if born in current year, therefore the look at birth_time in that case
- // (assuming that the value from there indicates in which tick of the current year the unit was born)
- bool compareUnitAgesYounger(df::unit* i, df::unit* j)
- {
- int32_t age_i = getUnitAge(i);
- int32_t age_j = getUnitAge(j);
- if(age_i == 0 && age_j == 0)
- {
- age_i = i->relations.birth_time;
- age_j = j->relations.birth_time;
- }
- return (age_i < age_j);
- }
- bool compareUnitAgesOlder(df::unit* i, df::unit* j)
- {
- int32_t age_i = getUnitAge(i);
- int32_t age_j = getUnitAge(j);
- if(age_i == 0 && age_j == 0)
- {
- age_i = i->relations.birth_time;
- age_j = j->relations.birth_time;
- }
- return (age_i > age_j);
- }
- //enum WatchedRaceSubtypes
- //{
- // femaleKid=0,
- // maleKid,
- // femaleAdult,
- // maleAdult
- //};
- struct WatchedRace
- {
- public:
- PersistentDataItem rconfig;
- bool isWatched; // if true, autobutcher will process this race
- int raceId;
- int fk; // max female kids
- int mk; // max male kids
- int fa; // max female adults
- int ma; // max male adults
- // bah, this should better be an array of 4 vectors
- // that way there's no need for the 4 ugly process methods
- vector <df::unit*> fk_ptr;
- vector <df::unit*> mk_ptr;
- vector <df::unit*> fa_ptr;
- vector <df::unit*> ma_ptr;
- WatchedRace(bool watch, int id, int _fk, int _mk, int _fa, int _ma)
- {
- isWatched = watch;
- raceId = id;
- fk = _fk;
- mk = _mk;
- fa = _fa;
- ma = _ma;
- }
- ~WatchedRace()
- {
- ClearUnits();
- }
- void UpdateConfig(color_ostream & out)
- {
- if(!rconfig.isValid())
- {
- string keyname = "autobutcher/watchlist/" + getRaceName(raceId);
- rconfig = World::GetPersistentData(keyname, NULL);
- }
- if(rconfig.isValid())
- {
- rconfig.ival(0) = raceId;
- rconfig.ival(1) = isWatched;
- rconfig.ival(2) = fk;
- rconfig.ival(3) = mk;
- rconfig.ival(4) = fa;
- rconfig.ival(5) = ma;
- }
- else
- {
- // this should never happen
- string keyname = "autobutcher/watchlist/" + getRaceName(raceId);
- out << "Something failed, could not find/create config key " << keyname << "!" << endl;
- }
- }
- void RemoveConfig(color_ostream & out)
- {
- if(!rconfig.isValid())
- return;
- World::DeletePersistentData(rconfig);
- }
- void SortUnitsByAge()
- {
- sort(fk_ptr.begin(), fk_ptr.end(), compareUnitAgesOlder);
- sort(mk_ptr.begin(), mk_ptr.end(), compareUnitAgesOlder);
- sort(fa_ptr.begin(), fa_ptr.end(), compareUnitAgesYounger);
- sort(ma_ptr.begin(), ma_ptr.end(), compareUnitAgesYounger);
- }
- void PushUnit(df::unit * unit)
- {
- if(isFemale(unit))
- {
- if(isBaby(unit) || isChild(unit))
- fk_ptr.push_back(unit);
- else
- fa_ptr.push_back(unit);
- }
- else //treat sex n/a like it was male
- {
- if(isBaby(unit) || isChild(unit))
- mk_ptr.push_back(unit);
- else
- ma_ptr.push_back(unit);
- }
- }
- void ClearUnits()
- {
- fk_ptr.clear();
- mk_ptr.clear();
- fa_ptr.clear();
- ma_ptr.clear();
- }
- int ProcessUnits_fk()
- {
- int subcount = 0;
- while(fk_ptr.size() > fk)
- {
- df::unit* unit = fk_ptr.back();
- doMarkForSlaughter(unit);
- fk_ptr.pop_back();
- subcount++;
- }
- return subcount;
- }
- int ProcessUnits_mk()
- {
- int subcount = 0;
- while(mk_ptr.size() > mk)
- {
- df::unit* unit = mk_ptr.back();
- doMarkForSlaughter(unit);
- mk_ptr.pop_back();
- subcount++;
- }
- return subcount;
- }
- int ProcessUnits_fa()
- {
- int subcount = 0;
- while(fa_ptr.size() > fa)
- {
- df::unit* unit = fa_ptr.back();
- doMarkForSlaughter(unit);
- fa_ptr.pop_back();
- subcount++;
- }
- return subcount;
- }
- int ProcessUnits_ma()
- {
- int subcount = 0;
- while(ma_ptr.size() > ma)
- {
- df::unit* unit = ma_ptr.back();
- doMarkForSlaughter(unit);
- ma_ptr.pop_back();
- subcount++;
- }
- return subcount;
- }
- int ProcessUnits()
- {
- SortUnitsByAge();
- int slaughter_count = 0;
- slaughter_count += ProcessUnits_fk();
- slaughter_count += ProcessUnits_mk();
- slaughter_count += ProcessUnits_fa();
- slaughter_count += ProcessUnits_ma();
- ClearUnits();
- return slaughter_count;
- }
- };
- // vector of races handled by autobutcher
- // the name is a bit misleading since entries can be set to 'unwatched'
- // to ignore them for a while but still keep the target count settings
- std::vector<WatchedRace*> watched_races;
- // default target values for autobutcher
- static int default_fk = 5;
- static int default_mk = 1;
- static int default_fa = 5;
- static int default_ma = 1;
- command_result df_autobutcher(color_ostream &out, vector <string> & parameters)
- {
- CoreSuspender suspend;
- bool verbose = false;
- bool watch_race = false;
- bool unwatch_race = false;
- bool forget_race = false;
- bool list_watched = false;
- bool list_export = false;
- bool change_target = false;
- vector <string> target_racenames;
- vector <int> target_raceids;
- int target_fk = default_fk;
- int target_mk = default_mk;
- int target_fa = default_fa;
- int target_ma = default_ma;
- int32_t target_raceid = -1;
- if(!parameters.size())
- {
- out << "You must specify a command!" << endl;
- out << autobutcher_help << endl;
- return CR_OK;
- }
- // parse main command
- string & p = parameters[0];
- if (p == "help" || p == "?")
- {
- out << autobutcher_help << endl;
- return CR_OK;
- }
- if (p == "example")
- {
- out << autobutcher_help_example << endl;
- return CR_OK;
- }
- else if (p == "start")
- {
- enable_autobutcher = true;
- start_autobutcher(out);
- return autoButcher(out, verbose);
- }
- else if (p == "stop")
- {
- enable_autobutcher = false;
- if(config_autobutcher.isValid())
- config_autobutcher.ival(0) = enable_autobutcher;
- out << "Autobutcher stopped." << endl;
- return CR_OK;
- }
- else if(p == "sleep")
- {
- parameters.erase(parameters.begin());
- if(!parameters.size())
- {
- out.printerr("No duration specified!\n");
- return CR_WRONG_USAGE;
- }
- else
- {
- size_t ticks = 0;
- stringstream ss(parameters.back());
- ss >> ticks;
- if(ticks <= 0)
- {
- out.printerr("Invalid duration specified (must be > 0)!\n");
- return CR_WRONG_USAGE;
- }
- sleep_autobutcher = ticks;
- if(config_autobutcher.isValid())
- config_autobutcher.ival(1) = sleep_autobutcher;
- out << "New sleep timer for autobutcher: " << ticks << " ticks." << endl;
- return CR_OK;
- }
- }
- else if(p == "watch")
- {
- parameters.erase(parameters.begin());
- watch_race = true;
- out << "Start watching race(s): "; // << endl;
- }
- else if(p == "unwatch")
- {
- parameters.erase(parameters.begin());
- unwatch_race = true;
- out << "Stop watching race(s): "; // << endl;
- }
- else if(p == "forget")
- {
- parameters.erase(parameters.begin());
- forget_race = true;
- out << "Removing race(s) from watchlist: "; // << endl;
- }
- else if(p == "target")
- {
- // needs at least 5 more parameters:
- // fk mk fa ma R (can have more than 1 R)
- if(parameters.size() < 6)
- {
- out.printerr("Not enough parameters!\n");
- return CR_WRONG_USAGE;
- }
- else
- {
- stringstream fk(parameters[1]);
- stringstream mk(parameters[2]);
- stringstream fa(parameters[3]);
- stringstream ma(parameters[4]);
- fk >> target_fk;
- mk >> target_mk;
- fa >> target_fa;
- ma >> target_ma;
- parameters.erase(parameters.begin(), parameters.begin()+5);
- change_target = true;
- out << "Setting new target count for race(s): "; // << endl;
- }
- }
- else if(p == "autowatch")
- {
- out << "Auto-adding to watchlist started." << endl;
- enable_autobutcher_autowatch = true;
- if(config_autobutcher.isValid())
- config_autobutcher.ival(2) = enable_autobutcher_autowatch;
- return CR_OK;
- }
- else if(p == "noautowatch")
- {
- out << "Auto-adding to watchlist stopped." << endl;
- enable_autobutcher_autowatch = false;
- if(config_autobutcher.isValid())
- config_autobutcher.ival(2) = enable_autobutcher_autowatch;
- return CR_OK;
- }
- else if(p == "list")
- {
- list_watched = true;
- }
- else if(p == "list_export")
- {
- list_export = true;
- }
- else
- {
- out << "Unknown command: " << p << endl;
- return CR_WRONG_USAGE;
- }
- if(list_watched)
- {
- out << "Autobutcher status: ";
- if(enable_autobutcher)
- out << "enabled,";
- else
- out << "not enabled,";
- if (enable_autobutcher_autowatch)
- out << " autowatch,";
- else
- out << " noautowatch,";
- out << " sleep: " << sleep_autobutcher << endl;
- out << "Default setting for new races:"
- << " fk=" << default_fk
- << " mk=" << default_mk
- << " fa=" << default_fa
- << " ma=" << default_ma
- << endl;
- if(!watched_races.size())
- {
- out << "The autobutcher race list is empty." << endl;
- return CR_OK;
- }
- out << "Races on autobutcher list: " << endl;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- df::creature_raw * raw = df::global::world->raws.creatures.all[w->raceId];
- string name = raw->creature_id;
- if(w->isWatched)
- out << "watched: ";
- else
- out << "not watched: ";
- out << name
- << " fk=" << w->fk
- << " mk=" << w->mk
- << " fa=" << w->fa
- << " ma=" << w->ma
- << endl;
- }
- return CR_OK;
- }
- if(list_export)
- {
- string run = "dfhack-run autobutcher ";
- #ifdef LINUX_BUILD
- run = "./dfhack-run autobutcher ";
- #endif
- // force creation of config
- out << run << "start" << endl;
- if(!enable_autobutcher)
- out << run << "stop" << endl;
- if (enable_autobutcher_autowatch)
- out << run << "autowatch" << endl;
- out << run << "sleep " << sleep_autobutcher << endl;
- out << run << "target"
- << " " << default_fk
- << " " << default_mk
- << " " << default_fa
- << " " << default_ma
- << " new" << endl;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- df::creature_raw * raw = df::global::world->raws.creatures.all[w->raceId];
- string name = raw->creature_id;
- out << run << "target"
- << " " << w->fk
- << " " << w->mk
- << " " << w->fa
- << " " << w->ma
- << " " << name << endl;
- if(w->isWatched)
- out << run << "watch " << name << endl;
- }
- return CR_OK;
- }
- // parse rest of parameters for commands followed by a list of races
- if( watch_race
- || unwatch_race
- || forget_race
- || change_target )
- {
- if(!parameters.size())
- {
- out.printerr("No race(s) specified!\n");
- return CR_WRONG_USAGE;
- }
- while(parameters.size())
- {
- string tr = parameters.back();
- target_racenames.push_back(tr);
- parameters.pop_back();
- out << tr << " ";
- }
- out << endl;
- }
- if(change_target && target_racenames.size() && target_racenames[0] == "all")
- {
- out << "Setting target count for all races on watchlist." << endl;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- w->fk = target_fk;
- w->mk = target_mk;
- w->fa = target_fa;
- w->ma = target_ma;
- w->UpdateConfig(out);
- }
- }
- if(target_racenames.size() && (target_racenames[0] == "all" || target_racenames[0] == "new"))
- {
- if(change_target)
- {
- out << "Setting target count for the future." << endl;
- default_fk = target_fk;
- default_mk = target_mk;
- default_fa = target_fa;
- default_ma = target_ma;
- if(config_autobutcher.isValid())
- {
- config_autobutcher.ival(3) = default_fk;
- config_autobutcher.ival(4) = default_mk;
- config_autobutcher.ival(5) = default_fa;
- config_autobutcher.ival(6) = default_ma;
- }
- return CR_OK;
- }
- else if(target_racenames[0] == "new")
- {
- out << "The only valid usage of 'new' is in combination when setting a target count!" << endl;
- // hm, maybe instead of complaining start/stop autowatch instead? and get rid of the autowatch option?
- if(unwatch_race)
- out << "'unwatch new' makes no sense! Use 'noautowatch' instead." << endl;
- else if(forget_race)
- out << "'forget new' makes no sense, 'forget' is only for existing watchlist entries! Use 'noautowatch' instead." << endl;
- else if(watch_race)
- out << "'watch new' makes no sense! Use 'autowatch' instead." << endl;
- return CR_WRONG_USAGE;
- }
- }
- if(target_racenames.size() && target_racenames[0] == "all")
- {
- // fill with race ids from watchlist
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- target_raceids.push_back(w->raceId);
- }
- }
- else
- {
- // map race names from parameter list to ids
- size_t num_races = df::global::world->raws.creatures.all.size();
- while(target_racenames.size())
- {
- bool found_race = false;
- for(size_t i=0; i<num_races; i++)
- {
- if(getRaceName(i) == target_racenames.back())
- {
- target_raceids.push_back(i);
- target_racenames.pop_back();
- found_race = true;
- break;
- }
- }
- if(!found_race)
- {
- out << "Race not found: " << target_racenames.back() << endl;
- return CR_OK;
- }
- }
- }
- while(target_raceids.size())
- {
- bool entry_found = false;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- if(w->raceId == target_raceids.back())
- {
- if(unwatch_race)
- {
- w->isWatched=false;
- w->UpdateConfig(out);
- }
- else if(forget_race)
- {
- w->RemoveConfig(out);
- watched_races.erase(watched_races.begin()+i);
- }
- else if(watch_race)
- {
- w->isWatched = true;
- w->UpdateConfig(out);
- }
- else if(change_target)
- {
- w->fk = target_fk;
- w->mk = target_mk;
- w->fa = target_fa;
- w->ma = target_ma;
- w->UpdateConfig(out);
- }
- entry_found = true;
- break;
- }
- }
- if(!entry_found && (watch_race||change_target))
- {
- WatchedRace * w = new WatchedRace(watch_race, target_raceids.back(), target_fk, target_mk, target_fa, target_ma);
- w->UpdateConfig(out);
- watched_races.push_back(w);
- }
- target_raceids.pop_back();
- }
- return CR_OK;
- }
- // check watched_races vector for a race id, return -1 if nothing found
- // calling method needs to check itself if the race is currently being watched or ignored
- int getWatchedIndex(int id)
- {
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- if(w->raceId == id) // && w->isWatched)
- return i;
- }
- return -1;
- }
- command_result autoButcher( color_ostream &out, bool verbose = false )
- {
- // don't run if not supposed to
- if(!Maps::IsValid())
- return CR_OK;
- // check if there is anything to watch before walking through units vector
- if(!enable_autobutcher_autowatch)
- {
- bool watching = false;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- if(w->isWatched)
- {
- watching = true;
- break;
- }
- }
- if(!watching)
- return CR_OK;
- }
- for(size_t i=0; i<world->units.all.size(); i++)
- {
- df::unit * unit = world->units.all[i];
- if( isDead(unit)
- || isUndead(unit)
- || isMarkedForSlaughter(unit)
- || isMerchant(unit) // ignore merchants' draught animals
- || isForest(unit) // ignore merchants' caged animals
- || !isOwnCiv(unit)
- || !isTame(unit)
- || isWar(unit) // ignore war dogs etc
- || isHunter(unit) // ignore hunting dogs etc
- // ignore creatures in built cages which are defined as rooms to leave zoos alone
- // (TODO: better solution would be to allow some kind of slaughter cages which you can place near the butcher)
- || (isContainedInItem(unit) && isInBuiltCageRoom(unit)) // !!! see comments in isBuiltCageRoom()
- || unit->name.has_name
- )
- continue;
- // found a bugged unit which had invalid coordinates but was not in a cage.
- // marking it for slaughter didn't seem to have negative effects, but you never know...
- if(!isContainedInItem(unit) && !hasValidMapPos(unit))
- continue;
- int watched_index = getWatchedIndex(unit->race);
- if(watched_index != -1)
- {
- WatchedRace * w = watched_races[watched_index];
- if(w->isWatched)
- w->PushUnit(unit);
- }
- else if(enable_autobutcher_autowatch)
- {
- WatchedRace * w = new WatchedRace(true, unit->race, default_fk, default_mk, default_fa, default_ma);
- w->UpdateConfig(out);
- watched_races.push_back(w);
- w->PushUnit(unit);
- string announce;
- announce = "New race added to autobutcher watchlist: " + getRaceName(w->raceId);
- Gui::showAnnouncement(announce, 2, false);
- //out << announce << endl;
- }
- }
- int slaughter_count = 0;
- for(size_t i=0; i<watched_races.size(); i++)
- {
- WatchedRace * w = watched_races[i];
- int slaughter_subcount = w->ProcessUnits();
- slaughter_count += slaughter_subcount;
- if(slaughter_subcount)
- {
- stringstream ss;
- ss << slaughter_subcount;
- string announce;
- announce = getRaceName(w->raceId) + " marked for slaughter: " + ss.str();
- Gui::showAnnouncement(announce, 2, false);
- //out << announce << endl;
- }
- }
- //out << slaughter_count << " units total marked for slaughter." << endl;
- return CR_OK;
- }
- ////////////////////////////////////////////////////
- // autobutcher and autonestbox start/init/cleanup
- command_result start_autobutcher(color_ostream &out)
- {
- enable_autobutcher = true;
- if (!config_autobutcher.isValid())
- {
- config_autobutcher = World::AddPersistentData("autobutcher/config");
- if (!config_autobutcher.isValid())
- {
- out << "Cannot enable autobutcher without a world!" << endl;
- return CR_OK;
- }
- config_autobutcher.ival(1) = sleep_autobutcher;
- config_autobutcher.ival(2) = enable_autobutcher_autowatch;
- config_autobutcher.ival(3) = default_fk;
- config_autobutcher.ival(4) = default_mk;
- config_autobutcher.ival(5) = default_fa;
- config_autobutcher.ival(6) = default_ma;
- }
- config_autobutcher.ival(0) = enable_autobutcher;
- out << "Starting autobutcher." << endl;
- init_autobutcher(out);
- return CR_OK;
- }
- command_result init_autobutcher(color_ostream &out)
- {
- cleanup_autobutcher(out);
- config_autobutcher = World::GetPersistentData("autobutcher/config");
- if(config_autobutcher.isValid())
- {
- if (config_autobutcher.ival(0) == -1)
- {
- config_autobutcher.ival(0) = enable_autobutcher;
- config_autobutcher.ival(1) = sleep_autobutcher;
- config_autobutcher.ival(2) = enable_autobutcher_autowatch;
- config_autobutcher.ival(3) = default_fk;
- config_autobutcher.ival(4) = default_mk;
- config_autobutcher.ival(5) = default_fa;
- config_autobutcher.ival(6) = default_ma;
- out << "Autobutcher's persistent config object was invalid!" << endl;
- }
- else
- {
- enable_autobutcher = config_autobutcher.ival(0);
- sleep_autobutcher = config_autobutcher.ival(1);
- enable_autobutcher_autowatch = config_autobutcher.ival(2);
- default_fk = config_autobutcher.ival(3);
- default_mk = config_autobutcher.ival(4);
- default_fa = config_autobutcher.ival(5);
- default_ma = config_autobutcher.ival(6);
- }
- }
- if(!enable_autobutcher)
- return CR_OK;
- // read watchlist from save
- std::vector<PersistentDataItem> items;
- World::GetPersistentData(&items, "autobutcher/watchlist/", true);
- for (auto p = items.begin(); p != items.end(); p++)
- {
- string key = p->key();
- out << "Reading from save: " << key << endl;
- //out << " raceid: " << p->ival(0) << endl;
- //out << " watched: " << p->ival(1) << endl;
- //out << " fk: " << p->ival(2) << endl;
- //out << " mk: " << p->ival(3) << endl;
- //out << " fa: " << p->ival(4) << endl;
- //out << " ma: " << p->ival(5) << endl;
- WatchedRace * w = new WatchedRace(p->ival(1), p->ival(0), p->ival(2), p->ival(3),p->ival(4),p->ival(5));
- w->rconfig = *p;
- watched_races.push_back(w);
- }
- return CR_OK;
- }
- command_result cleanup_autobutcher(color_ostream &out)
- {
- for(size_t i=0; i<watched_races.size(); i++)
- {
- delete watched_races[i];
- }
- watched_races.clear();
- return CR_OK;
- }
- command_result start_autonestbox(color_ostream &out)
- {
- enable_autonestbox = true;
- if (!config_autonestbox.isValid())
- {
- config_autonestbox = World::AddPersistentData("autonestbox/config");
- if (!config_autonestbox.isValid())
- {
- out << "Cannot enable autonestbox without a world!" << endl;
- return CR_OK;
- }
- config_autonestbox.ival(1) = sleep_autonestbox;
- }
- config_autonestbox.ival(0) = enable_autonestbox;
- out << "Starting autonestbox." << endl;
- init_autonestbox(out);
- return CR_OK;
- }
- command_result init_autonestbox(color_ostream &out)
- {
- cleanup_autonestbox(out);
- config_autonestbox = World::GetPersistentData("autonestbox/config");
- if(config_autonestbox.isValid())
- {
- if (config_autonestbox.ival(0) == -1)
- {
- config_autonestbox.ival(0) = enable_autonestbox;
- config_autonestbox.ival(1) = sleep_autonestbox;
- out << "Autonestbox's persistent config object was invalid!" << endl;
- }
- else
- {
- enable_autonestbox = config_autonestbox.ival(0);
- sleep_autonestbox = config_autonestbox.ival(1);
- }
- }
- return CR_OK;
- }
- command_result cleanup_autonestbox(color_ostream &out)
- {
- // nothing to cleanup currently
- // (future version of autonestbox could store info about cages for useless male kids)
- return CR_OK;
- }