Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Meph]

I know, but that still does not limit the reaction. I meant it for item production, for example only your legendary weaponsmith can do a specific reaction for a special weapon, or your legendary alchemist can create a build-mat that you need for a new magical building.

That would make balancing techtrees and a slow, steady advancement a lot easier to write.

[Maklak]

OK, I see your point now. The closest thing I can imagine is periodically iterating over all active jobs and ejecting the Dwarves who aren't qualified, but it wouldn't be fully foolproof.

[Kurik Amudnil]

A script/plugin to prevent dwarfs from choosing food/drink for eat/drink jobs from inappropriate sources.
may need to mark which food/drink stockpiles as being an appropriate source for eat/drink jobs.
may need to select an item from the appropriate source (search stockpile for first available food/drink item inside/outside container?).
may need to account for when appropriate sources are empty, or not so that new food/drink has a chance to get transported to the stockpile.
may need to make decisions on proximity to dinning area (more than one food pantry? if so, closest to the intended dinning area? closest to the dwarf?)
should allow dwarfs to keep food they are already carrying/eating/drinking

Why?  so that dwarfs will use the food stockpiles next to the dinning room rather than the food waiting for transport by minecart, or food waiting to be cooked at the kitchen, and use designated drink stockpiles rather than newly brewed drink at the still

[sweitx]

Several burrow related suggestions.
1. Dwarf Manipulator style interface for burrow assignment
Basically, use the interface we have for Dwarf Manipulator. But instead of having labors have columns, have burrows.
Obviously, we're going to have issue with that burrows can have arbitrary names and it will be difficult to fit into a single character (unlike labor, which can fit into single character column by having 2 letters representing the labors).
A solution would be to use the burrow symbol as column headers, and display the name of the highlighted burrow (like how Dwarf Manipulator displays the full name of the labor when the column is highlighted).

2. Extension to above, profession based auto-burrowing.
Allow automatically assign burrow based on activated labor.
For example, if a dwarf has the "weaver" labor active, he/she is automatically assigned to the weaver burrow (to prevent him/her from grabbing spider web from unsecured regions in the cavern).

Current DFHack capability to search for dwarf in the burrowing window is very helpful already. But I believe that my first suggestion would be helpful in giving an "at-a-glance" status on your fortress' burrow statuses. Also, since currently you cannot check which burrows a single dwarf belongs to by just looking ('v') at a dwarf, the above suggestion would be helpful at "debugging" burrow assignment.

[PeridexisErrant]

Ideas for UI plugins, roughly in ascending order of difficulty. 

1. DFHack GUI:  keybinding for a popup where commands can be typed, instead of finding another window.  Good for immersion, and makes fullscreen less of a pain.  Maybe Ctrl-Alt-H to open, and close with Esc?

2. Automate tree farming, by setting an area to re-designate tree cutting (or plant gathering) once per month.  Using a zone somehow would be cool, but burrows might be easier - for example:  at the start of each month, apply cut-trees designation to any burrow with 'TREE-CUT' in the name, and apply plant gathering designation to any with 'PLANT-GATHER' in the name.   I'm not sure how it might work with zones, but I'll leave it here anyway. 

3. Clickable menu options.  Falconne's mousequery plugin apparently makes playing on a windows 8 touchscreen possible, and this would make it even cooler.  Besides a step toward a mobile edition, it could also be pretty helpful for getting people into the game when the key mapping is most intimidating. 

[expwnent]

2. Automate tree farming, by setting an area to re-designate tree cutting (or plant gathering) once per month.  Using a zone somehow would be cool, but burrows might be easier - for example:  at the start of each month, apply cut-trees designation to any burrow with 'TREE-CUT' in the name, and apply plant gathering designation to any with 'PLANT-GATHER' in the name.   I'm not sure how it might work with zones, but I'll leave it here anyway. 

Would be relatively simple, actually. I'll add that to my to do list. The same interface would work for autodigging obsidian farms. Unless burrows automatically remove new obsidianized walls, which I don't think they do.

[PeridexisErrant]

