int32_t x;

int32_t y;

int32_t z;

public:

// Constructor/Deconstrctor

Patient(int32_t id, size_t spot_index, int32_t x, int32_t y, int32_t z);

int32_t getID() { return this->id; };

size_t getSpotIndex() { return this->spot_index; };

int32_t returnX() { return this->spot_in_hospital.x; };

int32_t returnY() { return this->spot_in_hospital.y; };

int32_t returnZ() { return this->spot_in_hospital.z; };

private:

struct hospital_spot spot_in_hospital;

int32_t id;

size_t spot_index;

this->id = id;

this->spot_index = spot_index;

this->spot_in_hospital.x = x;

this->spot_in_hospital.y = y;

this->spot_in_hospital.z = z;

public:

// Constructor

AnimalHospital(df::building *, color_ostream &out);

~AnimalHospital();

int32_t getID() { return id; }

bool acceptPatient(int32_t id, color_ostream&);

void processPatients(color_ostream &out);

void dischargePatient(Patient * patient, color_ostream &out);

void calculateHospital(bool force, color_ostream &out);

void reportUsage(color_ostream &out);

// GC

bool to_be_deleted;

private:

int spots_open;

int32_t id;

int32_t x1;

int32_t x2;

int32_t y1;

int32_t y2;

int32_t z;

int height;

int length;

// Doing an actual array in C++ is *annoying*, bloody copy constructors */

vector<bool> spots_in_use;

vector<int32_t> building_in_hospital_notification; /* If present, we already notified about this */

vector<Patient*> accepted_patients;

// Copy in what we need to know

id = building->id;

x1 = building->x1;

x2 = building->x2;

y1 = building->y1;

y2 = building->y2;

z = building->z;

// Determine how many spots we have for animals

this->length = x2-x1+1;

this->height = y2-y1+1;

// And calculate the hospital!

this->calculateHospital(true, out);

// This function determines if we can accept a patient, and if we will.

this->calculateHospital(true, out);

// First, do we have room?

if (!spots_open) return false;

// Yup, let's find the next open spot,

// and give it to our patient

int spot_cur = 0;

for (vector<bool>::iterator spot = this->spots_in_use.begin(); spot != this->spots_in_use.end(); spot++) {

if (*spot == false) {

*spot = true;

break;

}

spot_cur++;

}

spots_open--;

// Convert the spot into x/y/z cords.

int offset_y = spot_cur/length;

int offset_x = spot_cur%length;

// Create the patient!

Patient * patient = new Patient(id,

spot_cur,

this->x1+offset_x,

this->y1+offset_y,

this->z

);

accepted_patients.push_back(patient);

return true;

// Debugging tool to see parts of the hospital in use

int length_cursor = this->length;

for (bool spot : this->spots_in_use) {

if (spot) out.print("X");

else out.print("-");

length_cursor--;

if (length_cursor <= 0) {

out.print("\n");

length_cursor = this->length;

}

}

out.print("\n");

// Only calculate out the hospital if we actually have a patient in it

// (acceptPatient will forcibly rerun this to make sure everything OK

// Should reduce FPS impact of each calculation tick when the hospitals

// are not in use

//if (!force || (spots_open == length*height)) {

// Hospital is idle, don't recalculate

// return;

//}

// Calculate out the total area of the hospital

// This can change if a hospital has been resized

this->spots_open = length*height;

this->spots_in_use.assign(this->spots_open, false);

// The spots_in_use maps one to one with a spot

// starting at the upper-left hand corner, then

// across, then down. i.e.

//

// given hospital zone:

//

// UU

// uU

//

// where U is in use, and u isn't, the array

// would be t,t,f,t

// Walk the building array and see what stuff is in the hospital,

// then walk the patient array and remark those spots as used.

// If a patient is in an invalid spot, reassign it

