if pos and dfhack.maps.isValidTilePos(pos) then

local tiletype = dfhack.maps.getTileType(pos)

return tiletype and (

df.tiletype.attrs[tiletype].shape == df.tiletype_shape.NONE

or df.tiletype.attrs[tiletype].material == df.tiletype_material.AIR

)

end

return true

local toValidEnumValue = function(value, enum, default)

return value ~= nil and enum[value] and value or default

end

local toValidOptionValue = function(value)

return value == nil and -1 or value

end

local tiletype = {

shape = toValidEnumValue(target.shape, df.tiletype_shape, df.tiletype_shape.NONE),

material = toValidEnumValue(target.material, df.tiletype_material, df.tiletype_material.NONE),

special = toValidEnumValue(target.special, df.tiletype_special, df.tiletype_special.NONE),

variant = toValidEnumValue(target.variant, df.tiletype_variant, df.tiletype_variant.NONE),

hidden = toValidOptionValue(target.hidden),

light = toValidOptionValue(target.light),

subterranean = toValidOptionValue(target.subterranean),

skyview = toValidOptionValue(target.skyview),

aquifer = toValidOptionValue(target.aquifer),

autocorrect = target.autocorrect == nil and 0 or target.autocorrect,

}

tiletype.stone_material = tiletype.material == df.tiletype_material.STONE and target.stone_material or -1

tiletype.vein_type = tiletype.material ~= df.tiletype_material.STONE and -1 or toValidEnumValue(target.vein_type, df.inclusion_type, df.inclusion_type.CLUSTER)

return plugin.tiletypes_setTile(pos, tiletype)

spec.left_specs = safe_index(spec, "left_specs", "chars") and spec.left_specs or {chars={}}

spec.right_specs = safe_index(spec, "right_specs", "chars") and spec.right_specs or {chars={}}

spec.width = spec.width or -1

spec.height = spec.height or -1

spec.spacing = spec.spacing or -1

local getSpecWidth = function(value)

local width = 0

for _,v in pairs(value.chars) do

