size_t operator()(const df::coord pos) const {

return pos.x*65537 + pos.y*17 + pos.z;

}

{

switch (event) {

case SC_MAP_LOADED:

buildings_do_onupdate = true;

break;

case SC_MAP_UNLOADED:

buildings_do_onupdate = false;

break;

default:

break;

}

{

buildings_do_onupdate = false;

df::job_list_link *link = world->jobs.list.next;

for (; link; link = link->next) {

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

if (job->job_type != job_type::ConstructBuilding)

continue;

if (job->job_items.empty())

continue;

buildings_do_onupdate = true;

for (size_t i = 0; i < job->items.size(); i++)

{

df::job_item_ref *iref = job->items[i];

if (iref->role != df::job_item_ref::Reagent)

continue;

df::job_item *item = vector_get(job->job_items, iref->job_item_idx);

if (!item)

continue;

// Convert Reagent to Hauled, while decrementing quantity

item->quantity = std::max(0, item->quantity-1);

iref->role = df::job_item_ref::Hauled;

iref->job_item_idx = -1;

}

}

{

df::building *bld = world->buildings.all[index];

building.x1 = bld->x1;

building.x2 = bld->x2;

building.y1 = bld->y1;

building.y2 = bld->y2;

building.z = bld->z;

building.material.index = bld->mat_index;

building.material.type = bld->mat_type;

building.type = bld->getType();

building.subtype = bld->getSubtype();

building.custom_type = bld->getCustomType();

building.origin = bld;

return true;

{

vector <building_def *> & bld_def = world->raws.buildings.all;

btypes.clear();

for (building_def *temp : bld_def)

{

btypes[temp->id] = temp->code;

}

return true;

{

CHECK_NULL_POINTER(bld);

return true;

int32_t id = building->id;

df::coord p1(min(building->x1, building->x2), min(building->y1,building->y2), building->z);

df::coord p2(max(building->x1, building->x2), max(building->y1,building->y2), building->z);

if (!is_civzone) {

// civzones can be dynamically shrunk so we don't bother to cache

// their boundaries. findCivzonesAt() will trim the cache as needed.

corner1[id] = p1;

corner2[id] = p2;

}

for (int32_t x = p1.x; x <= p2.x; x++) {

for (int32_t y = p1.y; y <= p2.y; y++) {

df::coord pt(x, y, building->z);

if (Buildings::containsTile(building, pt, is_civzone)) {

if (is_civzone)

locationToCivzones[pt].push_back(id);

else

locationToBuilding[pt] = id;

}

}

}

if (!world || !building_next_id)

return;

int32_t nextBuildingId = *building_next_id;

for (int32_t id = nextCivzone; id < nextBuildingId; ++id) {

auto &vec = world->buildings.other[buildings_other_id::ANY_ZONE];

int32_t idx = df::building::binsearch_index(vec, id);

if (idx > -1)

cacheBuilding(vec[idx], true);

}

nextCivzone = nextBuildingId;

df::coord pos) {

pvec->clear();

// Tiles have an occupancy->bits.building flag to quickly determine if it is

// covered by a buildling, but there is no such flag for civzones.

// Therefore, we need to make sure that our cache is authoratative.

// Otherwise, we would have to fall back to linearly scanning the list of

// all civzones on a cache miss.

//

// Since we guarantee our cache contains *at least* all tiles that are

// currently covered by civzones, we can conclude that if a tile is not in

// the cache, there is no civzone there. Civzones *can* be dynamically

// shrunk, so we still need to verify that civzones that once covered this

// tile continue to cover this tile.

cacheNewCivzones();

auto civzones_it = locationToCivzones.find(pos);

if (civzones_it == locationToCivzones.end())

return false;

set<int32_t> ids_to_remove;

auto &civzones = civzones_it->second;

for (int32_t id : civzones) {

int32_t idx = df::building::binsearch_index(

world->buildings.other[buildings_other_id::ANY_ZONE], id);

df::building_civzonest *civzone = NULL;

if (idx > -1)

civzone = world->buildings.other.ANY_ZONE[idx];

if (!civzone || civzone->z != pos.z ||

!containsTile(civzone, pos, true)) {

ids_to_remove.insert(id);

continue;

}

pvec->push_back(civzone);

}

// civzone no longer occupies this tile; update the cache

if (!ids_to_remove.empty()) {

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

if (ids_to_remove.count(*it)) {

it = civzones.erase(it);

continue;

}

++it;

}

if (civzones.empty())

locationToCivzones.erase(pos);

}

return !pvec->empty();

{

if (vertical)

size.x = 1;

else

size.y = 1;

center = size/2;

df::building_type type, int subtype, int custom, int direction)

{

using namespace df::enums::building_type;

if (size.x <= 0)

size.x = 1;

if (size.y <= 0)

size.y = 1;

switch (type)

{

case FarmPlot:

case Bridge:

case RoadDirt:

case RoadPaved:

case Stockpile:

case Civzone:

center = size/2;

return true;

case TradeDepot:

case Shop:

size = df::coord2d(5,5);

center = df::coord2d(2,2);

return false;

case SiegeEngine:

case Windmill:

case Wagon:

size = df::coord2d(3,3);

center = df::coord2d(1,1);

return false;

case AxleHorizontal:

makeOneDim(size, center, direction);

return true;

case Rollers:

makeOneDim(size, center, (direction&1) == 0);

return true;

case WaterWheel:

size = df::coord2d(3,3);

makeOneDim(size, center, direction);

return false;

case Workshop:

{

using namespace df::enums::workshop_type;

switch ((df::workshop_type)subtype)

{

case Quern:

case Millstone:

case Tool:

size = df::coord2d(1,1);

center = df::coord2d(0,0);

break;

case Siege:

case Kennels:

size = df::coord2d(5,5);

center = df::coord2d(2,2);

break;

case Custom:

if (auto def = df::building_def::find(custom))

{

size = df::coord2d(def->dim_x, def->dim_y);

center = df::coord2d(def->workloc_x, def->workloc_y);

break;

}

default:

size = df::coord2d(3,3);

center = df::coord2d(1,1);

}

return false;

}

case Furnace:

{

using namespace df::enums::furnace_type;

switch ((df::furnace_type)subtype)

{

case Custom:

if (auto def = df::building_def::find(custom))

{

size = df::coord2d(def->dim_x, def->dim_y);

center = df::coord2d(def->workloc_x, def->workloc_y);

break;

}

default:

size = df::coord2d(3,3);

center = df::coord2d(1,1);

}

return false;

}

case ScrewPump:

{

using namespace df::enums::screw_pump_direction;

switch ((df::screw_pump_direction)direction)

{

case FromEast:

size = df::coord2d(2,1);

center = df::coord2d(1,0);

break;

case FromSouth:

size = df::coord2d(1,2);

center = df::coord2d(0,1);

break;

case FromWest:

size = df::coord2d(2,1);

center = df::coord2d(0,0);

break;

default:

size = df::coord2d(1,2);

center = df::coord2d(0,0);

}

return false;

}

default:

size = df::coord2d(1,1);

center = df::coord2d(0,0);

return false;

}

const df::coord2d &size)

{

ext->extents = new df::building_extents_type[size.x*size.y];

ext->x = pos.x;

ext->y = pos.y;

ext->width = size.x;

ext->height = size.y;

memset(ext->extents, 1, size.x*size.y);

df::building_extents *ext,

bool create_ext,

bool allow_occupied,

bool allow_wall)

{

bool found_any = false;

for (int dx = 0; dx < size.x; dx++)

{

for (int dy = 0; dy < size.y; dy++)

{

df::coord tile = pos + df::coord(dx,dy,0);

df::building_extents_type *etile = NULL;

// Exclude using extents

if (ext && ext->extents)

{

etile = getExtentTile(*ext, tile);

if (!etile || !*etile)

continue;

}

// Look up map block

df::map_block *block = Maps::getTileBlock(tile);

if (!block)

return false;

df::coord2d btile = df::coord2d(tile) & 15;

bool allowed = true;

// Check occupancy and tile type

if (!allow_occupied &&

block->occupancy[btile.x][btile.y].bits.building)

allowed = false;

else

{

auto tile = block->tiletype[btile.x][btile.y];

if (!allow_wall && !HighPassable(tile))

allowed = false;

}

// Create extents if requested

if (allowed)

found_any = true;

else

{

if (!ext || !create_ext)

return false;

if (!ext->extents)

{

init_extents(ext, pos, size);

etile = getExtentTile(*ext, tile);

}

if (!etile)

return false;

*etile = df::building_extents_type::None;

}

}

}

return found_any;

{

CHECK_NULL_POINTER(bld);

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

return std::pair<df::coord,df::coord2d>(pos, df::coord2d(bld->x2+1,bld->y2+1) - pos);

bool force_extents = false)

{

auto psize = Buildings::getSize(bld);

if (force_extents && !bld->room.extents)

{

// populate the room structure if it's not set already

init_extents(&bld->room, psize.first, psize.second);

}

return Buildings::checkFreeTiles(psize.first, psize.second, &bld->room,

can_change && bld->isExtentShaped(),

!bld->isSettingOccupancy(),

bld->getType() ==

df::building_type::Civzone);

{

if (!ext || !ext->extents)

return defval;

int cnt = 0;

for (int i = 0; i < ext->width * ext->height; i++)

if (ext->extents[i])

cnt++;

return cnt;

{

CHECK_NULL_POINTER(bld);

if (room)

{

}

else

{

if (tile.x < bld->x1 || tile.x > bld->x2 || tile.y < bld->y1 || tile.y > bld->y2)

return false;

}

if (bld->room.extents && (room || bld->isExtentShaped()))

{

df::building_extents_type *etile = getExtentTile(bld->room, tile);

if (!etile || !*etile)

return false;

}

return true;

{

for (int dx = -1; dx <= size.x; dx++)

{

for (int dy = -1; dy <= size.y; dy++)

{

// skip corners

if ((dx < 0 || dx == size.x) && (dy < 0 || dy == size.y))

continue;

df::coord tile = pos + df::coord(dx,dy,0);

df::map_block *block = Maps::getTileBlock(tile);

if (!block)

continue;

df::coord2d btile = df::coord2d(tile) & 15;

if (!isOpenTerrain(block->tiletype[btile.x][btile.y]))

return true;

}

}

return false;

{

auto size = Buildings::getSize(bld).second;

int cnt = size.x * size.y;

if (bld->room.extents && bld->isExtentShaped())

cnt = Buildings::countExtentTiles(&bld->room, cnt);

return cnt/4 + 1;

{

CHECK_NULL_POINTER(bld);

CHECK_INVALID_ARGUMENT(bld->id == -1);

// Compute correct size and apply it

df::coord2d old_size = size;

df::coord2d center;

getCorrectSize(size, center, bld->getType(), bld->getSubtype(),

bld->getCustomType(), direction);

// Delete old extents if size has changed.

if (old_size != size && bld->room.extents)

{

delete[] bld->room.extents;

bld->room.extents = NULL;

}

bld->x2 = bld->x1 + size.x - 1;

bld->y2 = bld->y1 + size.y - 1;

bld->centerx = bld->x1 + center.x;

bld->centery = bld->y1 + center.y;

auto type = bld->getType();

using namespace df::enums::building_type;

switch (type)

{

case WaterWheel:

{

auto obj = (df::building_water_wheelst*)bld;

obj->is_vertical = !!direction;

break;

}

case AxleHorizontal:

{

auto obj = (df::building_axle_horizontalst*)bld;

obj->is_vertical = !!direction;

break;

}

case ScrewPump:

{

auto obj = (df::building_screw_pumpst*)bld;

obj->direction = (df::screw_pump_direction)direction;

break;

}

case Rollers:

{

auto obj = (df::building_rollersst*)bld;

obj->direction = (df::screw_pump_direction)direction;

break;

}

case Bridge:

{

auto obj = (df::building_bridgest*)bld;

auto psize = getSize(bld);

obj->gate_flags.bits.has_support = hasSupport(psize.first, psize.second);

obj->direction = (df::building_bridgest::T_direction)direction;

break;

}

default:

break;

}

bool ok = checkBuildingTiles(bld, true);

if (type != Construction)

bld->setMaterialAmount(computeMaterialAmount(bld));

return ok;

{

bool use_extents = bld->room.extents && bld->isExtentShaped();

bool stockpile = (bld->getType() == building_type::Stockpile);

bool complete = (bld->getBuildStage() >= bld->getMaxBuildStage());

if (remove)

stockpile = complete = false;

for (int tx = bld->x1; tx <= bld->x2; tx++)

{

for (int ty = bld->y1; ty <= bld->y2; ty++)

{

df::coord tile(tx,ty,bld->z);

if (use_extents)

{

df::building_extents_type *etile = getExtentTile(bld->room, tile);

if (!etile || !*etile)

continue;

}

df::map_block *block = Maps::getTileBlock(tile);

df::coord2d btile = df::coord2d(tile) & 15;

auto &des = block->designation[btile.x][btile.y];

des.bits.pile = stockpile;

if (!remove)

des.bits.dig = tile_dig_designation::No;

if (complete)

bld->updateOccupancy(tx, ty);

else

{

auto &occ = block->occupancy[btile.x][btile.y];

if (remove)

occ.bits.building = tile_building_occ::None;

else

occ.bits.building = tile_building_occ::Planned;

}

}

}

{

{