for (df::building *building : world->buildings.all) {

// Check that we're not comparing ourselves;

if (building->id == this->id) {

continue;

}

// Check if the building is on our z level, if it isn't

// then it can't overlap the hospital (until Toady implements

// multi-z buildings

if (building->z != this->z) {

continue;

}

// DF defines activity zones multiple times in the building structure

// If axises agree with each other, we're looking at a reflection of

// ourselves

if (building->x1 == this->x1 &&

building->x2 == this->x2 &&

building->y1 == this->y1 &&

building->y2 == this->y2) {

continue;

}

// Check for X/Y overlap

// I can't believe I had to look this up -_-;

// http://stackoverflow.com/questions/306316/determine-if-two-rectangles-overlap-each-other

if ((this->x1 > building->x2 ||

building->x1 > this->x2 ||

this->y1 > building->y2 ||

building->y1 > this->y2)) {

continue;

}

// Crap, building overlaps, we need to figure out where it is in the hospital

// NOTE: under some conditions, this generates a false warning. Not a lot I can do about it

// Mark spots used by that building as used; FIXME: handle special logic for traction benches and such

int overlap_x1 = std::max(building->x1, this->x1);

int overlap_y1 = std::max(building->y1, this->y1);

int overlap_x2 = std::min(building->x2, this->x2);

int overlap_y2 = std::min(building->y2, this->y2);

for (int x = overlap_x1; x <= overlap_x2; x++) {

for (int y = overlap_y1; y <= overlap_y2; y++) {

int spot_index = (x - this->x1) + (this->length * (y - this->y1));

spots_in_use.at(spot_index) = true;

}

}

}

int32_t id = patient->getID();

// Remove them from the hospital

// We can safely iterate here because once we delete the unit

// we no longer use the iterator

for (vector<Patient*>::iterator accepted_patient = this->accepted_patients.begin(); accepted_patient != this->accepted_patients.end(); accepted_patient++) {

if ( (*accepted_patient)->getID() == id) {

out.print("Discharging unit %d from hospital %d\n", id, this->id);

// Reclaim their spot

spots_in_use.at((*accepted_patient)->getSpotIndex()) = false;

this->spots_open++;

delete (*accepted_patient);

this->accepted_patients.erase(accepted_patient);

break;

}

}

// And the master list

tracked_units.erase(id);

return;

// Where the magic happens

for (Patient *patient : this->accepted_patients) {

int id = patient->getID();

df::unit *real_unit = df::unit::find(id);

// Check to make sure the unit hasn't expired before assigning a job, or if they've been healed

if (!real_unit || !Units::isActive(real_unit) || !real_unit->health->flags.bits.needs_healthcare) {

// discharge the patient from the hospital

this->dischargePatient(patient, out);

return;

}

// Give the unit a job if they don't have any

if (!real_unit->job.current_job) {

// Create REST struct

df::job * job = new df::job;

DFHack::Job::linkIntoWorld(job);

job->pos.x = patient->returnX();

job->pos.y = patient->returnY();

job->pos.z = patient->returnZ();

job->flags.bits.special = 1;

job->job_type = df::enums::job_type::Rest;

df::general_ref *ref = df::allocate<df::general_ref_unit_workerst>();

ref->setID(real_unit->id);

job->general_refs.push_back(ref);

real_unit->job.current_job = job;

job->wait_timer = 1600;

out.print("Telling intelligent unit %d to report to the hospital!\n", real_unit->id);

}

}

if (dwarfvet_enabled) {

out.print("Clearing all animal hospitals\n");

}

for (AnimalHospital *animal_hospital : animal_hospital_zones) {

delete animal_hospital;

}

animal_hospital_zones.clear();