width = math.max(width, #v)

end

return width

end

local left_width = getSpecWidth(spec.left_specs)

local right_width = getSpecWidth(spec.right_specs)

spec.width = spec.width >= 0 and spec.width or (left_width + right_width + math.max(spec.spacing, 0))

local left_height = #spec.left_specs.chars

local right_height = #spec.right_specs.chars

spec.height = spec.height >= 0 and spec.height or math.max(left_height, right_height)

local left_tokens = widgets.makeButtonLabelText(spec.left_specs)

local right_tokens = widgets.makeButtonLabelText(spec.right_specs)

local centerHeight = function(tokens, height)

local height_spacing = (spec.height - height) // 2

for i=1, height_spacing do

table.insert(tokens, 1, NEWLINE)

end

height_spacing = spec.height - height - height_spacing

for i=1, height_spacing do

table.insert(tokens, NEWLINE)

end

end

centerHeight(left_tokens, left_height)

centerHeight(right_tokens, right_height)

local right_start = spec.spacing >= 0 and (left_width + spec.spacing + 1) or math.max(left_width, spec.width - right_width)

local label_tokens = {}

local left_cursor = 1

local right_cursor = 1

for y=1, spec.height do

for x=1, spec.width do

local token = nil

if x <= left_width then

token = left_tokens[left_cursor]

token = token ~= NEWLINE and token or nil

if token then

left_cursor = left_cursor + 1

end

elseif x >= right_start then

token = right_tokens[right_cursor]

token = token ~= NEWLINE and token or nil

if token then

right_cursor = right_cursor + 1

end

end

table.insert(label_tokens, token or EMPTY_TOKEN)

end

if y ~= spec.height then

-- Move the cursors to the token following the next NEWLINE

while left_tokens[left_cursor - 1] ~= NEWLINE do

left_cursor = left_cursor + 1

end

while right_tokens[right_cursor - 1] ~= NEWLINE do

right_cursor = right_cursor + 1

end

end

table.insert(label_tokens, NEWLINE)

end

return label_tokens

return pos.x <= self.x2

and pos.x >= self.x1

and pos.y <= self.y2

and pos.y >= self.y1

return overlap_rect.x1 <= self.x2

and overlap_rect.x2 >= self.x1

and overlap_rect.y1 <= self.y2

and overlap_rect.y2 >= self.y1

local output = {}

-- If there is any overlap with the screen rect

if self:isOverlapping(clip_rect) then

local temp_rect = Rect(self)

-- Get rect to the left of the clip rect

if temp_rect.x1 <= clip_rect.x1 then

table.insert(output, Rect{

x1= temp_rect.x1,

x2= math.min(temp_rect.x2, clip_rect.x1),

y1= temp_rect.y1,

y2= temp_rect.y2

})

temp_rect.x1 = clip_rect.x1

end

-- Get rect to the right of the clip rect

if temp_rect.x2 >= clip_rect.x2 then

table.insert(output, Rect{

x1= math.max(temp_rect.x1, clip_rect.x2),

x2= temp_rect.x2,

y1= temp_rect.y1,

y2= temp_rect.y2

})

temp_rect.x2 = clip_rect.x2

end

-- Get rect above the clip rect

if temp_rect.y1 <= clip_rect.y1 then

table.insert(output, Rect{

x1= temp_rect.x1,

x2= temp_rect.x2,

y1= temp_rect.y1,

y2= math.min(temp_rect.y2, clip_rect.y1)

})

temp_rect.y1 = clip_rect.y1

end

-- Get rect below the clip rect

if temp_rect.y2 >= clip_rect.y2 then

table.insert(output, Rect{

x1= temp_rect.x1,

x2= temp_rect.x2,

y1= math.max(temp_rect.y1, clip_rect.y2),

y2= temp_rect.y2

})

temp_rect.y2 = clip_rect.y2

end

else

-- No overlap

table.insert(output, self)

end

return output

local view_dims = dfhack.gui.getDwarfmodeViewDims()

local tile_view_size = xy2pos(view_dims.map_x2 - view_dims.map_x1 + 1, view_dims.map_y2 - view_dims.map_y1 + 1)

local display_view_size = xy2pos(df.global.init.display.grid_x, df.global.init.display.grid_y)

local display_to_tile_ratio = xy2pos(tile_view_size.x / display_view_size.x, tile_view_size.y / display_view_size.y)

return Rect{

x1= self.x1 * display_to_tile_ratio.x - 1,

x2= self.x2 * display_to_tile_ratio.x + 1,

y1= self.y1 * display_to_tile_ratio.y - 1,

y2= self.y2 * display_to_tile_ratio.y + 1

}

local view_dims = dfhack.gui.getDwarfmodeViewDims()

local tile_view_size = xy2pos(view_dims.map_x2 - view_dims.map_x1 + 1, view_dims.map_y2 - view_dims.map_y1 + 1)

local display_view_size = xy2pos(df.global.init.display.grid_x, df.global.init.display.grid_y)

local display_to_tile_ratio = xy2pos(tile_view_size.x / display_view_size.x, tile_view_size.y / display_view_size.y)

return Rect{

x1= (self.x1 + 1) / display_to_tile_ratio.x,

x2= (self.x2 - 1) / display_to_tile_ratio.x,

y1= (self.y1 + 1) / display_to_tile_ratio.y,

y2= (self.y2 - 1) / display_to_tile_ratio.y

}

local cur_draw_queue = draw_queue

for _,screen_rect in pairs(screen_rect_list) do

local screen_tile_rect = screen_rect:screenToTile()

local new_draw_queue = {}

for _,draw_rect in pairs(cur_draw_queue) do

for _,clipped in pairs(draw_rect.rect:clip(screen_tile_rect)) do

table.insert(new_draw_queue, { pen= draw_rect.pen, rect= clipped })

end

end

cur_draw_queue = new_draw_queue

end

for _,draw_rect in pairs(cur_draw_queue) do

dfhack.screen.fillRect(draw_rect.pen, draw_rect.rect.x1, draw_rect.rect.y1, draw_rect.rect.x2, draw_rect.rect.y2, true)

end

self.valid = true

self.min = nil

self.max = nil

for _,value in pairs(points) do

if dfhack.maps.isValidTilePos(value) then

self.min = xyz2pos(

self.min and math.min(self.min.x, value.x) or value.x,

self.min and math.min(self.min.y, value.y) or value.y,

self.min and math.min(self.min.z, value.z) or value.z

)

self.max = xyz2pos(

self.max and math.max(self.max.x, value.x) or value.x,

self.max and math.max(self.max.y, value.y) or value.y,

self.max and math.max(self.max.z, value.z) or value.z

)

else

self.valid = false

break

end

end

self.valid = self.valid and self.min and self.max

and dfhack.maps.isValidTilePos(self.min.x, self.min.y, self.min.z)

and dfhack.maps.isValidTilePos(self.max.x, self.max.y, self.max.z)

if not self.valid then

self.min = xyz2pos(-1, -1, -1)

self.max = xyz2pos(-1, -1, -1)

end

if not self.valid then return end

for z = self.min.z, self.max.z do

for y = self.min.y, self.max.y do

for x = self.min.x, self.max.x do

callback(xyz2pos(x, y, z))

end

end

end

if not self.valid or df.global.window_z < self.min.z or df.global.window_z > self.max.z then return end

local screen_min = xy2pos(

self.min.x - df.global.window_x,

self.min.y - df.global.window_y

)

local screen_max = xy2pos(

self.max.x - df.global.window_x,

self.max.y - df.global.window_y

)

local draw_queue = {}

if self.min.x == self.max.x and self.min.y == self.max.y then

-- Single point

draw_queue = {

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=true, s=true, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_min.y }

}

}