2. Automate tree farming

I'll add that to my to do list.

Awesome! 


Another suggestion, which I forgot to put in the other post: export-all from legends mode. 
I'd think that this shouldn't be too tricky to implement and it's been on feature request lists for years, but seems low-priority for Toady since it's basically a UI issue and mostly useful for legends or mapping utilities. 

[Kurik Amudnil]

2. Automate tree farming

I'll add that to my to do list.

Awesome! 


Another suggestion, which I forgot to put in the other post: export-all from legends mode. 
I'd think that this shouldn't be too tricky to implement and it's been on feature request lists for years, but seems low-priority for Toady since it's basically a UI issue and mostly useful for legends or mapping utilities.

I was recently thinking about how I would go about doing an export of all maps.  My thoughts on how to do it went something like this:

psudeo lua code

I don't know if lua can send key presses to a df viewscreen or be able to successfully wait for dwarf fortress to do its stuff.

*edit: inspired to work on this some more and found that yes I can send key events .. took some time to find the right ones.  Now I am having trouble figuring out how to let the game process while waiting for the new viewscreen to popup

*edit2: Ok, I think I have this working now.  I think it has some room for improvement (such as not exporting all, but a subset, or cancel after starting, or not starting if already in progress) but it seems to do the job for me.  Place in hack/scripts/exportmaps.lua

Code: ( "hack/scripts/exportmaps.lua") [Select]

-- Export all detail maps from legends
gui = require 'gui'

local vs = dfhack.gui.getCurViewscreen()
local i = 0

local MAPS = {
[0] = "Standard biom+site map",
"Elevations including lake and ocean floors",
"Elevations respecting water level",
"Biome",
"Hydrosphere",
"Temperature",
"Rainfall",
"Drainage",
"Savagery",
"Volcanism",
"Current vegitation",
"Evil",
"Salinity",
"Structures/fields/roads/etc.",
"Trade",
}
function wait_for_legends_vs()
vs = dfhack.gui.getCurViewscreen()
if i < 15 then
if df.viewscreen_legendsst:is_instance(vs) then
gui.simulateInput(vs, 'LEGENDS_EXPORT_DETAILED_MAP') -- "d" on screen some number internally
dfhack.timeout(10,'frames',wait_for_export_maps_vs)
else
dfhack.timeout(10,'frames',wait_for_legends_vs)
end
end
end
function wait_for_export_maps_vs()
vs = dfhack.gui.getCurViewscreen()
if df.viewscreen_export_graphical_mapst:is_instance(vs) then
vs.anon_13 = i -- anon_13 appears to be the selection cursor for this viewscreen
print('Exporting:  '..MAPS[i])
i = i + 1
gui.simulateInput(vs, 'SELECT') -- 1 internally, enter on screen
dfhack.timeout(10,'frames',wait_for_legends_vs)
else
dfhack.timeout(10,'frames',wait_for_export_maps_vs)
end
end

if df.viewscreen_legendsst:is_instance( vs ) then -- dfhack.gui.getCurFocus() == "legends"
wait_for_legends_vs()
elseif df.viewscreen_export_graphical_mapst:is_instance(vs) then
wait_for_export_maps_vs()
else
dfhack.printerr('Not in legends view')
end

to run:
[DFHack]# exportmaps
then go grab a sandwich or two

* uploaded to DFFD http://dffd.wimbli.com/file.php?id=7696

[expwnent]

Semicheating mod: get rid of machine delays. Pressure plates reset instantly, bridges activate instantly, etc. I'm not quite sure what I want, but the most I'd do is make everything instantaneous. This would allow for repeaters up to 50 times faster (assuming you can design one), faster dwarfputing, more reliable pressure plate detection of units / flow, etc. Thoughts?

[PeridexisErrant]

[DFHack]# exportmaps

Legendary.  (he he he)

Edit: tested it, and it works beautifully.  Thanks!

[scamtank]

I'd still give my left kidney for the ability to alter/replace vanilla reactions.

[expwnent]

I'd still give my left kidney for the ability to alter/replace vanilla reactions.

