#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 "MiscUtils.h"

#include "LuaTools.h"

#include "DataFuncs.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 "modules/Screen.h"

#include "MiscUtils.h"

#include <VTableInterpose.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>

#include "df/viewscreen_dwarfmodest.h"

#include "modules/Translation.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 df::global::ui_build_selector;

using df::global::gps;

using df::global::cur_year;

using df::global::cur_year_tick;

using df::global::ui_building_item_cursor;

using df::global::ui_building_assign_type;

using df::global::ui_building_assign_is_marked;

using df::global::ui_building_assign_units;

using df::global::ui_building_assign_items;

using df::global::ui_building_in_assign;

using df::global::ui_menu_width;

using df::global::ui_area_map_width;

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

DFHACK_PLUGIN_IS_ENABLED(is_enabled);

DFhackCExport command_result plugin_enable ( color_ostream &out, bool enable);

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

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)

}

DFhackCExport command_result plugin_onupdate ( color_ostream &out )

}

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)

}

bool isDead(df::unit* unit)

{

return unit->flags1.bits.dead;

}

bool isUndead(df::unit* unit)

}

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;

}

bool isTame(df::unit* creature)

}

bool isDomesticated(df::unit* creature)

}

bool isTrained(df::unit* unit)

}

bool isWar(df::unit* unit)

}

bool isHunter(df::unit* unit)

}

bool isAvailableForAdoption(df::unit* unit)

}

bool isOwnCiv(df::unit* unit)

{

return unit->civ_id == ui->civ_id;

}

bool isOwnRace(df::unit* unit)

{

return unit->race == ui->race_id;

}

string getRaceName(int32_t id)

}

string getRaceName(df::unit* unit)

}

string getRaceNamePlural(int32_t id)

}

string getRaceBabyName(df::unit* unit)

}

string getRaceChildName(df::unit* unit)

}

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)

}

bool isGrazer(df::unit* unit)

}

bool isMilkable(df::unit* unit)

}

bool isTrainableWar(df::unit* unit)

}

bool isTrainableHunting(df::unit* unit)

}

bool isTamable(df::unit* unit)

}

bool isMale(df::unit* unit)

{

return unit->sex == 1;

}

bool isFemale(df::unit* unit)

{

return unit->sex == 0;

}

bool hasValidMapPos(df::unit* unit)

}

bool isNaked(df::unit* unit)

{

return (unit->inventory.empty());

}

int getUnitIndexFromId(df::unit* unit_)

}

void unitInfo(color_ostream & out, df::unit* unit, bool verbose = false)

}

bool isActivityZone(df::building * building)

}

bool isPenPasture(df::building * building)

}

bool isPitPond(df::building * building)

}

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)

}

int32_t findBuildingIndexById(int32_t id)

}

int32_t findUnitIndexById(int32_t id)

}

df::unit* findUnitById(int32_t id)

{

int32_t index = findUnitIndexById(id);

if(index != -1)

return world->units.all[index];

else

return NULL;

}

int32_t findPenPitAtCursor()

}

int32_t findCageAtCursor()

}

int32_t findChainAtCursor()

}

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;

}