#include "Core.h"

#include <Console.h>

#include <Export.h>

#include <Error.h>

#include <PluginManager.h>

#include <modules/Gui.h>

#include <modules/Screen.h>

#include <modules/Maps.h>

#include <modules/MapCache.h>

#include <modules/World.h>

#include <modules/Units.h>

#include <modules/Job.h>

#include <modules/Materials.h>

#include <modules/Random.h>

#include <LuaTools.h>

#include <TileTypes.h>

#include <vector>

#include <cstdio>

#include <stack>

#include <string>

#include <cmath>

#include <string.h>

#include <VTableInterpose.h>

#include "df/graphic.h"

#include "df/building_siegeenginest.h"

#include "df/builtin_mats.h"

#include "df/world.h"

#include "df/buildings_other_id.h"

#include "df/job.h"

#include "df/building_drawbuffer.h"

#include "df/ui.h"

#include "df/viewscreen_dwarfmodest.h"

#include "df/ui_build_selector.h"

#include "df/flow_info.h"

#include "df/report.h"

#include "df/proj_itemst.h"

#include "df/unit.h"

#include "df/unit_soul.h"

#include "df/unit_skill.h"

#include "df/physical_attribute_type.h"

#include "df/creature_raw.h"

#include "df/caste_raw.h"

#include "df/caste_raw_flags.h"

#include "df/identity.h"

#include "df/game_mode.h"

#include "df/unit_misc_trait.h"

#include "df/job.h"

#include "df/job_item.h"

#include "df/item_actual.h"

#include "df/items_other_id.h"

#include "df/building_stockpilest.h"

#include "df/stockpile_links.h"

#include "df/workshop_profile.h"

#include "df/strain_type.h"

#include "df/material.h"

#include "df/flow_type.h"

#include "df/invasion_info.h"

#include "MiscUtils.h"

using std::vector;

using std::string;

using std::stack;

using namespace DFHack;

using namespace df::enums;

using df::global::gamemode;

using df::global::gps;

using df::global::world;

using df::global::ui;

using df::global::ui_build_selector;

using df::global::process_jobs;

using Screen::Pen;

DFHACK_PLUGIN("siege-engine");

static bool debug_mode = false;

static void setDebug(bool on)

{

debug_mode = on;

}

static void set_arrow_color(df::coord pos, int color)

}

typedef std::pair<df::coord, df::coord> coord_range;

static void set_range(coord_range *target, df::coord p1, df::coord p2)

}

static bool is_range_valid(const coord_range &target)

{

return target.first.isValid() && target.second.isValid();

}

static bool is_in_range(const coord_range &target, df::coord pos)

}

static std::pair<int, int> get_engine_range(df::building_siegeenginest *bld, float quality)

}

static void orient_engine(df::building_siegeenginest *bld, df::coord target)

}

static bool is_build_complete(df::building *bld)

{

return bld->getBuildStage() >= bld->getMaxBuildStage();

}

static float average_quality(df::building_actual *bld)

}

static int point_distance(df::coord speed)

{

return std::max(abs(speed.x), std::max(abs(speed.y), abs(speed.z)));

}

inline void normalize(float &x, float &y, float &z)

}

static Random::MersenneRNG rng;

static void random_direction(float &x, float &y, float &z)

}

static double random_error()

}

static int int_round (double val)

}

static const int WEAR_TICKS = 806400;

static bool apply_impact_damage(df::item *item, int minv, int maxv)

}

static bool enable_plugin();

struct EngineInfo {

};

static std::map<df::building*, EngineInfo*> engines;

static std::map<df::coord, df::building*> coord_engines;

static EngineInfo *find_engine(df::building *bld, bool create = false)

{

auto ebld = strict_virtual_cast<df::building_siegeenginest>(bld);

if (!ebld)

return NULL;

auto &obj = engines[bld];

if (obj)

{

obj->bld = ebld;

return obj;

}

if (!create || !is_build_complete(bld))

return NULL;

obj = new EngineInfo();

obj->id = bld->id;

obj->bld = ebld;

obj->center = df::coord(bld->centerx, bld->centery, bld->z);

obj->building_rect = coord_range(

df::coord(bld->x1, bld->y1, bld->z),

df::coord(bld->x2, bld->y2, bld->z)

);

obj->quality = average_quality(ebld);

obj->is_catapult = (ebld->type == siegeengine_type::Catapult);

obj->proj_speed = 2;

obj->hit_delay = obj->is_catapult ? 2 : -1;

obj->fire_range = get_engine_range(ebld, obj->quality);

// Base coefficients per engine type, plus 6% exponential bonus per quality level

obj->sigma_coeff = (obj->is_catapult ? 30.0 : 48.0) * pow(1.06f, obj->quality);

obj->ammo_vector_id = job_item_vector_id::BOULDER;

obj->ammo_item_type = item_type::BOULDER;

obj->operator_id = obj->operator_frame = -1;

coord_engines[obj->center] = bld;

return obj;

}