I think warmist had something kind of like that. It was related to adventure fort. Could be remembering wrong.

[Kurik Amudnil]

I'd still give my left kidney for the ability to alter/replace vanilla reactions.

I don't know if it is applicable here, but according to the dfhack lua api

2. removeNative(shop_name)

    Removes native choice list from the building.

  3. addReactionToShop(reaction_name,shop_name)

    Add a custom reaction to the building.

In any case, I doubt it removes a moods choice of output

[drayath]

Allow a stockpile to automatically dump any items added to it.
Can then use various stockpile filters to select garbage items, and them automatically dumped to a garbage disposal system.

Working proof of concept below. Modified version of autotrade plugin.
Have some concern about performance with large forts with lots of items (checks items each 500 ticks)
Idealy: Monitor completed jobs, if a haul job to a tagged stockpile then mark the item to dump. Then remove the ontimer code.
Note: Enabling dump on a stockpile will immediatly mark all items, disabling autodump ona stockpile will remove the dump flag from items unless a dwarf is already on the way to dump them.

Download: www.brightsoft.net/autostockdump.plug.zip

Spoiler (click to show/hide)

Code: [Select]

#include "uicommon.h"

#include "modules/Gui.h"

#include "df/world.h"
#include "df/world_raws.h"
#include "df/building_def.h"
#include "df/viewscreen_dwarfmodest.h"
#include "df/building_stockpilest.h"
#include "modules/Items.h"
#include "df/building_tradedepotst.h"
#include "df/general_ref_building_holderst.h"
#include "df/job.h"
#include "df/job_item_ref.h"
#include "modules/Job.h"
#include "df/ui.h"
#include "df/caravan_state.h"
#include "df/mandate.h"
#include "modules/Maps.h"
#include "modules/World.h"

using df::global::world;
using df::global::cursor;
using df::global::ui;
using df::building_stockpilest;

DFHACK_PLUGIN("autostockdump");
#define PLUGIN_VERSION 0.1


/*
 * Stockpile Access
 */

static building_stockpilest *get_selected_stockpile()
{
    if (!Gui::dwarfmode_hotkey(Core::getTopViewscreen()) ||
        ui->main.mode != ui_sidebar_mode::QueryBuilding)
    {
        return nullptr;
    }

    return virtual_cast<building_stockpilest>(world->selected_building);
}

class StockpileInfo {
public:

    StockpileInfo(df::building_stockpilest *sp_) : sp(sp_)
    {
        readBuilding();
    }

    StockpileInfo(PersistentDataItem &config)
    {
        this->config = config;
        id = config.ival(1);
    }

    bool inStockpile(df::item *i)
    {
        df::item *container = Items::getContainer(i);
        if (container)
            return inStockpile(container);

        if (i->pos.z != z) return false;
        if (i->pos.x < x1 || i->pos.x >= x2 ||
            i->pos.y < y1 || i->pos.y >= y2) return false;
        int e = (i->pos.x - x1) + (i->pos.y - y1) * sp->room.width;
        return sp->room.extents[e] == 1;
    }

    bool isValid()
    {
        auto found = df::building::find(id);
        return found && found == sp && found->getType() == building_type::Stockpile;
    }

    bool load()
    {
        auto found = df::building::find(id);
        if (!found || found->getType() != building_type::Stockpile)
            return false;

        sp = virtual_cast<df::building_stockpilest>(found);
        if (!sp)
            return false;

        readBuilding();

        return true;
    }

    int32_t getId()
    {
        return id;
    }

    bool matches(df::building_stockpilest* sp)
    {
        return this->sp == sp;
    }

    void save()
    {
        config = DFHack::World::AddPersistentData("autostockdump/stockpiles");
        config.ival(1) = id;
    }

    void remove()
    {
        DFHack::World::DeletePersistentData(config);
    }

private:
    PersistentDataItem config;
    df::building_stockpilest* sp;
    int x1, x2, y1, y2, z;
    int32_t id;