elseif self.min.x == self.max.x then

-- Vertical line

draw_queue = {

-- Line

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=true, s=false, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_max.y }

},

-- Top nub

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=true, s=false, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_min.y }

},

-- Bottom nub

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=true, s=true, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_max.y, y2= screen_max.y }

}

}

elseif self.min.y == self.max.y then

-- Horizontal line

draw_queue = {

-- Line

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=false, s=true, w=false}],

rect= Rect{ x1= screen_min.x, x2= screen_max.x, y1= screen_min.y, y2= screen_min.y }

},

-- Left nub

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=false, s=true, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_min.y }

},

-- Right nub

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=true, s=true, w=false}],

rect= Rect{ x1= screen_max.x, x2= screen_max.x, y1= screen_min.y, y2= screen_min.y }

}

}

else

-- Rectangle

draw_queue = {

-- North Edge

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=false, s=false, w=false}],

rect= Rect{ x1= screen_min.x, x2= screen_max.x, y1= screen_min.y, y2= screen_min.y }

},

-- East Edge

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=true, s=false, w=false}],

rect= Rect{ x1= screen_max.x, x2= screen_max.x, y1= screen_min.y, y2= screen_max.y }

},

-- South Edge

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=false, s=true, w=false}],

rect= Rect{ x1= screen_min.x, x2= screen_max.x, y1= screen_max.y, y2= screen_max.y }

},

-- West Edge

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=false, s=false, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_max.y }

},

-- NW Corner

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=false, s=false, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_min.y, y2= screen_min.y }

},

-- NE Corner

{

pen= tile_map.pens[tile_map.getPenKey{n=true, e=true, s=false, w=false}],

rect= Rect{ x1= screen_max.x, x2= screen_max.x, y1= screen_min.y, y2= screen_min.y }

},

-- SE Corner

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=true, s=true, w=false}],

rect= Rect{ x1= screen_max.x, x2= screen_max.x, y1= screen_max.y, y2= screen_max.y }

},

-- SW Corner

{

pen= tile_map.pens[tile_map.getPenKey{n=false, e=false, s=true, w=true}],

rect= Rect{ x1= screen_min.x, x2= screen_min.x, y1= screen_max.y, y2= screen_max.y }

},

}

if dfhack.screen.inGraphicsMode() or ascii_fill then

-- Fill inside

table.insert(draw_queue, 1, {

pen= tile_map.pens[tile_map.getPenKey{n=false, e=false, s=false, w=false}],

rect= Rect{ x1= screen_min.x + 1, x2= screen_max.x - 1, y1= screen_min.y + 1, y2= screen_max.y - 1 }

})

end

end

if avoid_rect and not dfhack.screen.inGraphicsMode() then

-- If in ASCII and an avoid_rect was specified

-- Draw the queue, avoiding the avoid_rect

drawOutsideOfScreenRectList(draw_queue, { avoid_rect })

else

-- Draw the queue

for _,draw_rect in pairs(draw_queue) do

dfhack.screen.fillRect(draw_rect.pen, math.floor(draw_rect.rect.x1), math.floor(draw_rect.rect.y1), math.floor(draw_rect.rect.x2), math.floor(draw_rect.rect.y2), true)