static EngineInfo *find_engine(lua_State *L, int idx, bool create = false, bool silent = false)

{

auto bld = Lua::CheckDFObject<df::building_siegeenginest>(L, idx);

auto engine = find_engine(bld, create);

if (!engine && !silent)

luaL_error(L, "no such engine");

return engine;

}

static EngineInfo *find_engine(df::coord pos)

{

auto engine = find_engine(coord_engines[pos]);

if (engine)

{

auto bld0 = df::building::find(engine->id);

auto bld = strict_virtual_cast<df::building_siegeenginest>(bld0);

if (!bld)

return NULL;

engine->bld = bld;

}

return engine;

}

static void clear_engines()

}

static void load_engines()

}

static int getTargetArea(lua_State *L)

}

static void clearTargetArea(df::building_siegeenginest *bld)

}

static bool setTargetArea(df::building_siegeenginest *bld, df::coord target_min, df::coord target_max)

}

static int getAmmoItem(lua_State *L)

}

static int setAmmoItem(lua_State *L)

}

static void forgetStockpileLink(EngineInfo *engine, int pile_id)

}

static void update_stockpile_links(EngineInfo *engine)

}

static int getStockpileLinks(lua_State *L)

}

static bool isLinkedToPile(df::building_siegeenginest *bld, df::building_stockpilest *pile)

}

static bool addStockpileLink(df::building_siegeenginest *bld, df::building_stockpilest *pile)

}

static bool removeStockpileLink(df::building_siegeenginest *bld, df::building_stockpilest *pile)

}

static df::workshop_profile *saveWorkshopProfile(df::building_siegeenginest *bld)

{

CHECK_NULL_POINTER(bld);

CHECK_INVALID_ARGUMENT(is_build_complete(bld));

if (!enable_plugin())

return NULL;

// Save skill limits

auto key = stl_sprintf("siege-engine/profiles/%d", bld->id);

auto entry = World::GetPersistentData(key, NULL);

if (!entry.isValid())

return NULL;

auto engine = find_engine(bld, true);

entry.ival(0) = engine->id;

entry.ival(1) = engine->profile.min_level;

entry.ival(2) = engine->profile.max_level;

// Save worker list

std::vector<PersistentDataItem> vec;

auto &workers = engine->profile.permitted_workers;

key = stl_sprintf("siege-engine/profile-workers/%d", bld->id);

World::GetPersistentData(&vec, key, true);

for (auto it = vec.begin(); it != vec.end(); ++it)

{

if (linear_index(workers, it->ival(1)) < 0)

World::DeletePersistentData(*it);

}

for (size_t i = 0; i < workers.size(); i++)

{

key = stl_sprintf("siege-engine/profile-workers/%d/%d", bld->id, workers[i]);

entry = World::GetPersistentData(key, NULL);

if (!entry.isValid())

continue;

entry.ival(0) = engine->id;

entry.ival(1) = workers[i];

}

return &engine->profile;

}

static df::unit *getOperatorUnit(df::building_siegeenginest *bld, bool force = false)

{

CHECK_NULL_POINTER(bld);

auto engine = find_engine(bld);

if (!engine)

return NULL;

if (engine->operator_id != -1 &&

(world->frame_counter - engine->operator_frame) <= 5)

{

auto op_unit = df::unit::find(engine->operator_id);

if (op_unit)

return op_unit;

}

if (force)

{

color_ostream_proxy out(Core::getInstance().getConsole());

out.print("Forced siege operator search\n");

auto &active = world->units.active;

for (size_t i = 0; i < active.size(); i++)

if (active[i]->pos == engine->center && Units::isCitizen(active[i]))

return active[i];

}

return NULL;

}

struct ProjectilePath {

};

static ProjectilePath decode_path(lua_State *L, int idx, df::coord origin)

}

static int projPosAtStep(lua_State *L)

}

static bool isPassableTile(df::coord pos)

}

static bool isTargetableTile(df::coord pos)

}

static bool isTreeTile(df::coord pos)

}

static bool adjustToTarget(EngineInfo *engine, df::coord *pos)

}

static int adjustToTarget(lua_State *L)

}

static const char* const hit_type_names[] = {

"wall", "floor", "ceiling", "map_edge", "tree"

};

struct PathMetrics {