    void readBuilding()
    {
        id = sp->id;
        z = sp->z;
        x1 = sp->room.x;
        x2 = sp->room.x + sp->room.width;
        y1 = sp->room.y;
        y2 = sp->room.y + sp->room.height;
    }
};





/*
 * Item Manipulation
 */


static bool is_valid_item(df::item *item)
{
    for (size_t i = 0; i < item->general_refs.size(); i++)
    {
        df::general_ref *ref = item->general_refs[i];

        switch (ref->getType())
        {
        case general_ref_type::CONTAINED_IN_ITEM:
            return false;

        case general_ref_type::UNIT_HOLDER:
            return false;

        case general_ref_type::BUILDING_HOLDER:
            return false;

        default:
            break;
        }
    }

    for (size_t i = 0; i < item->specific_refs.size(); i++)
    {
        df::specific_ref *ref = item->specific_refs[i];

        if (ref->type == specific_ref_type::JOB)
        {
            // Ignore any items assigned to a job
            return false;
        }
    }

    return true;
}

static void mark_all_in_stockpiles(vector<StockpileInfo> &stockpiles, bool dump)
{
    std::vector<df::item*> &items = world->items.other[items_other_id::IN_PLAY];

    // Precompute a bitmask with the bad flags
    df::item_flags bad_flags;
    bad_flags.whole = 0;

#define F(x) bad_flags.bits.x = true;
bad_flags.bits.dump = dump;
    F(forbid); F(garbage_collect);
    F(hostile); F(on_fire); F(trader);
    F(in_building); F(construction); F(artifact);
    F(owned); F(in_job);
#undef F

    size_t marked_count = 0;
    size_t error_count = 0;
    for (size_t i = 0; i < items.size(); i++)
    {
        df::item *item = items[i];
        if (item->flags.whole & bad_flags.whole)
            continue;

        if (!is_valid_item(item))
            continue;

        for (auto it = stockpiles.begin(); it != stockpiles.end(); it++)
        {
            if (!it->inStockpile(item))
                continue;

            item->flags.bits.dump = dump;
        }
    }
}


/*
 * Stockpile Monitoring
 */

class StockpileMonitor
{
public:
    bool isMonitored(df::building_stockpilest *sp)
    {
        for (auto it = monitored_stockpiles.begin(); it != monitored_stockpiles.end(); it++)
        {
            if (it->matches(sp))
                return true;
        }

        return false;
    }

    void add(df::building_stockpilest *sp)
    {
        auto pile = StockpileInfo(sp);
        if (pile.isValid())
        {
            monitored_stockpiles.push_back(StockpileInfo(sp));
            monitored_stockpiles.back().save();
        }
    }

    void remove(df::building_stockpilest *sp)
    {
        for (auto it = monitored_stockpiles.begin(); it != monitored_stockpiles.end(); it++)
        {
            if (it->matches(sp))
            {
                it->remove();
                monitored_stockpiles.erase(it);
                break;
            }
        }
    }

    void doCycle()
    {
        for (auto it = monitored_stockpiles.begin(); it != monitored_stockpiles.end();)
        {
            if (!it->isValid())
            {
                it = monitored_stockpiles.erase(it);
                continue;
            }

            ++it;
        }

        mark_all_in_stockpiles(monitored_stockpiles, true);
    }

    void reset()
    {
        monitored_stockpiles.clear();
        std::vector<PersistentDataItem> items;
        DFHack::World::GetPersistentData(&items, "autostockdump/stockpiles");

        for (auto i = items.begin(); i != items.end(); i++)
        {
            auto pile = StockpileInfo(*i);
            if (pile.load())
                monitored_stockpiles.push_back(StockpileInfo(pile));
            else
                pile.remove();
        }
    }


private:
    vector<StockpileInfo> monitored_stockpiles;
};

static StockpileMonitor monitor;

#define DELTA_TICKS 600

