dfhack/plugins/lua/stockflow.lua

local _ENV = mkmodule('plugins.stockflow')

gui = require "gui"
utils = require "utils"

reaction_list = {}
saved_orders = {}
jobs_to_create = {}

triggers = {
    {filled = false, divisor = 1, name = "Per empty space"},
    {filled = true,  divisor = 1, name = "Per stored item"},
    {filled = false, divisor = 2, name = "Per two empty spaces"},
    {filled = true,  divisor = 2, name = "Per two stored items"},
    {filled = false, divisor = 3, name = "Per three empty spaces"},
    {filled = true,  divisor = 3, name = "Per three stored items"},
    {filled = false, divisor = 4, name = "Per four empty spaces"},
    {filled = true,  divisor = 4, name = "Per four stored items"},
    {name = "Never"},
}

-- Populate the reaction and stockpile order lists.
-- To be called whenever a world is loaded.
function initialize_world()
    reaction_list = collect_reactions()
    saved_orders = collect_orders()
    jobs_to_create = {}
end

-- Clear all caches.
-- Called when a world is loaded, or when the plugin is disabled.
function clear_caches()
    reaction_list = {}
    saved_orders = {}
    jobs_to_create = {}
end

function trigger_name(cache)
    local trigger = triggers[cache.entry.ints[3]]
    return trigger and trigger.name or "Never"
end

function list_orders()
    local listed = false
    for _, spec in pairs(saved_orders) do
        local num = spec.stockpile.stockpile_number
        local name = spec.entry.value
        local trigger = trigger_name(spec)
        print("Stockpile #"..num, name, trigger)
        listed = true
    end
    
    if not listed then
        print("No manager jobs have been set for your stockpiles.")
        print("Use j in a stockpile menu to create one...")
    end
end

-- Save the stockpile jobs for later creation.
-- Called when the bookkeeper starts updating stockpile records.
function start_bookkeeping()
    result = {}
    for reaction_id, quantity in pairs(check_stockpiles()) do
        local amount = order_quantity(reaction_list[reaction_id].order, quantity)
        if amount > 0 then
            result[reaction_id] = amount
        end
    end
    
    jobs_to_create = result
end

-- Insert any saved jobs.
-- Called when the bookkeeper finishes updating stockpile records.
function finish_bookkeeping()
    for reaction, amount in pairs(jobs_to_create) do
        create_orders(reaction_list[reaction].order, amount)
    end
    
    jobs_to_create = {}
end

function stockpile_settings(sp)
    local order = saved_orders[sp.id]
    if not order then
        return "No job selected", ""
    end
    
    return order.entry.value, trigger_name(order)
end