{

commands.push_back(PluginCommand(

"dwarfvet",

"Allows animals to be treated at animal hospitals",

dwarfvet));

return CR_OK;

if (Buildings::isHospital(building) && Buildings::isAnimalTraining(building) && Buildings::isActive(building)) {

return true;

}

return false;

// We compare hospitals by checking if positions are identical, not by ID

// since activity zones can easily be changed in size

if ( hospital1->x1 == hospital2->x1 &&

hospital1->x2 == hospital2->x2 &&

hospital1->y1 == hospital2->y1 &&

hospital1->y2 == hospital2->y2 &&

hospital1->z == hospital2->z) {

return true;

}

return false;

if ( !dwarfvet_enabled )

return;

CoreSuspender suspend;

int32_t own_race_id = df::global::ui->race_id;

/**

vector<df::building*> hospitals_on_map;

// Because C++ iterators suck, we're going to build a temporary vector with the AHZ, and then

// copy it for my own bloody sanity (and compilance with the STL spec)

vector<AnimalHospital*> ahz_scratch;

// Holding area for things to be added to the scratch

vector<df::building*> to_be_added;

// Walk the building tree, and generate a list of animal hospitals on the map

for (df::building* building : df::building::get_vector()) {

if (isActiveAnimalHospital(building)) {

hospitals_on_map.push_back(building);

}

}

int count_of_hospitals = hospitals_on_map.size();

int hospitals_cached = animal_hospital_zones.size();

//out.print ("count_of_Hospitals: %d, hospitals_cached: %d\n", count_of_hospitals, hospitals_cached);

// It's possible our hospital cache is empty, if so, simply copy it, and jump to the main logic

if (!hospitals_cached && count_of_hospitals) {

out.print("Populating hospital cache:\n");

for (df::building *current_hospital : hospitals_on_map) {

AnimalHospital * hospital = new AnimalHospital(current_hospital, out);

out.print(" Found animal hospital %d at x1: %d, y1: %d, z: %d from valid hospital list\n",

hospital->getID(),

current_hospital->x1,

current_hospital->y1,

current_hospital->z

);

animal_hospital_zones.push_back(hospital);

}

goto processUnits;

}

if (!count_of_hospitals && !hospitals_cached) {

// No hospitals found, cache is empty, just return

goto cleanup;

}

// Now walk our list of known hospitals, do a bit of checking, then compare

// TODO: this doesn't handle zone resizes at all

for (AnimalHospital *animal_hospital : animal_hospital_zones) {

// If a zone is changed at all, DF seems to reallocate it.

//

// Each AnimalHospital has a "to_be_deleted" bool. We're going to set that to true, and clear it if we can't

// find a matching hospital. This limits the number of times we need to walk through the AHZ list to twice, and

// lets us cleanly report it later

//

// Surviving hospitals will be copied to scratch which will become the new AHZ vector

animal_hospital->to_be_deleted = true;

for (df::building *current_hospital : hospitals_on_map) {

/* Keep the hospital if its still valid */

if (animal_hospital->getID() == current_hospital->id) {

ahz_scratch.push_back(animal_hospital);

animal_hospital->to_be_deleted = false;

break;

}

}

}

// Report what we're deleting by checking the to_be_deleted bool.

//

// Whatsever left is added to the pending add list

for (AnimalHospital *animal_hospital : animal_hospital_zones) {

if (animal_hospital->to_be_deleted) {

out.print("Hospital #%d removed\n", animal_hospital->getID());

delete animal_hospital;

}

}

/* Now we need to walk the scratch and add anything that is a hospital and wasn't in the vector */

for (df::building *current_hospital : hospitals_on_map) {

bool new_hospital = true;

for (AnimalHospital *animal_hospital : ahz_scratch) {

if (animal_hospital->getID() == current_hospital->id) {

// Next if we're already here

new_hospital = false;

break;

}

}

// Add it if its new

if (new_hospital == true) to_be_added.push_back(current_hospital);

}

/* Now add it to the scratch AHZ */

for (df::building *current_hospital : to_be_added) {

// Add it to the vector

out.print("Adding new hospital #id: %d at x1 %d y1: %d z: %d\n",

current_hospital->id,

current_hospital->x1,

current_hospital->y1,

current_hospital->z

);

AnimalHospital * hospital = new AnimalHospital(current_hospital, out);

ahz_scratch.push_back(hospital);

}

/* Copy the scratch to the AHZ */

animal_hospital_zones = ahz_scratch;

// We always recheck the cache instead of counts because someone might have removed then added a hospital

processUnits:

/* Code borrowed from petcapRemover.cpp */