DFhackCExport command_result plugin_onupdate ( color_ostream &out )
{
    if(!Maps::IsValid())
        return CR_OK;

    static decltype(world->frame_counter) last_frame_count = 0;

    if (DFHack::World::ReadPauseState())
        return CR_OK;

    if (world->frame_counter - last_frame_count < DELTA_TICKS)
        return CR_OK;

    last_frame_count = world->frame_counter;

    monitor.doCycle();

    return CR_OK;
}


/*
 * Interface
 */

struct trade_hook : public df::viewscreen_dwarfmodest
{
    typedef df::viewscreen_dwarfmodest interpose_base;

    bool handleInput(set<df::interface_key> *input)
    {
        building_stockpilest *sp = get_selected_stockpile();
        if (!sp)
            return false;

        if (input->count(interface_key::CUSTOM_K))
        {
            if (monitor.isMonitored(sp))
{
                monitor.remove(sp);
vector<StockpileInfo> wrapper;
wrapper.push_back(StockpileInfo(sp));
mark_all_in_stockpiles(wrapper, false);
}
            else
{
                monitor.add(sp);
vector<StockpileInfo> wrapper;
wrapper.push_back(StockpileInfo(sp));
mark_all_in_stockpiles(wrapper, true);
}
        }

        return false;
    }

    DEFINE_VMETHOD_INTERPOSE(void, feed, (set<df::interface_key> *input))
    {
        if (!handleInput(input))
            INTERPOSE_NEXT(feed)(input);
    }

    DEFINE_VMETHOD_INTERPOSE(void, render, ())
    {
        INTERPOSE_NEXT(render)();

        building_stockpilest *sp = get_selected_stockpile();
        if (!sp)
            return;

        auto dims = Gui::getDwarfmodeViewDims();
        int left_margin = dims.menu_x1 + 1;
        int x = left_margin;
        int y = 25;

        OutputToggleString(x, y, "Auto dump", "k", monitor.isMonitored(sp), true, left_margin);
    }
};

IMPLEMENT_VMETHOD_INTERPOSE(trade_hook, feed);
IMPLEMENT_VMETHOD_INTERPOSE(trade_hook, render);

static command_result autotrade_cmd(color_ostream &out, vector <string> & parameters)
{
    if (!parameters.empty())
    {
        if (parameters.size() == 1 && toLower(parameters[0])[0] == 'v')
        {
            out << "Auto Stockpile Dump" << endl << "Version: " << PLUGIN_VERSION << endl;
        }
    }

    return CR_OK;
}


DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
{
    switch (event)
    {
    case DFHack::SC_MAP_LOADED:
        monitor.reset();
        break;
    case DFHack::SC_MAP_UNLOADED:
        break;
    default:
        break;
    }
    return CR_OK;
}

DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
{
    if (!gps || !INTERPOSE_HOOK(trade_hook, feed).apply() || !INTERPOSE_HOOK(trade_hook, render).apply())
        out.printerr("Could not insert autostockdump hooks!\n");

    commands.push_back(
        PluginCommand(
        "autostockdump", "Automatically dump items in marked stockpiles.",
        autotrade_cmd, false, ""));

    return CR_OK;
}

DFhackCExport command_result plugin_shutdown ( color_ostream &out )
{
    return CR_OK;
}



[Brilliand]

Portal buildings. Enter building #1, worker is teleported to building #2
- Possible: YES
 - Quickly travel across the map.
 - Reinforcements for deep layers, like the circus.
 - More tactics, ambush invasions yourself.
 - Enter otherwise walled-off areas, without opening doors for enemies.

This one was intended for military purposes, I think adding it to the pathfinding of the game, so that haulers would use it, is way to tricky. I was mostly thinking of these deep curious underground structures, with the squads barely making it to the lower levels before turning around for a drink/meal. Or fighting in the third cavern/circus.

The portals would probably be more useful (particularly for sending out the military) if they teleported all dwarves in the vicinity (probably within 3 tiles, since that's the precision of a move order).  Or rather, teleport all units within the building, and leave it to the modders to make their military teleporters 7x7.

Also, for multiple buildings: It should be possible to ignore forbidden buildings when choosing a destination portal - that would make having more than 2 portals workable (just forbid any portals you're not using at the moment).