-- Toggle the trigger condition for a stockpile.
function toggle_trigger(sp)
    local saved = saved_orders[sp.id]
    if saved then
        saved.entry.ints[3] = (saved.entry.ints[3] % #triggers) + 1
        saved.entry:save()
    end
end

function collect_orders()
    local result = {}
    local entries = dfhack.persistent.get_all("stockflow/entry", true)
    if entries then
        local stockpiles = df.global.world.buildings.other.STOCKPILE
        for _, entry in ipairs(entries) do
            local spid = entry.ints[1]
            local stockpile = utils.binsearch(stockpiles, spid, "id")
            if stockpile then
                -- Todo: What if entry.value ~= reaction_list[order_number].name?
                result[spid] = {
                    stockpile = stockpile,
                    entry = entry,
                }
            end
        end
    end
    
    return result
end

-- Choose an order that the stockpile should add to the manager queue.
function select_order(stockpile)
    screen:reset(stockpile)
    screen:show()
end

function reaction_entry(job_type, values, name)
    local order = df.manager_order:new()
    -- These defaults differ from the newly created order's.
    order:assign{
        job_type = job_type,
        unk_2 = -1,
        item_subtype = -1,
        mat_type = -1,
        mat_index = -1,
    }
    
    if values then
        -- Override default attributes.
        order:assign(values)
    end
    
    return {
        name = name or df.job_type.attrs[job_type].caption,
        order = order,
    }
end

function resource_reactions(reactions, job_type, mat_info, keys, items, options)
    local values = {}
    for key, value in pairs(mat_info.management) do
        values[key] = value
    end
    
    for _, itemid in ipairs(keys) do
        local itemdef = items[itemid]
        local start = options.verb or mat_info.verb or "Make"
        if options.adjective then
            start = start.." "..itemdef.adjective
        end
        
        if (not options.permissible) or options.permissible(itemdef) then
            local item_name = " "..itemdef[options.name_field or "name"]
            if options.capitalize then
                item_name = string.gsub(item_name, " .", string.upper)
            end
            
            values.item_subtype = itemid
            table.insert(reactions, reaction_entry(job_type, values, start.." "..mat_info.adjective..item_name))
        end
    end
end

function material_reactions(reactions, itemtypes, mat_info)
    -- Expects a list of {job_type, verb, item_name} tuples.
    for _, row in ipairs(itemtypes) do
        local line = row[2].." "..mat_info.adjective
        if row[3] then
            line = line.." "..row[3]
        end
        
        table.insert(reactions, reaction_entry(row[1], mat_info.management, line))
    end
end

function clothing_reactions(reactions, mat_info, filter)
    local resources = df.global.world.entities.all[df.global.ui.civ_id].resources
    local itemdefs = df.global.world.raws.itemdefs
    resource_reactions(reactions, 101, mat_info, resources.armor_type,  itemdefs.armor,  {permissible = filter})
    resource_reactions(reactions, 103, mat_info, resources.pants_type,  itemdefs.pants,  {permissible = filter})
    resource_reactions(reactions, 117, mat_info, resources.gloves_type, itemdefs.gloves, {permissible = filter})
    resource_reactions(reactions, 102, mat_info, resources.helm_type,   itemdefs.helms,  {permissible = filter})
    resource_reactions(reactions, 118, mat_info, resources.shoes_type,  itemdefs.shoes,  {permissible = filter})
end

-- Find the reaction types that should be listed in the management interface.
function collect_reactions()
    -- The sequence here tries to match the native manager screen.
    -- It should also be possible to collect the sequence from somewhere native,
    -- but I currently can only find it while the job selection screen is active.
    -- Even that list doesn't seem to include their names.
    local result = {}
    
    local materials = {
        rock = {
            adjective = "rock",
            management = {mat_type = 0},
        },
    }
    
    for _, name in ipairs{"wood", "cloth", "leather", "silk", "yarn", "bone", "shell", "tooth", "horn", "pearl"} do
        materials[name] = {
            adjective = name,
            management = {material_category = {[name] = true}},
        }
    end
    
    materials.wood.adjective = "wooden"
    materials.tooth.adjective = "ivory/tooth"
    materials.leather.clothing_flag = "LEATHER"
    
    local jobs = {12, 22, 219, 31, 32}
    for _, job_id in ipairs(jobs) do
        table.insert(result, reaction_entry(job_id))
    end
    
    -- Cutting, encrusting, and metal extraction.
    local rock_types = df.global.world.raws.inorganics
    for rock_id = #rock_types-1, 0, -1 do
        local material = rock_types[rock_id].material
        local rock_name = material.state_adj.Solid
        if material.flags.IS_STONE or material.flags.IS_GEM then
            table.insert(result, reaction_entry(85, {mat_type = 0, mat_index = rock_id}, "Cut "..rock_name))
            
            table.insert(result, reaction_entry(87, {
                mat_type = 0,
                mat_index = rock_id,
                item_category = {finished_goods = true},
            }, "Encrust Finished Goods With "..rock_name))
            
            table.insert(result, reaction_entry(87, {
                mat_type = 0,
                mat_index = rock_id,
                item_category = {furniture = true},
            }, "Encrust Furniture With "..rock_name))
            
            table.insert(result, reaction_entry(87, {
                mat_type = 0,
                mat_index = rock_id,
                item_category = {ammo = true},
            }, "Encrust Ammo With "..rock_name))
        end
        
        if #rock_types[rock_id].metal_ore.mat_index > 0 then
            table.insert(result, reaction_entry(90, {mat_type = 0, mat_index = rock_id}, "Smelt "..rock_name.." Ore"))
        end
        
        if #rock_types[rock_id].thread_metal.mat_index > 0 then
            table.insert(result, reaction_entry(92, {mat_type = 0, mat_index = rock_id}))
        end
    end
    
    -- Glass cutting and encrusting, with different job numbers.
    -- We could search the entire table, but glass is less subject to raws.
    local glass_types = df.global.world.raws.mat_table.builtin
    local glasses = {}
    for glass_id = 3, 5 do
        local material = glass_types[glass_id]
        local glass_name = material.state_adj.Solid
        if material.flags.IS_GLASS then
            -- For future use.
            table.insert(glasses, {
                adjective = glass_name,
                management = {mat_type = glass_id},
            })
                
            table.insert(result, reaction_entry(86, {mat_type = glass_id}, "Cut "..glass_name))
            
            table.insert(result, reaction_entry(88, {
                mat_type = glass_id,
                item_category = {finished_goods = true},
            }, "Encrust Finished Goods With "..glass_name))
            
            table.insert(result, reaction_entry(88, {
                mat_type = glass_id,
                item_category = {furniture = true},
            }, "Encrust Furniture With "..glass_name))
            
            table.insert(result, reaction_entry(88, {
                mat_type = glass_id,
                item_category = {ammo = true},
            }, "Encrust Ammo With "..glass_name))
        end
    end
    
    -- Dyeing
    table.insert(result, reaction_entry(192))
    table.insert(result, reaction_entry(193))
    
    -- Sew Image
    cloth_mats = {materials.cloth, materials.silk, materials.yarn, materials.leather}
    for _, material in ipairs(cloth_mats) do
        material_reactions(result, {{194, "Sew", "Image"}}, material)
    end
    
    for _, spec in ipairs{materials.bone, materials.shell, materials.tooth, materials.horn, materials.pearl} do
        material_reactions(result, {{132, "Decorate With"}}, spec)
    end
    
    -- Make Totem
    table.insert(result, reaction_entry(130))
    -- Butcher an Animal
    table.insert(result, reaction_entry(105))
    -- Mill Plants
    table.insert(result, reaction_entry(107))
    -- Make Potash From Lye
    table.insert(result, reaction_entry(189))
    -- Make Potash From Ash
    table.insert(result, reaction_entry(191))
    
    -- Kitchen
    table.insert(result, reaction_entry(115, {mat_type = 2}, "Prepare Easy Meal"))
    table.insert(result, reaction_entry(115, {mat_type = 3}, "Prepare Fine Meal"))
    table.insert(result, reaction_entry(115, {mat_type = 4}, "Prepare Lavish Meal"))
    
    -- Brew Drink
    table.insert(result, reaction_entry(150))
    
    -- Weaving
    table.insert(result, reaction_entry(116, {material_category = {plant = true}}, "Weave Thread into Cloth"))
    table.insert(result, reaction_entry(116, {material_category = {silk = true}}, "Weave Thread into Silk"))
    table.insert(result, reaction_entry(116, {material_category = {yarn = true}}, "Weave Yarn into Cloth"))
    
    -- Extracts, farmer's workshop, and wood burning
    local jobs = {151, 152, 153, 106, 110, 109, 214, 215, 188, 111, 112, 113, 114, 186, 187}
    for _, job_id in ipairs(jobs) do
        table.insert(result, reaction_entry(job_id))
    end
    
    -- Reactions defined in the raws.
    -- Not all reactions are allowed to the civilization.
    -- That includes "Make sharp rock" by default.
    local entity = df.global.world.entities.all[df.global.ui.civ_id]
    for _, reaction_id in ipairs(entity.entity_raw.workshops.permitted_reaction_id) do
        local reaction = df.global.world.raws.reactions[reaction_id]
        local name = string.gsub(reaction.name, "^.", string.upper)
        table.insert(result, reaction_entry(211, {reaction_name = reaction.code}, name))
    end
    
    -- Metal forging
    local itemdefs = df.global.world.raws.itemdefs
    for rock_id = 0, #rock_types - 1 do
        local material = rock_types[rock_id].material
        local rock_name = material.state_adj.Solid
        local mat_flags = {
            adjective = rock_name,
            management = {mat_type = 0, mat_index = rock_id},
            verb = "Forge",
        }
        
        if material.flags.IS_METAL then
            table.insert(result, reaction_entry(104, mat_flags.management, "Stud With "..rock_name))
            
            if material.flags.ITEMS_WEAPON then
                -- Todo: Are these really the right flags to check?
                resource_reactions(result, 97, mat_flags, entity.resources.weapon_type, itemdefs.weapons, {
                    permissible = (function(itemdef) return itemdef.skill_ranged == -1 end),
                })
                
                -- Is this entirely disconnected from the entity?
                material_reactions(result, {{135, "Forge", "Ballista Arrow Head"}}, mat_flags)
                
                resource_reactions(result, 142, mat_flags, entity.resources.trapcomp_type, itemdefs.trapcomps, {
                    adjective = true,
                })
                
                resource_reactions(result, 136, mat_flags, entity.resources.siegeammo_type, itemdefs.siege_ammo, {
                    verb = "Assemble",
                })
            end
            
            if material.flags.ITEMS_WEAPON_RANGED then
                resource_reactions(result, 97, mat_flags, entity.resources.weapon_type, itemdefs.weapons, {
                    permissible = (function(itemdef) return itemdef.skill_ranged >= 0 end),
                })
            end
            
            if material.flags.ITEMS_DIGGER then
                -- Todo: Ranged or training digging weapons?
                resource_reactions(result, 97, mat_flags, entity.resources.digger_type, itemdefs.weapons, {
                })
            end
            
            if material.flags.ITEMS_AMMO then
                resource_reactions(result, 131, mat_flags, entity.resources.ammo_type, itemdefs.ammo, {
                    name_field = "name_plural",
                })
            end
            
            if material.flags.ITEMS_ANVIL then
                material_reactions(result, {{98, "Forge", "Anvil"}}, mat_flags)
            end
            
            if material.flags.ITEMS_ARMOR then
                local metalclothing = (function(itemdef) return itemdef.props.flags.METAL end)
                clothing_reactions(result, mat_flags, metalclothing)
                resource_reactions(result, 119, mat_flags, entity.resources.shield_type, itemdefs.shields, {
                })
            end
            
            if material.flags.ITEMS_SOFT then
                local metalclothing = (function(itemdef) return itemdef.props.flags.SOFT and not itemdef.props.flags.METAL end)
                clothing_reactions(result, mat_flags, metalclothing)
            end
            
            if material.flags.ITEMS_HARD then
                resource_reactions(result, 218, mat_flags, entity.resources.tool_type, itemdefs.tools, {
                    permissible = (function(itemdef) return itemdef.flags.HARD_MAT end),
                    capitalize = true,
                })
            end
            
            if material.flags.ITEMS_METAL then
                resource_reactions(result, 218, mat_flags, entity.resources.tool_type, itemdefs.tools, {
                    permissible = (function(itemdef) return itemdef.flags.METAL_MAT end),
                    capitalize = true,
                })
            end
            
            if material.flags.ITEMS_HARD then
                material_reactions(result, {
                    {69, "Construct", "Door"},
                    {70, "Construct", "Floodgate"},
                    {200, "Construct", "Hatch Cover"},
                    {201, "Construct", "Grate"},
                    {72, "Construct", "Throne"},
                    {73, "Construct", "Sarcophagus"},
                    {74, "Construct", "Table"},
                    {205, "Construct", "Splint"},
                    {206, "Construct", "Crutch"},
                    {77, "Construct", "Armor Stand"},
                    {78, "Construct", "Weapon Rack"},
                    {79, "Construct", "Cabinet"},
                    {123, "Forge", "Goblet"},
                    {124, "Forge", "Instrument"},
                    {125, "Forge", "Toy"},
                    {80, "Construct", "Statue"},
                    {81, "Construct", "Blocks"},
                    {126, "Forge", "Animal Trap"},
                    {127, "Forge", "Barrel"},
                    {128, "Forge", "Bucket"},
                    {76, "Construct", "Bin"},
                    {195, "Forge", "Pipe Section"},
                    {120, "Forge", "Cage"},
                    {84, "Mint", "Coins"},
                    {75, "Construct", "Chest"},
                    {122, "Forge", "Flask"},
                    {121, "Forge", "Chain"},
                    {83, "Make", "Crafts"},
                }, mat_flags)
            end
            
            if material.flags.ITEMS_SOFT then
                material_reactions(result, {
                    {133, "Make", "Backpack"},
                    {134, "Make", "Quiver"},
                    {99, "Construct", "Catapult Parts"},
                    {100, "Construct", "Ballista Parts"},
                }, mat_flags)
            end
        end
    end
    
    -- Traction Bench
    table.insert(result, reaction_entry(207))
    
    -- Non-metal weapons
    resource_reactions(result, 97, materials.wood, entity.resources.weapon_type, itemdefs.weapons, {
        permissible = (function(itemdef) return itemdef.skill_ranged >= 0 end),
    })
    
    resource_reactions(result, 97, materials.wood, entity.resources.training_weapon_type, itemdefs.weapons, {
    })
    
    resource_reactions(result, 97, materials.bone, entity.resources.weapon_type, itemdefs.weapons, {
        permissible = (function(itemdef) return itemdef.skill_ranged >= 0 end),
    })
    
    resource_reactions(result, 97, materials.rock, entity.resources.weapon_type, itemdefs.weapons, {
        permissible = (function(itemdef) return itemdef.flags.CAN_STONE end),
    })
    
    -- Wooden items
    -- Closely related to the ITEMS_HARD list.
    material_reactions(result, {
        {69, "Construct", "Door"},
        {70, "Construct", "Floodgate"},
        {200, "Construct", "Hatch Cover"},
        {201, "Construct", "Grate"},
        {72, "Construct", "Chair"},
        {73, "Construct", "Casket"},
        {74, "Construct", "Table"},
        {77, "Construct", "Armor Stand"},
        {78, "Construct", "Weapon Rack"},
        {79, "Construct", "Cabinet"},
        {123, "Make", "Cup"},
        {124, "Make", "Instrument"},
    }, materials.wood)
    
    resource_reactions(result, 218, materials.wood, entity.resources.tool_type, itemdefs.tools, {
        -- permissible = (function(itemdef) return itemdef.flags.WOOD_MAT end),
        capitalize = true,
    })
    
    material_reactions(result, {
        {125, "Make", "Toy"},
        {81, "Construct", "Blocks"},
        {205, "Construct", "Splint"},
        {206, "Construct", "Crutch"},
        {126, "Make", "Animal Trap"},
        {127, "Make", "Barrel"},
        {128, "Make", "Bucket"},
        {76, "Construct", "Bin"},
        {120, "Make", "Cage"},
        {195, "Make", "Pipe Section"},
    }, materials.wood)
    
    resource_reactions(result, 142, materials.wood, entity.resources.trapcomp_type, itemdefs.trapcomps, {
        permissible = (function(itemdef) return itemdef.flags.WOOD end),
        adjective = true,
    })
    
    -- Rock items
    material_reactions(result, {
        {69, "Construct", "Door"},
        {70, "Construct", "Floodgate"},
        {200, "Construct", "Hatch Cover"},
        {201, "Construct", "Grate"},
        {72, "Construct", "Throne"},
        {73, "Construct", "Coffin"},
        {74, "Construct", "Table"},
        {77, "Construct", "Armor Stand"},
        {78, "Construct", "Weapon Rack"},
        {79, "Construct", "Cabinet"},
        {123, "Make", "Mug"},
        {124, "Make", "Instrument"},
    }, materials.rock)
    
    resource_reactions(result, 218, materials.rock, entity.resources.tool_type, itemdefs.tools, {
        permissible = (function(itemdef) return itemdef.flags.HARD_MAT end),
        capitalize = true,
    })
    
    material_reactions(result, {
        {125, "Make", "Toy"},
        {203, "Construct", "Quern"},
        {204, "Construct", "Millstone"},
        {212, "Construct", "Slab"},
        {80, "Construct", "Statue"},
        {81, "Construct", "Blocks"},
    }, materials.rock)
    
    -- Glass items
    for _, mat_info in ipairs(glasses) do
        material_reactions(result, {
            {69, "Construct", "Portal"},
            {70, "Construct", "Floodgate"},
            {200, "Construct", "Hatch Cover"},
            {201, "Construct", "Grate"},
            {72, "Construct", "Throne"},
            {73, "Construct", "Coffin"},
            {74, "Construct", "Table"},
            {77, "Construct", "Armor Stand"},
            {78, "Construct", "Weapon Rack"},
            {79, "Construct", "Cabinet"},
            {123, "Make", "Goblet"},
            {124, "Make", "Instrument"},
        }, mat_info)
        
        resource_reactions(result, 218, mat_info, entity.resources.tool_type, itemdefs.tools, {
            permissible = (function(itemdef) return itemdef.flags.HARD_MAT end),
            capitalize = true,
        })
        
        material_reactions(result, {
            {125, "Make", "Toy"},
            {80, "Construct", "Statue"},
            {81, "Construct", "Blocks"},
            {120, "Make", "Terrarium"},
            {195, "Make", "Tube"},
        }, mat_info)
        
        resource_reactions(result, 142, mat_info, entity.resources.trapcomp_type, itemdefs.trapcomps, {
            adjective = true,
        })
    end
    
    -- Bed, specified as wooden.
    table.insert(result, reaction_entry(71, materials.wood.management))
    
    -- Windows
    for _, mat_info in ipairs(glasses) do
        material_reactions(result, {
            {129, "Make", "Window"},
        }, mat_info)
    end
    
    -- Rock Mechanisms
    table.insert(result, reaction_entry(141, materials.rock.management))
    
    resource_reactions(result, 136, materials.wood, entity.resources.siegeammo_type, itemdefs.siege_ammo, {
        verb = "Assemble",
    })
    
    for _, mat_info in ipairs(glasses) do
        material_reactions(result, {
            {82, "Make Raw", nil},
        }, mat_info)
    end
    
    material_reactions(result, {
        {133, "Make", "Backpack"},
        {134, "Make", "Quiver"},
    }, materials.leather)
    
    for _, material in ipairs(cloth_mats) do
        clothing_reactions(result, material, (function(itemdef) return itemdef.props.flags[material.clothing_flag or "SOFT"] end))
    end
    
    -- Boxes, Bags, and Ropes
    boxmats = {
        {mats = {materials.wood}, box = "Chest"},
        {mats = {materials.rock}, box = "Coffer"},
        {mats = glasses, box = "Box", flask = "Vial"},
        {mats = {materials.cloth}, box = "Bag", chain = "Rope"},
        {mats = {materials.leather}, box = "Bag", flask = "Waterskin"},
        {mats = {materials.silk, materials.yarn}, box = "Bag", chain = "Rope"},
    }
    for _, boxmat in ipairs(boxmats) do
        for _, mat in ipairs(boxmat.mats) do
            material_reactions(result, {{75, "Construct", boxmat.box}}, mat)
            if boxmat.chain then
                material_reactions(result, {{121, "Make", boxmat.chain}}, mat)
            end
            if boxmat.flask then
                material_reactions(result, {{122, "Make", boxmat.flask}}, mat)
            end
        end
    end
    
    for _, mat in ipairs{
        materials.wood,
        materials.rock,
        materials.cloth,
        materials.leather,
        materials.shell,
        materials.bone,
        materials.silk,
        materials.tooth,
        materials.horn,
        materials.pearl,
        materials.yarn,
    } do
        material_reactions(result, {{83, "Make", "Crafts"}}, mat)
    end
    
    -- Siege engine parts
    table.insert(result, reaction_entry(99, materials.wood.management))
    table.insert(result, reaction_entry(100, materials.wood.management))
    
    for _, mat in ipairs{materials.wood, materials.bone} do
        resource_reactions(result, 131, mat, entity.resources.ammo_type, itemdefs.ammo, {
            name_field = "name_plural",
        })
    end
    
    -- BARRED and SCALED as flag names don't quite seem to fit, here.
    clothing_reactions(result, materials.bone, (function(itemdef) return itemdef.props.flags[3] end))
    clothing_reactions(result, materials.shell, (function(itemdef) return itemdef.props.flags[4] end))
    
    for _, mat in ipairs{materials.wood, materials.leather} do
        resource_reactions(result, 119, mat, entity.resources.shield_type, itemdefs.shields, {})
    end
    
    -- Melt a Metal Object
    table.insert(result, reaction_entry(91))
    
    return result
end

screen = gui.FramedScreen {
    frame_title = "Select Stockpile Order",
}

PageSize = 16
function screen:onRenderBody(dc)
    -- Emulates the built-in manager screen.
    dc:seek(1, 1):string("Type in parts of the name to narrow your search.  ", COLOR_WHITE)
    dc:string(gui.getKeyDisplay("LEAVESCREEN"), COLOR_LIGHTGREEN)
    dc:string(" to abort.", COLOR_WHITE)
    dc:seek(1, PageSize + 5):string(self.search_string, COLOR_LIGHTCYAN)
    for _, item in ipairs(self.displayed) do
        dc:seek(item.x, item.y):string(item.name, item.color)
    end
end

function screen:onInput(keys)
    if keys.LEAVESCREEN then
        self:dismiss()
    elseif keys.SELECT then
        self:dismiss()
        local selected = self.reactions[self.position].index
        store_order(self.stockpile, selected)
    elseif keys.STANDARDSCROLL_UP then
        self.position = self.position - 1
    elseif keys.STANDARDSCROLL_DOWN then
        self.position = self.position + 1
    elseif keys.STANDARDSCROLL_LEFT then
        self.position = self.position - PageSize
    elseif keys.STANDARDSCROLL_RIGHT then
        self.position = self.position + PageSize
    elseif keys.STANDARDSCROLL_PAGEUP then
        -- Moves to the first item displayed on the new page, for some reason.
        self.position = self.position - PageSize*2 - ((self.position-1) % (PageSize*2))
    elseif keys.STANDARDSCROLL_PAGEDOWN then
        -- Moves to the first item displayed on the new page, for some reason.
        self.position = self.position + PageSize*2 - ((self.position-1) % (PageSize*2))
    elseif keys.STRING_A000 then
        -- This seems like an odd way to check for Backspace.
        self.search_string = string.sub(self.search_string, 1, -2)
    elseif keys._STRING and keys._STRING >= 32 then
        -- This interface only accepts letters and spaces.
        local char = string.char(keys._STRING)
        if char == " " or string.find(char, "^%a") then
            self.search_string = self.search_string .. string.upper(char)
        end
    end
    
    self:refilter()
end

function screen:reset(stockpile)
    self.stockpile = stockpile
    self.search_string = ""
    self.position = 1
    self:refilter()
end

function matchall(haystack, needles)
    for _, needle in ipairs(needles) do
        if not string.find(haystack, needle) then
            return false
        end
    end
    
    return true
end

function splitstring(full, pattern)
    local last = string.len(full)
    local result = {}
    local n = 1
    while n <= last do
        local start, stop = string.find(full, pattern, n)
        if not start then
            result[#result+1] = string.sub(full, n)
            break
        elseif start > n then
            result[#result+1] = string.sub(full, n, start - 1)
        end
        
        if stop < n then
            -- The pattern matches an empty string.
            -- Avoid an infinite loop.
            break
        end
        
        n = stop + 1
    end
    
    return result
end

function screen:refilter()
    local filtered = {}
    local needles = splitstring(self.search_string, " ")
    for key, value in ipairs(reaction_list) do
        if matchall(string.upper(value.name), needles) then
            filtered[#filtered+1] = {
                index = key,
                name = value.name
            }
        end
    end
    
    if self.position < 1 then
        self.position = #filtered
    elseif self.position > #filtered then
        self.position = 1
    end
    
    local start = 1
    while self.position >= start + PageSize*2 do
        start = start + PageSize*2
    end
    
    local displayed = {}
    for n = 0, PageSize*2 - 1 do
        local item = filtered[start + n]
        if not item then
            break
        end
        
        local x = 1
        local y = 4 + n
        if n >= PageSize then
            x = 39
            y = y - PageSize
        end
        
        local color = COLOR_CYAN
        if start + n == self.position then
            color = COLOR_LIGHTCYAN
        end
        
        displayed[n + 1] = {
            x = x,
            y = y,
            name = item.name,
            color = color,
        }
    end
    
    self.reactions = filtered
    self.displayed = displayed
end

function store_order(stockpile, order_number)
    local name = reaction_list[order_number].name
    -- print("Setting stockpile #"..stockpile.stockpile_number.." to "..name.." (#"..order_number..")")
    local saved = saved_orders[stockpile.id]
    if saved then
        saved.entry.value = name
        saved.entry.ints[2] = order_number
        saved.entry:save()
    else
        saved_orders[stockpile.id] = {
            stockpile = stockpile,
            entry = dfhack.persistent.save{
                key = "stockflow/entry/"..stockpile.id,
                value = name,
                ints = {
                    stockpile.id,
                    order_number,
                    1,
                },
            },
        }
    end
end

-- Compare the job specification of two orders.
function orders_match(a, b)
    local fields = {
        "job_type",
        "item_subtype",
        "reaction_name",
        "mat_type",
        "mat_index",
    }
    
    for _, fieldname in ipairs(fields) do
        if a[fieldname] ~= b[fieldname] then
            return false
        end
    end
    
    local subtables = {
        "item_category",
        "material_category",
    }
    
    for _, fieldname in ipairs(subtables) do
        local aa = a[fieldname]
        local bb = b[fieldname]
        for key, value in ipairs(aa) do
            if bb[key] ~= value then
                return false
            end
        end
    end
    
    return true
end

-- Reduce the quantity by the number of matching orders in the queue.
function order_quantity(order, quantity)
    local amount = quantity
    for _, managed in ipairs(df.global.world.manager_orders) do
        if orders_match(order, managed) then
            amount = amount - managed.amount_left
            if amount < 0 then
                return 0
            end
        end
    end
    
    if amount > 30 then
        -- Respect the quantity limit.
        -- With this many in the queue, we can wait for the next cycle.
        return 30
    end
    
    return amount
end

-- Place a new copy of the order onto the manager's queue.
function create_orders(order, amount)
    local new_order = order:new()
    new_order.amount_left = amount
    new_order.amount_total = amount
    -- Todo: Create in a validated state if the fortress is small enough?
    new_order.is_validated = 0
    df.global.world.manager_orders:insert('#', new_order)
end

function findItemsAtTile(x, y, z)
    -- There should be a faster and easier way to do this...
    local found = {}
    for _, item in ipairs(df.global.world.items.all) do
        -- local ix, iy, iz = dfhack.items.getPosition(item)
        if item.pos.x == x and item.pos.y == y and
            item.pos.z == z and item.flags.on_ground then
            found[#found+1] = item
        end
    end
    
    return found
end

function countContents(container, settings)
    local total = 0
    local blocking = false
    for _, item in ipairs(dfhack.items.getContainedItems(container)) do
        if item.flags.container then
            -- Recursively count the total of items contained.
            -- Not likely to go more than two levels deep.
            local subtotal, subblocked = countContents(item, settings)
            if subtotal > 0 then
                -- Ignore the inner container itself;
                -- generally, only the contained items matter.
                total = total + subtotal
            elseif subblocked then
                blocking = true
            elseif matches_stockpile(item, settings) then
                -- The container may or may not be empty,
                -- but is stockpiled as a container itself.
                total = total + 1
            else
                blocking = true
            end
        elseif matches_stockpile(item, settings) then
            total = total + 1
        else
            blocking = true
        end
    end
    
    return total, blocking
end

function check_stockpiles(verbose)
    local result = {}
    for _, spec in pairs(saved_orders) do
        local trigger = triggers[spec.entry.ints[3]]
        if trigger and trigger.divisor then
            local reaction = spec.entry.ints[2]
            local filled, empty = check_pile(spec.stockpile, verbose)
            local amount = trigger.filled and filled or empty
            amount = (amount - (amount % trigger.divisor)) / trigger.divisor
            result[reaction] = (result[reaction] or 0) + amount
        end
    end
    
    return result
end

function check_pile(sp, verbose)
    local numspaces = 0
    local filled = 0
    local empty = 0
    for y = sp.y1, sp.y2 do
        for x = sp.x1, sp.x2 do
            -- Sadly, the obvious check currently fails when y == sp.y2
            if dfhack.buildings.containsTile(sp, x, y) or
                (y == sp.y2 and dfhack.buildings.findAtTile(x, y, sp.z) == sp) then
                numspaces = numspaces + 1
                local designation, occupancy = dfhack.maps.getTileFlags(x, y, sp.z)
                if not designation.liquid_type then
                    if not occupancy.item then
                        empty = empty + 1
                    else
                        local item_count, blocked = count_pile_items(sp, x, y)
                        if item_count > 0 then
                            filled = filled + item_count
                        elseif not blocked then
                            empty = empty + 1
                        end
                    end
                end
            end
        end
    end
    
    if verbose then
        print("Stockpile #"..sp.stockpile_number,
            string.format("%3d spaces", numspaces),
            string.format("%4d items", filled),
            string.format("%4d empty spaces", empty))
    end
    
    return filled, empty
end

function count_pile_items(sp, x, y)
    local item_count = 0
    local blocked = false
    for _, item in ipairs(findItemsAtTile(x, y, sp.z)) do
        if item:isAssignedToThisStockpile(sp.id) then
            -- This is a bin or barrel associated with the stockpile.
            -- If it's empty, it doesn't count as blocking the stockpile space.
            -- Oddly, when empty, item.flags.container might be false.
            local subtotal, subblocked = countContents(item, sp.settings)
            item_count = item_count + subtotal
            if subblocked then
                blocked = true
            end
        elseif matches_stockpile(item, sp.settings) then
            item_count = item_count + 1
        else
            blocked = true
        end
    end
    
    return item_count, blocked
end

function matches_stockpile(item, settings)
    -- Check whether the item matches the stockpile.
    -- FIXME: This is starting to look like a whole lot of work.
    if df.item_barst:is_instance(item) then
        return settings.flags.bars_blocks
    elseif df.item_blocksst:is_instance(item) then
        return settings.flags.bars_blocks
    elseif df.item_smallgemst:is_instance(item) then
        return settings.flags.gems
    elseif df.item_boulderst:is_instance(item) then
        return settings.flags.stone
    elseif df.item_woodst:is_instance(item) then
        return settings.flags.wood
    elseif df.item_seedsst:is_instance(item) then
        return settings.flags.food
    elseif df.item_meatst:is_instance(item) then
        return settings.flags.food
    elseif df.item_plantst:is_instance(item) then
        return settings.flags.food
    elseif df.item_leavesst:is_instance(item) then
        return settings.flags.food
    elseif df.item_cheesest:is_instance(item) then
        return settings.flags.food
    elseif df.item_globst:is_instance(item) then
        return settings.flags.food
    elseif df.item_fishst:is_instance(item) then
        return settings.flags.food
    elseif df.item_fish_rawst:is_instance(item) then
        return settings.flags.food
    elseif df.item_foodst:is_instance(item) then
        return settings.flags.food
    elseif df.item_drinkst:is_instance(item) then
        return settings.flags.food
    elseif df.item_eggst:is_instance(item) then
        return settings.flags.food
    elseif df.item_skin_tannedst:is_instance(item) then
        return settings.flags.leather
    elseif df.item_remainsst:is_instance(item) then
        return settings.flags.refuse
    elseif df.item_verminst:is_instance(item) then
        return settings.flags.animals
    elseif df.item_petst:is_instance(item) then
        return settings.flags.animals
    elseif df.item_threadst:is_instance(item) then
        return settings.flags.cloth
    end
    
    return true
end

return _ENV