for (df::unit *unit : df::unit::get_vector()) {

/* As hilarious as it would be, lets not treat FB :) */

if ( !Units::isActive(unit) || unit->flags1.bits.active_invader || unit->flags2.bits.underworld || unit->flags2.bits.visitor_uninvited || unit->flags2.bits.visitor ) {

continue;

}

if ( !Units::isTamable(unit)) {

continue;

}

/**

// 1. Make sure its our own civ

if (!Units::isOwnCiv(unit)) {

continue;

}

// 2. Check for tameness

if (unit->training_level == df::animal_training_level::WildUntamed) {

// We don't IMMEDIATELY continue here, if the unit is

// part of our civ, it indiciates it WAS tamed, and reverted

// from SemiWild. Clear its civ flag so it looses TRAPAVOID

//

// Unfortunately, dwarves (or whatever is CIV_SELECTABLE)

// also have a default taming level of WildUntamed so

// check for this case

//

// Furthermore, it MIGHT be a werebeast, so check THAT too

// and exclude those as well.

//

// Finally, this breaks makeown. I might need to write a patch

// to set the tameness of "makeowned" units so dwarfvet can notice

// it

if (unit->race == own_race_id || unit->enemy.normal_race == own_race_id) {

continue;

} else {

unit->civ_id = -1;

out.print ("Clearing civ on unit: %d", unit->id);

}

}

// 3. Check for health struct

if (!unit->health) {

// Unit has not been injured ever; health struct MIA

continue;

}

// 4. Check the healthcare flags

if (unit->health->flags.bits.needs_healthcare) {

/**

// Now we need to find if this unit can be accepted at a hospital

bool awareOfUnit = tracked_units.count(unit->id);

// New unit for dwarfvet to be aware of!

if (!awareOfUnit) {

// The master list handles all patients which are accepted

// Check if this is a unit we're already aware of

for (auto animal_hospital : animal_hospital_zones) {

if (animal_hospital->acceptPatient(unit->id, out)) {

out.print("Accepted patient %d at hospital %d\n", unit->id, animal_hospital->getID());

tracked_units.insert(unit->id);

break;

}

}

}

}

}

// The final step, process all patients!

for (AnimalHospital *animal_hospital : animal_hospital_zones) {

animal_hospital->calculateHospital(true, out);

animal_hospital->processPatients(out);

}

cleanup:

EventManager::unregisterAll(plugin_self);

EventManager::EventHandler handle(tickHandler, howOften);

EventManager::registerTick(handle, howOften, plugin_self);

{

CoreSuspender suspend;

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

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

out.print("dwarfvet enabled!\n");

dwarfvet_enabled = true;

}

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

out.print("dwarvet disabled!\n");

dwarfvet_enabled = false;

}

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

out.print("Current animal hospitals are:\n");

for (df::building *building : df::building::get_vector()) {

if (isActiveAnimalHospital(building)) {

out.print(" at x1: %d, x2: %d, y1: %d, y2: %d, z: %d\n", building->x1, building->x2, building->y1, building->y2, building->z);

}

}

return CR_OK;

}

if ( parameters[a] == "report-usage") {

out.print("Current animal hospitals are:\n");

for (AnimalHospital *animal_hospital : animal_hospital_zones) {

animal_hospital->calculateHospital(true, out);

animal_hospital->reportUsage(out);

}

return CR_OK;

}

}

if ( !dwarfvet_enabled ) {

return CR_OK;

}

EventManager::unregisterAll(plugin_self);

EventManager::EventHandler handle(tickHandler, howOften);

EventManager::registerTick(handle, howOften, plugin_self);

return CR_OK;

{

if (enable && !dwarfvet_enabled) {

dwarfvet_enabled = true;

}

else if (!enable && dwarfvet_enabled) {

delete_animal_hospital_vector(out);

dwarfvet_enabled = false;

}

return CR_OK;

{

switch (event)

{

case DFHack::SC_MAP_LOADED:

break;

case DFHack::SC_MAP_UNLOADED:

delete_animal_hospital_vector(out);

dwarfvet_enabled = false;

break;

default:

break;

}

return CR_OK;