{

commands.push_back(PluginCommand(

"diggingInvaders",

"Makes invaders dig to your dwarves.",

diggingInvadersCommand));

//*df::global::debug_showambush = true;

return CR_OK;

if ( enabled == enable )

return CR_OK;

enabled = enable;

EventManager::unregisterAll(plugin_self);

clearDijkstra();

lastInvasionJob = lastInvasionDigger = -1;

activeDigging = false;

invaderJobs.clear();

if ( enabled ) {

EventManager::EventHandler handler(plugin_self, newInvasionHandler, 1000);

EventManager::registerListener(EventManager::EventType::INVASION, handler);

findAndAssignInvasionJob(out, (void*)0);

}

return CR_OK;

{

switch (event) {

case DFHack::SC_WORLD_LOADED:

//TODO: check game mode

//in case there are invaders when the game is loaded, we check if there's work to be done

activeDigging = enabled;

clearDijkstra();

findAndAssignInvasionJob(out, (void*)0);

break;

case DFHack::SC_WORLD_UNLOADED:

// cleanup

plugin_enable(out, false);

break;

default:

break;

}

return CR_OK;

unordered_map<df::coord, cost_t, PointHash> *pointCost;

PointComp(unordered_map<df::coord, cost_t, PointHash> *p): pointCost(p) {

}

int32_t operator()(df::coord p1, df::coord p2) const {

if ( p1 == p2 ) return 0;

auto i1 = pointCost->find(p1);

auto i2 = pointCost->find(p2);

if ( i1 == pointCost->end() && i2 == pointCost->end() )

return p1 < p2;

if ( i1 == pointCost->end() )

return true;

if ( i2 == pointCost->end() )

return false;

cost_t c1 = (*i1).second;

cost_t c2 = (*i2).second;

if ( c1 != c2 )

return c1 < c2;

return p1 < p2;

}

if ( activeDigging )

return;

activeDigging = true;

findAndAssignInvasionJob(out, (void*)0);

for ( size_t a = 0; a < parameters.size(); a++ ) {

if ( parameters[a] == "1" || parameters[a] == "enable" ) {

plugin_enable(out,true);

} else if ( parameters[a] == "0" || parameters[a] == "disable" ) {

plugin_enable(out,false);

} else if ( parameters[a] == "add" || parameters[a] == "remove" ) {

if ( a+1 >= parameters.size() )

return CR_WRONG_USAGE;

string race = parameters[a+1];

if ( parameters[a] == "add" ) {

diggingRaces.insert(race);

DigAbilities& abilities = digAbilities[race];

memcpy(abilities.costWeight, costWeightDefault, costDim*sizeof(cost_t));

memcpy(abilities.jobDelay, jobDelayDefault, costDim*sizeof(int32_t));

} else {

diggingRaces.erase(race);

digAbilities.erase(race);

}

a++;

} else if ( parameters[a] == "setCost" || parameters[a] == "setDelay" ) {

if ( a+3 >= parameters.size() )

return CR_WRONG_USAGE;

string raceString = parameters[a+1];

if ( digAbilities.find(raceString) == digAbilities.end() ) {

DigAbilities bob;

memset(&bob, 0xFF, sizeof(bob));

digAbilities[raceString] = bob;

}

DigAbilities& abilities = digAbilities[raceString];

string costStr = parameters[a+2];

int32_t costDim = -1;

if ( costStr == "walk" ) {

costDim = CostDimension::Walk;

if ( parameters[a] == "setDelay" )

return CR_WRONG_USAGE;

} else if ( costStr == "destroyBuilding" ) {

costDim = CostDimension::DestroyBuilding;

} else if ( costStr == "dig" ) {

costDim = CostDimension::Dig;

} else if ( costStr == "destroyRoughConstruction" ) {

costDim = CostDimension::DestroyRoughConstruction;

} else if ( costStr == "destroySmoothConstruction" ) {

costDim = CostDimension::DestroySmoothConstruction;

} else {

return CR_WRONG_USAGE;

}

cost_t value;

stringstream asdf(parameters[a+3]);

asdf >> value;

//if ( parameters[a] == "setCost" && value <= 0 )

// return CR_WRONG_USAGE;

if ( parameters[a] == "setCost" ) {

abilities.costWeight[costDim] = value;

} else {

abilities.jobDelay[costDim] = value;

}

a += 3;

} else if ( parameters[a] == "edgeCost" ) {

if ( a+1 >= parameters.size() )

return CR_WRONG_USAGE;

string raceString = parameters[a+1];

if ( digAbilities.find(raceString) == digAbilities.end() ) {

out.print("Race {} does not have dig abilities assigned.\n", raceString);

return CR_WRONG_USAGE;

}

DigAbilities& abilities = digAbilities[raceString];

df::coord bob = Gui::getCursorPos();

out.print("({},{},{}), ({},{},{}): cost = {}\n", lastDebugEdgeCostPoint.x, lastDebugEdgeCostPoint.y, lastDebugEdgeCostPoint.z, bob.x, bob.y, bob.z, getEdgeCost(out, lastDebugEdgeCostPoint, bob, abilities));

lastDebugEdgeCostPoint = bob;

a++;

} else if ( parameters[a] == "now" ) {

activeDigging = true;

findAndAssignInvasionJob(out, (void*)0);

} else if ( parameters[a] == "clear" ) {

diggingRaces.clear();

digAbilities.clear();

} else if ( parameters[a] == "edgesPerTick" ) {

if ( a+1 >= parameters.size() )

return CR_WRONG_USAGE;

stringstream asdf(parameters[a+1]);

int32_t edgeCount = 100;

asdf >> edgeCount;

edgesPerTick = edgeCount;

a++;

}

else {

return CR_WRONG_USAGE;

}

}

activeDigging = enabled;

out.print("diggingInvaders: enabled = {}, activeDigging = {}, edgesPerTick = {}\n", enabled, activeDigging, edgesPerTick);

return CR_OK;

invaders.clear();

invaderPts.clear();

localPts.clear();

parentMap.clear();

costMap.clear();

comp = PointComp(&costMap);

fringe = set<df::coord,PointComp>(comp);

localPtsFound = edgeCount = 0;

foundTarget = false;

closedSet.clear();

workNeeded.clear();

//returns the worker id of the job created //used to

//out.print("%s, %d: %d\n", __FILE__, __LINE__, (int32_t)tickTime);

if ( !enabled || !activeDigging ) {

clearDijkstra();

return;

}

//we're going to unregister just in case this function has been called 20 times or something.

EventManager::unregister(EventManager::EventType::TICK, findJobTickHandler);

EventManager::registerTick(findJobTickHandler, 1);

if ( fringe.empty() ) {

df::unit* lastDigger = df::unit::find(lastInvasionDigger);

if ( lastDigger && lastDigger->job.current_job && lastDigger->job.current_job->id == lastInvasionJob ) {

return;

}

//out.print("{},{}: lastDigger = {}, last job = {}, last digger's job = {}\n", __FILE__, __LINE__, lastInvasionDigger, lastInvasionJob, !lastDigger ? -1 : (!lastDigger->job.current_job ? -1 : lastDigger->job.current_job->id));

lastInvasionDigger = lastInvasionJob = -1;

clearDijkstra();

unordered_set<uint16_t> invaderConnectivity;

unordered_set<uint16_t> localConnectivity;

//find all locals and invaders

for ( size_t a = 0; a < world->units.all.size(); a++ ) {

df::unit* unit = world->units.all[a];

if ( !Units::isActive(unit) )

continue;

if ( Units::isCitizen(unit) ) {

if ( localPts.find(unit->pos) != localPts.end() )

continue;

localPts.insert(unit->pos);

df::map_block* block = Maps::getTileBlock(unit->pos);

localConnectivity.insert(block->walkable[unit->pos.x&0xF][unit->pos.y&0xF]);

} else if ( unit->flags1.bits.active_invader ) {

df::creature_raw* raw = df::creature_raw::find(unit->race);

if ( raw == NULL ) {

out.print("{},{}: WTF? Couldn't find creature raw.\n", __FILE__, __LINE__);

continue;

}

/*

if ( digAbilities.find(raw->creature_id) == digAbilities.end() )

continue;

if ( invaderPts.find(unit->pos) != invaderPts.end() )

continue;

//must be able to wield a pick: this is overly pessimistic

if ( unit->status2.limbs_grasp_max <= 0 || unit->status2.limbs_grasp_count < unit->status2.limbs_grasp_max )

continue;

df::map_block* block = Maps::getTileBlock(unit->pos);

invaderConnectivity.insert(block->walkable[unit->pos.x&0xF][unit->pos.y&0xF]);

if ( invaderPts.size() > 0 )

continue;

invaderPts.insert(unit->pos);

costMap[unit->pos] = 0;

fringe.insert(unit->pos);

invaders.push_back(unit->id);

} else {

continue;

}

}

if ( invaders.empty() || localPts.empty() ) {

activeDigging = false;

return;

}

//if local connectivity is not disjoint from invader connectivity, no digging required

bool overlap = false;

for ( auto a = localConnectivity.begin(); a != localConnectivity.end(); a++ ) {

uint16_t conn = *a;

if ( invaderConnectivity.find(conn) == invaderConnectivity.end() )

continue;

overlap = true;

break;

}

if ( overlap ) {

//still keep checking next frame: might kill a few outsiders then dig down

return;

}

}

df::unit* firstInvader = df::unit::find(invaders[0]);

if ( firstInvader == NULL ) {

fringe.clear();

return;

}

df::creature_raw* creature_raw = df::creature_raw::find(firstInvader->race);

if ( creature_raw == NULL || digAbilities.find(creature_raw->creature_id) == digAbilities.end() ) {

//inappropriate digger: no dig abilities

fringe.clear();

return;

}

DigAbilities& abilities = digAbilities[creature_raw->creature_id];

//TODO: check that firstInvader is an appropriate digger

//out << firstInvader->id << endl;

//out << firstInvader->pos.x << ", " << firstInvader->pos.y << ", " << firstInvader->pos.z << endl;

//out << __LINE__ << endl;

uint32_t xMax, yMax, zMax;

Maps::getSize(xMax,yMax,zMax);

xMax *= 16;

yMax *= 16;

MapExtras::MapCache cache;

// clock_t t0 = clock();

clock_t totalEdgeTime = 0;

int32_t edgesExpanded = 0;

while(!fringe.empty()) {

if ( edgesPerTick > 0 && edgesExpanded++ >= edgesPerTick ) {

return;

}

df::coord pt = *(fringe.begin());

fringe.erase(fringe.begin());

//out.print("line %d: fringe size = %d, localPtsFound = %d / %d, closedSetSize = %d, pt = %d,%d,%d\n", __LINE__, fringe.size(), localPtsFound, localPts.size(), closedSet.size(), pt.x,pt.y,pt.z);

if ( closedSet.find(pt) != closedSet.end() ) {

out.print("{},{}: Double closure! Bad!\n", __FILE__, __LINE__);

break;

}

closedSet.insert(pt);

if ( localPts.find(pt) != localPts.end() ) {

localPtsFound++;

if ( true || localPtsFound >= localPts.size() ) {

foundTarget = true;

break;

}

if ( workNeeded.find(pt) == workNeeded.end() || workNeeded[pt] == 0 ) {

//there are still dwarves to kill that don't require digging to get to

return;

}

}

cost_t myCost = costMap[pt];

clock_t edgeTime = clock();

vector<Edge>* myEdges = getEdgeSet(out, pt, cache, xMax, yMax, zMax, abilities);

totalEdgeTime += (clock() - edgeTime);

for ( auto a = myEdges->begin(); a != myEdges->end(); a++ ) {

Edge &e = *a;

if ( e.p1 == df::coord() )

break;

edgeCount++;

df::coord& other = e.p1;

if ( other == pt )

other = e.p2;

//if ( closedSet.find(other) != closedSet.end() )

// continue;

auto i = costMap.find(other);

if ( i != costMap.end() ) {

cost_t cost = (*i).second;

if ( cost <= myCost + e.cost ) {

continue;

}

fringe.erase((*i).first);

}

costMap[other] = myCost + e.cost;

fringe.insert(other);

parentMap[other] = pt;

workNeeded[other] = (e.cost > 1 ? 1 : 0) + workNeeded[pt];

}

delete myEdges;

}

// clock_t time = clock() - t0;

//out.print("tickTime = {}, time = {}, totalEdgeTime = {}, total points = {}, total edges = {}, time per point = {:.3f}, time per edge = {:.3f}, clocks/sec = {}\n", (int32_t)tickTime, time, totalEdgeTime, closedSet.size(), edgeCount, (float)time / closedSet.size(), (float)time / edgeCount, CLOCKS_PER_SEC);

fringe.clear();

if ( !foundTarget )

return;

unordered_set<df::coord, PointHash> requiresZNeg;

unordered_set<df::coord, PointHash> requiresZPos;

//find important edges

Edge firstImportantEdge(df::coord(), df::coord(), -1);

//df::coord closest;

//cost_t closestCostEstimate=0;

//cost_t closestCostActual=0;

for ( auto i = localPts.begin(); i != localPts.end(); i++ ) {

df::coord pt = *i;

if ( costMap.find(pt) == costMap.end() )

continue;

if ( parentMap.find(pt) == parentMap.end() )

continue;

//closest = pt;

//closestCostEstimate = costMap[closest];

//if ( workNeeded[pt] == 0 )

// continue;

while ( parentMap.find(pt) != parentMap.end() ) {

//out.print("(%d,%d,%d)\n", pt.x, pt.y, pt.z);

df::coord parent = parentMap[pt];

cost_t cost = getEdgeCost(out, parent, pt, abilities);

if ( cost < 0 ) {

//path invalidated

return;

}

//closestCostActual += cost;

if ( Maps::canStepBetween(parent, pt) ) {

} else {

if ( pt.x == parent.x && pt.y == parent.y ) {

if ( pt.z < parent.z ) {

requiresZNeg.insert(parent);

requiresZPos.insert(pt);

} else if ( pt.z > parent.z ) {

requiresZNeg.insert(pt);

requiresZPos.insert(parent);

}

}

//if ( workNeeded[pt] > workNeeded[parent] ) {

//importantEdges.push_front(Edge(pt,parent,0));

//}

firstImportantEdge = Edge(pt,parent,0);

//out.print("(%d,%d,%d) -> (%d,%d,%d)\n", parent.x,parent.y,parent.z, pt.x,pt.y,pt.z);

}

pt = parent;

}

break;

}

if ( firstImportantEdge.p1 == df::coord() )

return;

assignJob(out, firstImportantEdge, parentMap, costMap, invaders, requiresZNeg, requiresZPos, cache, abilities);

lastInvasionDigger = firstInvader->id;

lastInvasionJob = firstInvader->job.current_job ? firstInvader->job.current_job->id : -1;

invaderJobs.erase(lastInvasionJob);

for ( df::job_list_link* link = &world->jobs.list; link != NULL; link = link->next ) {

if ( link->item == NULL )

continue;

df::job* job = link->item;

if ( invaderJobs.find(job->id) == invaderJobs.end() ) {

continue;

}

//cancel it

job->flags.bits.item_lost = 1;

out.print("{},{}: cancelling job {}.\n", __FILE__,__LINE__, job->id);

//invaderJobs.remove(job->id);

}

invaderJobs.erase(lastInvasionJob);

return;

map<df::coord, df::coord>::iterator i = rootMap.find(point);

if ( i == rootMap.end() ) {

rootMap[point] = point;

return point;

}

df::coord parent = (*i).second;

if ( parent == point )

return parent;

df::coord root = getRoot(parent, rootMap);

rootMap[point] = root;

return root;