#include "Debug.h"

#include "PluginManager.h"

#include "modules/Maps.h"

#include "modules/Persistence.h"

#include "modules/Units.h"

#include "modules/World.h"

#include "df/unit.h"

#include "df/unit_relationship_type.h"

using std::string;

using std::vector;

using namespace DFHack;

DFHACK_PLUGIN("fastdwarf");

DFHACK_PLUGIN_IS_ENABLED(is_enabled);

REQUIRE_GLOBAL(world);

using df::global::debug_turbospeed; // soft dependency, so not REQUIRE_GLOBAL

namespace DFHack {

// for configuration-related logging

DBG_DECLARE(fastdwarf, control, DebugCategory::LINFO);

// for logging during the update cycle

DBG_DECLARE(fastdwarf, cycle, DebugCategory::LINFO);

}

static const string CONFIG_KEY = string(plugin_name) + "/config";

static PersistentDataItem config;

enum ConfigValues {

CONFIG_FAST = 0,

CONFIG_TELE = 1,

};

static command_result do_command(color_ostream &out, vector<string> & parameters);

DFhackCExport command_result plugin_init(color_ostream &out, std::vector<PluginCommand> & commands) {

DEBUG(control,out).print("initializing {}\n", plugin_name);

commands.push_back(PluginCommand(

"fastdwarf",

"Citizens walk fast and and finish jobs instantly.",

do_command));

return CR_OK;

}

static void set_state(color_ostream &out, int fast, int tele) {

DEBUG(control,out).print("setting state: fast={}, tele={}\n", fast, tele);

is_enabled = fast || tele;

config.set_int(CONFIG_FAST, fast);

config.set_int(CONFIG_TELE, tele);

if (debug_turbospeed)

*debug_turbospeed = fast == 2;

else if (fast == 2)

out.printerr("Speed level 2 not available.\n");

}

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

if (!Core::getInstance().isMapLoaded() || !World::IsSiteLoaded()) {

out.printerr("Cannot enable {} without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

if (enable != is_enabled) {

set_state(out, enable ? 1 : 0, 0);

} else {

DEBUG(control,out).print("{} from the API, but already {}; no action\n",

is_enabled ? "enabled" : "disabled",

is_enabled ? "enabled" : "disabled");

}

return CR_OK;

}

DFhackCExport command_result plugin_shutdown (color_ostream &out) {

DEBUG(control,out).print("shutting down {}\n", plugin_name);

// make sure the debug flag doesn't get left on

if (debug_turbospeed)

*debug_turbospeed = false;

return CR_OK;

}

DFhackCExport command_result plugin_load_site_data (color_ostream &out) {

config = World::GetPersistentSiteData(CONFIG_KEY);

if (!config.isValid()) {

DEBUG(control,out).print("no config found in this save; initializing\n");

config = World::AddPersistentSiteData(CONFIG_KEY);

set_state(out, false, false);

} else {

is_enabled = config.get_int(CONFIG_FAST) || config.get_int(CONFIG_TELE);

DEBUG(control,out).print("loading persisted state: fast={}, tele={}\n",

config.get_int(CONFIG_FAST),

config.get_int(CONFIG_TELE));

}

return CR_OK;

}

DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event) {

if (event == DFHack::SC_WORLD_UNLOADED) {

if (is_enabled) {

DEBUG(control,out).print("world unloaded; disabling {}\n",

plugin_name);

is_enabled = false;

}

}

return CR_OK;

}

static void do_tele(color_ostream &out, df::unit * unit) {

// skip dwarves that are dragging creatures or being dragged

if ((unit->relationship_ids[df::unit_relationship_type::Draggee] != -1) ||

(unit->relationship_ids[df::unit_relationship_type::Dragger] != -1))

return;

// skip dwarves that are following other units

if (unit->following != 0)

return;

// skip unconscious units

if (unit->counters.unconscious > 0)

return;

// don't do anything if the dwarf isn't going anywhere

if (!unit->pos.isValid() || !unit->path.dest.isValid() || unit->pos == unit->path.dest)

return;

// skip units with no current job so they can still meander and fulfill needs

if (!unit->job.current_job)

return;

// don't do anything if the destination is in a different pathability group or is unrevealed

if (!Maps::canWalkBetween(unit->pos, unit->path.dest))

return;

if (!Maps::isTileVisible(unit->path.dest))

return;

DEBUG(cycle,out).print("teleporting unit {}\n", unit->id);

if (!Units::teleport(unit, unit->path.dest))

return;

unit->path.path.clear();

}

DFhackCExport command_result plugin_onupdate(color_ostream &out) {

DEBUG(cycle,out).print("running {} cycle\n", plugin_name);

// fast mode 2 is handled by DF itself

bool is_fast = config.get_int(CONFIG_FAST) == 1;

bool is_tele = config.get_int(CONFIG_TELE) == 1;

Units::forCitizens([&](auto unit) {

if (is_tele)

do_tele(out, unit);

if (is_fast) {

DEBUG(cycle,out).print("fastifying unit {}\n", unit->id);

Units::setGroupActionTimers(out, unit, 1, df::unit_action_type_group::All);

}

});

return CR_OK;

}

/////////////////////////////////////////////////////

// CLI logic

//

static command_result do_command(color_ostream &out, vector <string> & parameters)

{

if (!Core::getInstance().isMapLoaded() || !World::IsSiteLoaded()) {

out.printerr("Cannot run {} without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

const size_t num_params = parameters.size();

if (num_params > 2 || (num_params > 1 && parameters[0] == "help"))

return CR_WRONG_USAGE;

if (num_params == 0 || parameters[0] == "status") {

out.print("Current state: fast = {}, teleport = {}.\n",

config.get_int(CONFIG_FAST),

config.get_int(CONFIG_TELE));

return CR_OK;

}

int fast = string_to_int(parameters[0]);

int tele = num_params >= 2 ? string_to_int(parameters[1]) : 0;

if (fast < 0 || fast > 2) {

out.printerr("Invalid value for fast: '{}'", parameters[0]);

return CR_WRONG_USAGE;

}

if (tele < 0 || tele > 1) {

out.printerr("Invalid value for tele: '{}'", parameters[1]);

return CR_WRONG_USAGE;

}

set_state(out, fast, tele);

return CR_OK;

}