for ( auto j = tickQueue.find(getRidOf.freq); j != tickQueue.end(); ) {

if ( (*j).first > getRidOf.freq )

break;

if ( (*j).second != getRidOf ) {

j++;

continue;

}

j = tickQueue.erase(j);

}

switch (t) {

case EventType::TICK:

return manageTickEvent;

case EventType::JOB_INITIATED:

return manageJobInitiatedEvent;

case EventType::JOB_STARTED:

return manageJobStartedEvent;

case EventType::JOB_COMPLETED:

return manageJobCompletedEvent;

case EventType::UNIT_NEW_ACTIVE:

return manageNewUnitActiveEvent;

case EventType::UNIT_DEATH:

return manageUnitDeathEvent;

case EventType::ITEM_CREATED:

return manageItemCreationEvent;

case EventType::BUILDING:

return manageBuildingEvent;

case EventType::CONSTRUCTION:

return manageConstructionEvent;

case EventType::SYNDROME:

return manageSyndromeEvent;

case EventType::INVASION:

return manageInvasionEvent;

case EventType::INVENTORY_CHANGE:

return manageEquipmentEvent;

case EventType::REPORT:

return manageReportEvent;

case EventType::UNIT_ATTACK:

return manageUnitAttackEvent;

case EventType::UNLOAD:

return manageUnloadEvent;

case EventType::INTERACTION:

return manageInteractionEvent;

case EventType::EVENT_MAX:

return nullptr;

//default:

//we don't do this... because then the compiler wouldn't error for missing cases in the enum

}

return nullptr;

std::array<eventManager_t, EventType::EVENT_MAX> managers{};

auto t = (EventType::EventType) 0;

while (t < EventType::EVENT_MAX) {

managers[t] = getManager(t);

t = (EventType::EventType) int(t + 1);

}

return managers;

int32_t id;

int32_t completion_timer;

uint32_t flags_bits_repeat;

template<typename A, typename B>

size_t operator()(const std::pair<A,B>& p) const {

auto h1 = std::hash<A>{}(p.first);

auto h2 = std::hash<B>{}(p.second);

return h1 ^ (h2 << 1);

}

auto &core = Core::getInstance();

auto &counters = core.perf_counters;

uint32_t start_ms = core.p->getTickCount();

const char * plugin_name = !handle.plugin ? "<null>" : handle.plugin->getName().c_str();

handle.eventHandler(out, arg);

counters.incCounter(counters.event_manager_event_per_plugin_ms[eventType][plugin_name], start_ms);

if (!df::global::world)

return;

unordered_set<EventHandler> toRemove;

int32_t tick = df::global::world->frame_counter;

while ( !tickQueue.empty() ) {

if ( tick < (*tickQueue.begin()).first )

break;

EventHandler &handle = (*tickQueue.begin()).second;

tickQueue.erase(tickQueue.begin());

DEBUG(log,out).print("calling handler for tick event\n");

run_handler(out, EventType::TICK, handle, (void*)intptr_t(tick));

toRemove.insert(handle);

}

if ( toRemove.empty() )

return;

for ( auto a = handlers[EventType::TICK].begin(); a != handlers[EventType::TICK].end(); ) {

EventHandler &handle = (*a).second;

if ( toRemove.find(handle) == toRemove.end() ) {

a++;

continue;

}

a = handlers[EventType::TICK].erase(a);

toRemove.erase(handle);

if ( toRemove.empty() )

break;

}

if (!df::global::world)

return;

if (!df::global::job_next_id)

return;

if ( lastJobId == -1 ) {

lastJobId = *df::global::job_next_id - 1;

return;

}

if ( lastJobId+1 == *df::global::job_next_id ) {

return; //no new jobs

}

multimap<Plugin*,EventHandler> copy(handlers[EventType::JOB_INITIATED].begin(), handlers[EventType::JOB_INITIATED].end());

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

if ( link->item == nullptr )

continue;