end

end

local out = 0

for _,v in ipairs({nesw.n, nesw.e, nesw.s, nesw.w}) do

out = (out << 1) | (v and 1 or 0)

end

return out

end

return {

[TILE_MAP.getPenKey{ n=false, e=false, s=false, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 1, 2), fg=COLOR_GREEN, ch='X'}, -- INSIDE

[TILE_MAP.getPenKey{ n=true, e=false, s=false, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 0, 1), fg=COLOR_GREEN, ch='X'}, -- NW

[TILE_MAP.getPenKey{ n=true, e=false, s=false, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 1, 1), fg=COLOR_GREEN, ch='X'}, -- NORTH

[TILE_MAP.getPenKey{ n=true, e=true, s=false, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 2, 1), fg=COLOR_GREEN, ch='X'}, -- NE

[TILE_MAP.getPenKey{ n=false, e=false, s=false, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 0, 2), fg=COLOR_GREEN, ch='X'}, -- WEST

[TILE_MAP.getPenKey{ n=false, e=true, s=false, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 2, 2), fg=COLOR_GREEN, ch='X'}, -- EAST

[TILE_MAP.getPenKey{ n=false, e=false, s=true, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 0, 3), fg=COLOR_GREEN, ch='X'}, -- SW

[TILE_MAP.getPenKey{ n=false, e=false, s=true, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 1, 3), fg=COLOR_GREEN, ch='X'}, -- SOUTH

[TILE_MAP.getPenKey{ n=false, e=true, s=true, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 2, 3), fg=COLOR_GREEN, ch='X'}, -- SE

[TILE_MAP.getPenKey{ n=true, e=true, s=false, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 3, 2), fg=COLOR_GREEN, ch='X'}, -- N_NUB

[TILE_MAP.getPenKey{ n=true, e=true, s=true, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 5, 1), fg=COLOR_GREEN, ch='X'}, -- E_NUB

[TILE_MAP.getPenKey{ n=true, e=false, s=true, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 3, 1), fg=COLOR_GREEN, ch='X'}, -- W_NUB

[TILE_MAP.getPenKey{ n=false, e=true, s=true, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 4, 2), fg=COLOR_GREEN, ch='X'}, -- S_NUB

[TILE_MAP.getPenKey{ n=false, e=true, s=false, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 3, 3), fg=COLOR_GREEN, ch='X'}, -- VERT_NS

[TILE_MAP.getPenKey{ n=true, e=false, s=true, w=false }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 4, 1), fg=COLOR_GREEN, ch='X'}, -- VERT_EW

[TILE_MAP.getPenKey{ n=true, e=true, s=true, w=true }] = dfhack.pen.parse{tile=dfhack.screen.findGraphicsTile("CURSORS", 4, 3), fg=COLOR_GREEN, ch='X'}, -- POINT

}

self.frame = { w=0, h=0 }

self.box=nil

self.first_point=nil

self.last_point=nil

if self.tile_map then

if self.tile_map.createPens then

self.tile_map.pens = self.tile_map.createPens()

end

else

error("No tile map provided")

end

-- Set the cursor to the center of the screen

guidm.setCursorPos(guidm.Viewport.get():getCenter())

-- Show cursor

df.global.game.main_interface.main_designation_selected = df.main_designation_type.TOGGLE_ENGRAVING

if self.tooltip_enabled then

if self.screen then

self.dimensions_tooltip = widgets.DimensionsTooltip{

get_anchor_pos_fn=function()

if self.first_point and self.flat then

return xyz2pos(self.first_point.x, self.first_point.y, df.global.window_z)

end

return self.first_point

end,

}

self.screen:addviews{

self.dimensions_tooltip

}

else

error("No screen provided to BoxSelection, unable to display DimensionsTooltip")

end

end

if self.first_point and self.last_point

and dfhack.maps.isValidTilePos(self.first_point)

and dfhack.maps.isValidTilePos(self.last_point)

then

self.box = Box{

self.first_point,

self.last_point

}

if self.on_confirm then

self.on_confirm(self.box)

end

end

self.box = nil

self.first_point = nil

self.last_point = nil

if BoxSelection.super.onInput(self, keys) then

return true

end

if keys.LEAVESCREEN or keys._MOUSE_R then

if self.last_point then

self.box = nil

self.last_point = nil

return true