if ( link->item->id <= lastJobId )

continue;

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for job initiated event\n");

run_handler(out, EventType::JOB_INITIATED, handle, (void*)link->item);

}

}

lastJobId = *df::global::job_next_id - 1;

if (!df::global::world)

return;

// iterate event handler callbacks

multimap<Plugin*, EventHandler> copy(handlers[EventType::JOB_STARTED].begin(), handlers[EventType::JOB_STARTED].end());

std::vector<int32_t> newStartedJobs;

newStartedJobs.reserve(startedJobs.size());

for (const auto jobPtr : df::global::world->jobs.list) {

// posting_index of -1 implies a worker has been assigned to a new job.

if (jobPtr->posting_index == -1) {

auto jobId = jobPtr->id;

newStartedJobs.push_back(jobId);

/*

if (!std::binary_search(startedJobs.begin(), startedJobs.end(), jobId)) {

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for job started event\n");

run_handler(out, EventType::JOB_STARTED, handle, jobPtr);

}

}

}

}

startedJobs = std::move(newStartedJobs);

if (!df::global::world)

return;

multimap<Plugin*, EventHandler> copy(handlers[EventType::JOB_COMPLETED].begin(), handlers[EventType::JOB_COMPLETED].end());

std::vector<JobCompleteData> nowJobs;

// predict the size in advance, this will prevent or reduce memory reallocation.

nowJobs.reserve(prevJobs.size());

for (const auto jobPtr : df::global::world->jobs.list) {

auto& job = *jobPtr;

auto seenIt = seenJobs.find(job.id);

if (seenIt != seenJobs.end()) {

/*

auto seenJob = seenIt->second.get();

// The key here is to strategically check the most important bits to reduce churn.

if (seenJob->flags.whole != job.flags.whole

|| (seenJob->items.size() != job.items.size())

|| (seenJob->general_refs.size() != job.general_refs.size())) {

seenIt->second = Job::JobUniquePtr(Job::cloneJobStruct(&job, true));

}

} else if (job.completion_timer != -1) {

// Restrict additions to seenJobs to jobs that we know have started.

seenJobs.emplace(job.id, Job::JobUniquePtr(Job::cloneJobStruct(&job, true)));

}

/*

nowJobs.emplace_back(job.id, job.completion_timer, (bool)job.flags.bits.repeat);

}

// Do we want this check?

//assert(std::is_sorted(nowJobs.begin(), nowJobs.end()));

// uncomment if bay12 changes things to make job IDs not be in ascending order.

//std::ranges::sort(nowJobs, {}, &JobCompleteData::id);

#if 0

//testing info on job initiation/completion

//newly allocated jobs

for ( auto j = nowJobs.begin(); j != nowJobs.end(); j++ ) {

if ( prevJobs.find((*j).first) != prevJobs.end() )

continue;

df::job& job1 = *(*j).second;

out.print("new job\n"

" location : {:#X}\n"

" id : {}\n"

" type : {} {}\n"

" working : {}\n"

" completion_timer : {}\n"

" workerID : {}\n"

" time : {} -> {}\n"

"\n", job1.list_link->item, job1.id, job1.job_type, ENUM_ATTR(job_type, caption, job1.job_type), job1.flags.bits.working, job1.completion_timer, getWorkerID(&job1), tick0, tick1);

}

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

df::job& job0 = *(*i).second;

auto j = nowJobs.find((*i).first);

if ( j == nowJobs.end() ) {

out.print("job deallocated\n"

" location : {:#X}\n"

" id : {}\n"

" type : {} {}\n"

" working : {}\n"

" completion_timer : {}\n"

" workerID : {}\n"

" time : {} -> {}\n"

,job0.list_link == NULL ? 0 : job0.list_link->item, job0.id, job0.job_type, ENUM_ATTR(job_type, caption, job0.job_type), job0.flags.bits.working, job0.completion_timer, getWorkerID(&job0), tick0, tick1);

continue;

}

df::job& job1 = *(*j).second;

if ( job0.flags.bits.working == job1.flags.bits.working &&

(job0.completion_timer == job1.completion_timer || (job1.completion_timer > 0 && job0.completion_timer-1 == job1.completion_timer)) &&

getWorkerID(&job0) == getWorkerID(&job1) )

continue;

out.print("job change\n"

" location : {:#X} -> {:#X}\n"

" id : {} -> {}\n"

" type : {} -> {}\n"

" type : {} -> {}\n"

" working : {} -> {}\n"

" completion timer : {} -> {}\n"

" workerID : {} -> {}\n"

" time : {} -> {}\n"

"\n",

job0.list_link->item, job1.list_link->item,

job0.id, job1.id,

job0.job_type, job1.job_type,

ENUM_ATTR(job_type, caption, job0.job_type), ENUM_ATTR(job_type, caption, job1.job_type),

job0.flags.bits.working, job1.flags.bits.working,

job0.completion_timer, job1.completion_timer,

getWorkerID(&job0), getWorkerID(&job1),

tick0, tick1

);

}

#endif

auto prevIt = prevJobs.begin();

auto nowIt = nowJobs.begin();

/*

while (prevIt != prevJobs.end()) {

auto& prevJob = *prevIt;

if (nowIt == nowJobs.end() || prevJob.id != nowIt->id) { // job ID is in prevJobs. ID does not exist in nowJobs.

// recently finished or cancelled job

if (!prevJob.flags_bits_repeat && prevJob.completion_timer == 0) {

// It should be in seenJobs.

auto seenIt = seenJobs.find(prevJob.id);

if (seenIt != seenJobs.end()) {

df::job& seenJob = *seenIt->second;

for (auto& [_, handle] : copy) {

DEBUG(log, out).print("calling handler for job completed event\n");

run_handler(out, EventType::JOB_COMPLETED, handle, (void*)&seenJob);

}

seenJobs.erase(prevJob.id);

}

}

} else { // prevIt job ID and nowIt job ID are equal.

// could have just finished if it's a repeat job

if (prevJob.flags_bits_repeat && prevJob.completion_timer == 0

&& nowIt->completion_timer == -1) {

// It should be in seenJobs.

auto seenIt = seenJobs.find(prevJob.id);

if (seenIt != seenJobs.end()) {

df::job& seenJob = *seenIt->second;

// still false positive if cancelled at EXACTLY the right time, but experiments show this doesn't happen

for (auto& [_, handle] : copy) {

DEBUG(log, out).print("calling handler for repeated job completed event\n");

run_handler(out, EventType::JOB_COMPLETED, handle, (void*)&seenJob);

}

}

}

// prevIt has caught up to nowIt.

++nowIt;

}

++prevIt;

}

/*

if (seenJobs.size() > nowJobs.size() * 2) {

std::unordered_map<int32_t, Job::JobUniquePtr> newMap;

newMap.reserve(nowJobs.size());

for (auto& data : nowJobs) {

auto it = seenJobs.find(data.id);

if (it != seenJobs.end()) {

newMap.emplace(std::move(*it));

}

}

seenJobs.swap(newMap);

}

prevJobs = std::move(nowJobs);

if (!df::global::world)

return;

multimap<Plugin*,EventHandler> copy(handlers[EventType::UNIT_NEW_ACTIVE].begin(), handlers[EventType::UNIT_NEW_ACTIVE].end());

unordered_set<int32_t> next_activeUnits;

vector<int32_t> newly_active_unit_ids;

for (df::unit* unit : df::global::world->units.active) {

if (!Units::isActive(unit))

continue;

next_activeUnits.emplace(unit->id);

if (!activeUnits.count(unit->id))

newly_active_unit_ids.emplace_back(unit->id);

}

for (int32_t unit_id : newly_active_unit_ids) {

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for new unit event\n");

run_handler(out, EventType::UNIT_NEW_ACTIVE, handle, (void*) intptr_t(unit_id)); // intptr_t() avoids cast from smaller type warning

}

}

activeUnits = std::move(next_activeUnits);

if (!df::global::world)

return;

multimap<Plugin*,EventHandler> copy(handlers[EventType::UNIT_DEATH].begin(), handlers[EventType::UNIT_DEATH].end());

vector<int32_t> dead_unit_ids;

for (auto unit : df::global::world->units.all) {

//if ( unit->counters.death_id == -1 ) {

if ( Units::isActive(unit) ) {

livingUnits.insert(unit->id);

continue;

}

if (!Units::isDead(unit)) continue; // for units that have left the map but aren't dead

//dead: if dead since last check, trigger events

if ( livingUnits.find(unit->id) == livingUnits.end() )

continue;

livingUnits.erase(unit->id);

dead_unit_ids.emplace_back(unit->id);

}

for (int32_t unit_id : dead_unit_ids) {

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for unit death event\n");

run_handler(out, EventType::UNIT_DEATH, handle, (void*)intptr_t(unit_id));

}

}

if (!df::global::world)

return;

if (!df::global::item_next_id)

return;

if ( nextItem >= *df::global::item_next_id ) {

return;

}

multimap<Plugin*,EventHandler> copy(handlers[EventType::ITEM_CREATED].begin(), handlers[EventType::ITEM_CREATED].end());

size_t index = df::item::binsearch_index(df::global::world->items.all, nextItem, false);

if ( index != 0 ) index--;

std::vector<int32_t> created_items;

for ( size_t a = index; a < df::global::world->items.all.size(); a++ ) {

df::item* item = df::global::world->items.all[a];

//already processed

if ( item->id < nextItem )

continue;

//invaders

if ( item->flags.bits.foreign )

continue;

//traders who bring back your items?

if ( item->flags.bits.trader )

continue;

//migrants

if ( item->flags.bits.owned )

continue;

//spider webs don't count

if ( item->flags.bits.spider_web )

continue;

created_items.push_back(item->id);

}

// handle all created items

for (int32_t item_id : created_items) {

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for item created event\n");

run_handler(out, EventType::ITEM_CREATED, handle, (void*)intptr_t(item_id));

}

}

nextItem = *df::global::item_next_id;

if (!df::global::world)

return;

if (!df::global::building_next_id)

return;

/*

multimap<Plugin*,EventHandler> copy(handlers[EventType::BUILDING].begin(), handlers[EventType::BUILDING].end());

//first alert people about new buildings

vector<int32_t> new_buildings;

for ( int32_t a = nextBuilding; a < *df::global::building_next_id; a++ ) {

int32_t index = df::building::binsearch_index(df::global::world->buildings.all, a);

if ( index == -1 ) {

//out.print("%s, line %d: Couldn't find new building with id %d.\n", __FILE__, __LINE__, a);

//the tricky thing is that when the game first starts, it's ok to skip buildings, but otherwise, if you skip buildings, something is probably wrong. TODO: make this smarter

continue;

}

buildings.insert(a);

new_buildings.emplace_back(a);

}

nextBuilding = *df::global::building_next_id;

//now alert people about destroyed buildings

for ( auto it = buildings.begin(); it != buildings.end(); ) {

int32_t id = *it;

int32_t index = df::building::binsearch_index(df::global::world->buildings.all,id);

if ( index != -1 ) {

++it;

continue;

}

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for destroyed building event\n");

run_handler(out, EventType::BUILDING, handle, (void*)intptr_t(id));

}

it = buildings.erase(it);

}

//alert people about newly created buildings

std::for_each(new_buildings.begin(), new_buildings.end(), [&](int32_t building){

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for created building event\n");

run_handler(out, EventType::BUILDING, handle, (void*)intptr_t(building));

}

});

if (!df::global::world)

return;

//unordered_set<df::construction*> constructionsNow(df::global::world->event.constructions.begin(), df::global::world->event.constructions.end());

multimap<Plugin*, EventHandler> copy(handlers[EventType::CONSTRUCTION].begin(), handlers[EventType::CONSTRUCTION].end());

unordered_set<df::construction> next_construction_set; // will be swapped with constructions

next_construction_set.reserve(constructions.bucket_count());

vector<df::construction> new_constructions;

// find new constructions - swapping found constructions over from constructions to next_construction_set

for (auto c : df::global::world->event.constructions) {

auto &construction = *c;

auto it = constructions.find(construction);

if (it == constructions.end()) {

// handle new construction event later

new_constructions.emplace_back(construction);

}

else {

constructions.erase(it);

}

next_construction_set.emplace(construction);

}

constructions.swap(next_construction_set);

// now next_construction_set contains all the constructions that were removed (not found in df::global::world->event.constructions)

for (auto& construction : next_construction_set) {

// handle construction removed event

for (const auto &[_,handle]: copy) {

DEBUG(log,out).print("calling handler for destroyed construction event\n");

run_handler(out, EventType::CONSTRUCTION, handle, (void*) &construction);

}

}

// now handle all the new constructions

for (auto& construction : new_constructions) {

for (const auto &[_,handle]: copy) {

DEBUG(log,out).print("calling handler for created construction event\n");

run_handler(out, EventType::CONSTRUCTION, handle, (void*) &construction);

}

}

if (!df::global::world)

return;

multimap<Plugin*,EventHandler> copy(handlers[EventType::SYNDROME].begin(), handlers[EventType::SYNDROME].end());

int32_t highestTime = -1;

std::vector<SyndromeData> new_syndrome_data;

for (auto unit : df::global::world->units.all) {

for ( size_t b = 0; b < unit->syndromes.active.size(); b++ ) {

df::unit_syndrome* syndrome = unit->syndromes.active[b];

int32_t startTime = syndrome->year*ticksPerYear + syndrome->year_time;

if ( startTime > highestTime )

highestTime = startTime;

if ( startTime <= lastSyndromeTime )

continue;

new_syndrome_data.emplace_back(unit->id, b);

}

}

for (auto& data : new_syndrome_data) {

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for syndrome event\n");

run_handler(out, EventType::SYNDROME, handle, (void*)&data);

}

}

lastSyndromeTime = highestTime;

if (!df::global::plotinfo)

return;

multimap<Plugin*,EventHandler> copy(handlers[EventType::INVASION].begin(), handlers[EventType::INVASION].end());

if ( df::global::plotinfo->invasions.next_id <= nextInvasion )

return;

nextInvasion = df::global::plotinfo->invasions.next_id;

for (auto &[_,handle] : copy) {

DEBUG(log,out).print("calling handler for invasion event\n");

run_handler(out, EventType::INVASION, handle, (void*)intptr_t(nextInvasion-1));

}

if (!df::global::world)

return;

multimap<Plugin*,EventHandler> copy(handlers[EventType::INVENTORY_CHANGE].begin(), handlers[EventType::INVENTORY_CHANGE].end());

unordered_map<int32_t, InventoryItem> itemIdToInventoryItem;

unordered_set<int32_t> currentlyEquipped;

vector<InventoryChangeData> equipment_pickups;

vector<InventoryChangeData> equipment_drops;

vector<InventoryChangeData> equipment_changes;

// This vector stores the pointers to newly created changed items

// needed as the stack allocated temporary (in the loop) is lost when we go to

// handle the event calls, so we move that data to the heap if its needed,

// and then once we are done we delete everything.

vector<InventoryItem*> changed_items;

for (auto unit : df::global::world->units.all) {

itemIdToInventoryItem.clear();

currentlyEquipped.clear();

/*if ( unit->flags1.bits.inactive )

auto oldEquipment = equipmentLog.find(unit->id);

bool hadEquipment = oldEquipment != equipmentLog.end();

vector<InventoryItem>* temp;