Print

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

[Bumber]

GitHub did drop password-based auth over HTTPS within the past year (you have to use a token or an alternative to push now) - I'm assuming that's what Bumber is referring to. They also dropped the git:// protocol more recently.

I definitely want to keep HTTPS as the default in Compile.rst for the reasons Myk said - for read-only access, it is the simplest and does not require extra setup steps. If you'd like to update Contributing.rst with instructions on switching to SSH (maybe references to existing GitHub docs?), that would be welcomed.

Looks like the easiest way is just to create a PAT and use that instead of your password when pushing:
https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

This doesn't require switching from https.

The relevant documents for SSH are:
https://docs.github.com/en/get-started/getting-started-with-git/managing-remote-repositories
https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent

Those show how to use set-url to switch the remote to SSH, generate the key, and use ssh-agent to tie your key to a passphrase.

[myk]

DFHack 0.47.05-r5 released!

This release brings improvements to autofarm, quickfort, autochop, autonick, blueprint, and others. There are also many new widgets available for Lua GUI script writers.

Modders! This release includes custom-raw-tokens: a brand new library for reading mod-added tags in the raws. This allows you to write scripts that modify the game when tagged items are used.

Binaries available on the release page

Changelog:

Spoiler (click to show/hide)

DFHack 0.47.05-r5
=================

New Plugins
-----------
- `spectate`: "spectator mode" -- automatically follows dwarves doing things in your fort

New Scripts
-----------
- `devel/eventful-client`: useful for testing eventful events

New Tweaks
----------
- `tweak`: ``partial-items`` displays percentage remaining for partially-consumed items such as hospital cloth

Fixes
-----
- `autofarm`: removed restriction on only planting "discovered" plants
- `cxxrandom`: fixed exception when calling ``bool_distribution``
- `devel/query`:
    - fixed a problem printing parents when the starting path had lua pattern special characters in it
    - fixed a crash when trying to iterate over linked lists
- `gui/advfort`: encrust and stud jobs no longer consume reagents without actually improving the target item
- `luasocket`: return correct status code when closing socket connections so clients can know when to retry
- `quickfort`: contructions and bridges are now properly placed over natural ramps
- `setfps`: keep internal ratio of processing FPS to graphics FPS in sync when updating FPS

Misc Improvements
-----------------
- `autochop`:
    - only designate the amount of trees required to reach ``max_logs``
    - preferably designate larger trees over smaller ones
- `autonick`:
    - now displays help instead of modifying dwarf nicknames when run without parameters. use ``autonick all`` to rename all dwarves.
    - added ``--quiet`` and ``--help`` options
- `blueprint`:
    - ``track`` phase renamed to ``carve``
    - carved fortifications and (optionally) engravings are now captured in generated blueprints
- `cursecheck`: new option, ``--ids`` prints creature and race IDs of the cursed creature
- `debug`:
    - DFHack log messages now have configurable headers (e.g. timestamp, origin plugin name, etc.) via the ``debugfilter`` command of the `debug` plugin
    - script execution log messages (e.g. "Loading script: dfhack_extras.init" can now be controlled with the ``debugfilter`` command. To hide the messages, add this line to your ``dfhack.init`` file: ``debugfilter set Warning core script``
- `dfhack-examples-guide`:
    - add mugs to ``basic`` manager orders
    - ``onMapLoad_dreamfort.init`` remove "cheaty" commands and new tweaks that are now in the default ``dfhack.init-example`` file
- `dig-now`: handle fortification carving
- `EventManager`:
    - add new event type ``JOB_STARTED``, triggered when a job first gains a worker
    - add new event type ``UNIT_NEW_ACTIVE``, triggered when a new unit appears on the active list
- `gui/blueprint`: support new `blueprint` options and phases
- `gui/create-item`: Added "(chain)" annotation text for armours with the [CHAIN_METAL_TEXT] flag set
- `manipulator`: tweak colors to make the cursor easier to locate
- `quickfort`:
    - support transformations for blueprints that use expansion syntax
    - adjust direction affinity when transforming buildings (e.g.  bridges that open to the north now open to the south when rotated 180 degrees)
    - automatically adjust cursor movements on the map screen in ``#query`` and ``#config`` modes when the blueprint is transformed. e.g.  ``{Up}`` will be played back as ``{Right}`` when the blueprint is rotated clockwise and the direction key would move the map cursor
    - new blueprint mode: ``#config``; for playing back key sequences that don't involve the map cursor (like configuring hotkeys, changing standing orders, or modifying military uniforms)
    - API function ``apply_blueprint`` can now take ``data`` parameters that are simple strings instead of coordinate maps. This allows easier application of blueprints that are just one cell.
- `stocks`: allow search terms to match the full item label, even when the label is truncated for length
- `tweak`: ``stable-cursor`` now keeps the cursor stable even when the viewport moves a small amount
- ``dfhack.init-example``: recently-added tweaks added to example ``dfhack.init`` file

API
---
- add functions reverse-engineered from ambushing unit code: ``Units::isHidden()``, ``Units::isFortControlled()``, ``Units::getOuterContainerRef()``, ``Items::getOuterContainerRef()``

Lua
---
- `custom-raw-tokens`: library for accessing tokens added to raws by mods
- ``dfhack.units``: Lua wrappers for functions reverse-engineered from ambushing unit code: ``isHidden(unit)``, ``isFortControlled(unit)``, ``getOuterContainerRef(unit)``, ``getOuterContainerRef(item)``
- ``dialogs``: ``show*`` functions now return a reference to the created dialog
- ``dwarfmode.enterSidebarMode()``: passing ``df.ui_sidebar_mode.DesignateMine`` now always results in you entering ``DesignateMine`` mode and not ``DesignateChopTrees``, even when you looking at the surface (where the default designation mode is ``DesignateChopTrees``)
- ``dwarfmode.MenuOverlay``:
    - if ``sidebar_mode`` attribute is set, automatically manage entering a specific sidebar mode on show and restoring the previous sidebar mode on dismiss
    - new class function ``renderMapOverlay`` to assist with painting tiles over the visible map
- ``ensure_key``: new global function for retrieving or dynamically creating Lua table mappings
- ``safe_index``: now properly handles lua sparse tables that are indexed by numbers
- ``string``: new function ``escape_pattern()`` escapes regex special characters within a string
- ``widgets``:
    - unset values in ``frame_inset`` table default to ``0``
    - ``FilteredList`` class now allows all punctuation to be typed into the filter and can match search keys that start with punctuation
    - minimum height of ``ListBox`` dialog is now calculated correctly when there are no items in the list (e.g. when a filter doesn't match anything)
    - if ``autoarrange_subviews`` is set, ``Panel``\s will now automatically lay out widgets vertically according to their current height.  This allows you to have widgets dynamically change height or become visible/hidden and you don't have to worry about recalculating frame layouts
    - new class ``ResizingPanel`` (subclass of ``Panel``) automatically recalculates its own frame height based on the size, position, and visibility of its subviews
    - new class ``HotkeyLabel`` (subclass of ``Label``) that displays and reacts to hotkeys
    - new class ``CycleHotkeyLabel`` (subclass of ``Label``) allows users to cycle through a list of options by pressing a hotkey
    - new class ``ToggleHotkeyLabel`` (subclass of ``CycleHotkeyLabel``) toggles between ``On`` and ``Off`` states
    - new class ``WrappedLabel`` (subclass of ``Label``) provides autowrapping of text
    - new class ``TooltipLabel`` (subclass of ``WrappedLabel``) provides tooltip-like behavior

Structures
----------
- ``adventure_optionst``: add missing ``getUnitContainer`` vmethod
- ``historical_figure.T_skills``: add ``account_balance`` field
- ``job``: add ``improvement`` field (union with ``hist_figure_id`` and ``race``)
- ``report_init.flags``: rename ``sparring`` flag to ``hostile_combat``
- ``viewscreen_loadgamest``: add missing ``LoadingImageSets`` and ``LoadingDivinationSets`` enum values to ``cur_step`` field

Documentation
-------------
- add more examples to the plugin example skeleton files so they are more informative for a newbie
- update download link and installation instructions for Visual C++ 2015 build tools on Windows
- update information regarding obtaining a compatible Windows build environment
- `confirm`: correct the command name in the plugin help text
- `cxxrandom`: added usage examples
- `lua-string`: document DFHack string extensions (``startswith()``, ``endswith()``, ``split()``, ``trim()``, ``wrap()``, and ``escape_pattern()``)
- `quickfort-blueprint-guide`: added screenshots to the Dreamfort case study and overall clarified text
- `remote-client-libs`: add new Rust client library
- ``Lua API.rst``: added ``isHidden(unit)``, ``isFortControlled(unit)``, ``getOuterContainerRef(unit)``, ``getOuterContainerRef(item)``

[Rumrusher]

don't know why I never tested adding a view to the game but yeah
I think this mini script probably decent enough of a step to get to switching between fort mode and adventure mode.
 and possibly bringing back the old dfhack fort retire, and uhhh give players the means to quicksave in adventure mode.

ok so as I was writing this I got hit with two issues, one being if fort mode side ever unpause you will auto ruin the run which will end the run which could be fixed with a test to see if fort mode is unpaused then re-pausing it.
and if you made a quicksave you pretty much have to do a manual save after that to clean the save state or the game will crash if you try to fast travel.

Code: ("Adv2Fortswap.lua") [Select]

if  dfhack.world.isFortressMode() then
df.global.gview.view.child=df.viewscreen_dungeonmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
df.global.gamemode=1
df.global.gametype=1
else
df.global.gview.view.child=df.viewscreen_dwarfmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
df.global.gamemode=0
df.global.gametype=0
end

so here's the code beware this could lead to some other unstable stuff down the road I haven't tested or found but I think for a fort mode player perspective this should let one just jump into playing anyone if you set the unit up as an adventurer or well unit active 0



edit: additional quick test to see how well switching between adv mode and fort mode goes.

extremely experimental adv mode quicksave test which requires use of the previous script to fix the autosaves when you reload.

Code: ("advquicksave.lua") [Select]

-- Makes the game immediately save the state.
--[====[

Adv quicksave
=========
If called in adv mode, makes DF immediately switches to fort mode then saves the game by setting a flag
normally used in seasonal auto-save. then switches back to adv mode big warning the saves that are backup are set to fort mode so probably best run say a mode set script to switch back to adv mode then save the game again as last I check that seems to fix one crash after switching back to adv mode and fast traveling a bit.

]====]

local gui = require("gui")

--luacheck: defclass={run:bool}
QuicksaveOverlay = defclass(QuicksaveOverlay, gui.Screen)

function QuicksaveOverlay:render()
    if not self.run then
        self.run = true
        save()
        self:renderParent()
        self:dismiss()
    end
end

if not dfhack.isMapLoaded() then
    qerror("World and map aren't loaded.")
end
function adv2fort ()
if  dfhack.world.isFortressMode() then
df.global.gview.view.child=df.viewscreen_dungeonmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
df.global.gamemode=1
df.global.gametype=1
else
df.global.gview.view.child=df.viewscreen_dwarfmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
df.global.gamemode=0
df.global.gametype=0
end
end
if not dfhack.world.isFortressMode() then
adv2fort()
end

local ui_main = df.global.ui.main
local flags4 = df.global.d_init.flags4


local function restore_autobackup()
    if ui_main.autosave_request and dfhack.isMapLoaded() then
        dfhack.timeout(10, 'frames', restore_autobackup)
    else
        flags4.AUTOBACKUP = true
    end

end

function save()
    -- Request auto-save
    ui_main.autosave_request = true

    -- And since it will overwrite the backup, disable it temporarily
    if flags4.AUTOBACKUP then
        flags4.AUTOBACKUP = false
        restore_autobackup()
    end

    print 'The game should save the state now.'
end

QuicksaveOverlay():show()
dfhack.timeout(10, 'frames',adv2fort)


edit: ok so went and fix some issues that came up with this script mostly the fort mode side tends to break if you attempt to zoom on a unit, and the solution was I was missing the parent section on the viewscreen open legends had this solved since 2015 and I should have scan that lua script for tips.
so this should probably work for fort mode players who want to switch from fort mode to adv mode then back to fort mode if they don't leave the fort site and also if they assign an unit on field as an adventurer.

there's a tofort script warmist made that would benefit on this update but like I'm currently checking that one out and seeing if there's any more unforeseen errors that comes from using that and making minor tweaks.

oh while I'm here I should probably post the script I use to clear designation spam from using these scripts

Code: ("select-map.lua") [Select]

df.global.ui.main.mode=10
df.global.selection_rect.start_x=0
df.global.selection_rect.start_y=0
df.global.selection_rect.start_z=610
df.global.selection_rect.end_x=-1430
df.global.selection_rect.end_y=900
df.global.selection_rect.end_z=0
df.global.cursor.x=400
df.global.cursor.y=400
df.global.cursor.z=0

this script should select the entire map and let you clear designations with little scrolling as possible... though this will clear previously set designations so probably best to use this for returning to a fort after finishing up or making an adv closet to shove the adv in, to make the designation spam that would pop up from the adventurer's field of view be smaller to deal with and not lead to the entire fort digging up the place.

edit: ok so went back and updated the clear designation script to include the script selecting the clear designation menu so all you need to do is just hit enter after running the script... but also click on the header of the window of DF as any mouse support will mess with the cursor placement.

also here's the current attempt at modifying warmist's tofort script with viewscreen switching here
should be warned it's unstable to a degree so far in my testing it's possible to at least build on just about any site and any scripts that un-residents the whole town would be advised to be used.

like this one

Code: [Select]

function DeresidentCiv(unit,trgunit)
local adv=df.global.world.units.active[0].civ_id
for k,v in pairs(df.global.world.units.active) do
if v.civ_id==adv then

if v== nil then
error("Invalid creature")
end
v.flags2.resident=false
end
end
return true
endedit edit: ok so I ended up making two different versions of warmist's tofort(well 8ish this one is 6.0) and this one has the accidental mechanic of letting you keep access to your fort's military and squad while you explore the world in adv mode and switch back into fort mode, setting up means to do Squad level attack commands if you brought along your fort military on the trip or lets you enlist folks on site and command them to fight.

Spoiler: "tofort6.lua and tofort7.lua and tofort8.lua" (click to show/hide)

Code: (tofort6.lua) [Select]

-- changes from advmode to fort safely and back (hopefully)
--this version of warmist's tofort works really well going from fort mode to adv mode as you gain access to the fort's military
if df.global.gamemode==df.game_mode.ADVENTURE then
local adv=df.global.world.units.active[0]
local ui=df.global.ui
function advGlobalPos()
    local wd=df.global.world.world_data
    return wd.adv_region_x*16+wd.adv_emb_x,wd.adv_region_y*16+wd.adv_emb_y
end
function inSite()
    local tx,ty=advGlobalPos()
    for k,v in pairs(df.global.world.world_data.sites) do
        local tp2={v.global_min_x, v.global_min_y, v.global_max_x, v.global_max_y}
        if tx>=tp2[1] and tx<=tp2[3] and
            ty>=tp2[2] and ty<=tp2[4] then
            return v
        end
    end
end
local site=inSite()
if site==nil then
    qerror("No site you are in found.")
end
local h_ent
if ui.main.fortress_entity==nil then
    for k,v in pairs(df.global.world.entities.all) do
        if v.type==df.historical_entity_type.SiteGovernment then --maybe match race too?
            h_ent=v
            break
        end
    end
    if h_ent==nil then
        qerror("Valid historical entity not found. sorry...")
    end
    ui.main.fortress_entity=h_ent
else
    h_ent=ui.main.fortress_entity
end
function addToEntity(entity,unit,addtoLead)
    local nem=dfhack.units.getNemesis(unit)
    local hfig=nem.figure
    hfig.entity_links:insert("#",{new=df.histfig_entity_link_memberst,entity_id=entity.id,link_strength=100})
    entity.nemesis_ids:insert("#",nem.id)
    entity.nemesis:insert("#",nem)
    entity.histfig_ids:insert("#",hfig.id)
    entity.hist_figures:insert("#",hfig)
    if addtoLead then
        local lead_id
        for k,v in pairs(entity.positions.own) do
            if v.flags.IS_LEADER==true then
                lead_id=v.id
                break
            end
        end
        if lead_id~=nil then
            for k,v in pairs(entity.positions.assignments) do
                if v.position_id==lead_id  then
                        v.histfig=hfig.id
                    break
                end
            end
        end
    end
end

ui.civ_id=adv.civ_id
ui.race_id=adv.race
--[[for kui,vra in pairs(ui.unk_races) do
if vra~=nil then
print=("hey does this work")
vra:insert("#", ui.race_id)
--df.global.ui.unk_races:insert("#",adv.race)
else
break
end
end]]--
ui.unk_races:insert("#",adv.race)
ui.site_id=site.id
if ui.main.fortress_site==nil then ui.main.fortress_site=site end
if site.entity_links==nil then site.entity_links:insert("#", {new=true, df.entity_site_link, target=site.id, entity_id=ui.fortress_entity.id}) end
ui.group_id=h_ent.id
ui.game_state=2
addToEntity(h_ent,adv,true)
if #ui.alerts.list==0 then
    ui.alerts.list:insert("#",{new=true,name="Dummy alert"})
    ui.alerts.next_id=1
end
--fix training info
if h_ent.training_knowledge == nil then
    h_ent.training_knowledge={new=true}
end
df.global.gamemode=df.game_mode.DWARF
df.global.gametype=df.game_type.DWARF_MAIN
if df.global.gview.view.child.child==nil then df.global.gview.view.child=df.viewscreen_dwarfmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
 end
    print("Mode change complete. Now save and load")
else
    local adv=dfhack.gui.getSelectedUnit(true)
    if adv then
        --swap units...
    end
    df.global.gamemode=df.game_mode.ADVENTURE
    df.global.gametype=df.game_type.ADVENTURE_MAIN
df.global.gview.view.child=df.viewscreen_dungeonmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
    print("Mode change complete. Now save and load")
end


Code: (tofort7.lua) [Select]

-- changes from advmode to fort safely and back (hopefully)
if df.global.gamemode==df.game_mode.ADVENTURE then
local adv=df.global.world.units.active[0]
local ui=df.global.ui
function advGlobalPos()
    local wd=df.global.world.world_data
    return wd.adv_region_x*16+wd.adv_emb_x,wd.adv_region_y*16+wd.adv_emb_y
end
function inSite()
    local tx,ty=advGlobalPos()
    for k,v in pairs(df.global.world.world_data.sites) do
        local tp2={v.global_min_x, v.global_min_y, v.global_max_x, v.global_max_y}
        if tx>=tp2[1] and tx<=tp2[3] and
            ty>=tp2[2] and ty<=tp2[4] then
            return v
        end
    end
end
local site=inSite()
if site==nil then
    qerror("No site you are in found.")
end
local h_ent
if ui.main.fortress_entity~=nil or ui.main.fortress_site~=nil then
ui.main.fortress_entity=nil
ui.main.fortress_site=nil
end
if ui.main.fortress_entity==nil then
    for k,v in pairs(df.global.world.entities.all) do
        if v.type==df.historical_entity_type.SiteGovernment then --maybe match race too?
            h_ent=v
            break
        end
    end
    if h_ent==nil then
        qerror("Valid historical entity not found. sorry...")
    end
    ui.main.fortress_entity=h_ent
else
    h_ent=ui.main.fortress_entity
end
function cleardesignate(adv)
local adv=df.global.world.units.active[0]
df.global.ui.main.mode=10
df.global.selection_rect.start_x=0
df.global.selection_rect.start_y=0
df.global.selection_rect.start_z=610
df.global.selection_rect.end_x=-14300
df.global.selection_rect.end_y=9000
df.global.selection_rect.end_z=0
df.global.cursor.x=400
df.global.cursor.y=400
df.global.cursor.z=0
dfhack.gui.getCurViewscreen():feed_key(1)
df.global.cursor.x=adv.pos.x
df.global.cursor.y=adv.pos.y
df.global.cursor.z=adv.pos.z
dfhack.gui.getCurViewscreen():feed_key(1)
dfhack.run_command('revflood')

end
function addToEntity(entity,unit,addtoLead)
    local nem=dfhack.units.getNemesis(unit)
    local hfig=nem.figure
    hfig.entity_links:insert("#",{new=df.histfig_entity_link_memberst,entity_id=entity.id,link_strength=100})
    entity.nemesis_ids:insert("#",nem.id)
    entity.nemesis:insert("#",nem)
    entity.histfig_ids:insert("#",hfig.id)
    entity.hist_figures:insert("#",hfig)
    if addtoLead then
        local lead_id
        for k,v in pairs(entity.positions.own) do
            if v.flags.IS_LEADER==true then
                lead_id=v.id
                break
            end
        end
        if lead_id~=nil then
            for k,v in pairs(entity.positions.assignments) do
                if v.position_id==lead_id  then
                        v.histfig=hfig.id
                    break
                end
            end
        end
    end
end

ui.civ_id=adv.civ_id
ui.race_id=adv.race
df.global.pause_state=true


ui.unk_races:insert("#",adv.race)
ui.site_id=site.id
if ui.main.fortress_site==nil then ui.main.fortress_site=site end
if site.entity_links==nil then site.entity_links:insert("#", {new=true, df.entity_site_link, target=site.id, entity_id=ui.fortress_entity.id}) end
ui.group_id=h_ent.id
ui.game_state=2
addToEntity(h_ent,adv,true)
if #ui.alerts.list==0 then
    ui.alerts.list:insert("#",{new=true,name="Dummy alert"})
    ui.alerts.next_id=1
end
--fix training info
if h_ent.training_knowledge == nil then
    h_ent.training_knowledge={new=true}
end
df.global.gamemode=df.game_mode.DWARF
df.global.gametype=df.game_type.DWARF_MAIN
if df.global.gview.view.child.child==nil then df.global.gview.view.child=df.viewscreen_dwarfmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
 end
 cleardesignate()
    print("Mode change complete. Now save and load")
else
    local adv=dfhack.gui.getSelectedUnit(true)
    if adv then
        --swap units...
    end
    df.global.gamemode=df.game_mode.ADVENTURE
    df.global.gametype=df.game_type.ADVENTURE_MAIN
df.global.gview.view.child=df.viewscreen_dungeonmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
    print("Mode change complete. Now save and load")
end


Code: (tofort8.lua) [Select]

-- changes from advmode to fort safely and back (hopefully)
if df.global.gamemode==df.game_mode.ADVENTURE then
local adv=df.global.world.units.active[0]
local ui=df.global.ui
function advGlobalPos()
    local wd=df.global.world.world_data
    return wd.adv_region_x*16+wd.adv_emb_x,wd.adv_region_y*16+wd.adv_emb_y
end
--[[function inSite()
    local tx,ty=advGlobalPos()
    for k,v in pairs(df.global.world.world_data.sites) do
        local tp={v.pos.x,v.pos.y}
        if tx>=tp[1]*16+v.rgn_min_x and tx<=tp[1]*16+v.rgn_max_x and
            ty>=tp[2]*16+v.rgn_min_y and ty<=tp[2]*16+v.rgn_max_y then
            return v
        end
    end
end]]--
function inSite()
    local tx,ty=advGlobalPos()
    for k,v in pairs(df.global.world.world_data.sites) do
        local tp2={v.global_min_x, v.global_min_y, v.global_max_x, v.global_max_y}
        if tx>=tp2[1] and tx<=tp2[3] and
            ty>=tp2[2] and ty<=tp2[4] then
            return v
        end
    end
end
local site=inSite()
if site==nil then
    qerror("No site you are in found.")
end
local h_ent
if ui.main.fortress_entity~=nil or ui.main.fortress_site~=nil then
ui.main.fortress_entity=nil
ui.main.fortress_site=nil
end
if ui.main.fortress_entity==nil then
    for k,v in pairs(df.global.world.entities.all) do
        if v.type==df.historical_entity_type.SiteGovernment then --maybe match race too?
            h_ent=v
            break
        end
    end
    if h_ent==nil then
        qerror("Valid historical entity not found. sorry...")
    end
    ui.main.fortress_entity=h_ent
else
    h_ent=ui.main.fortress_entity
end
function cleardesignate(adv)
local adv=df.global.world.units.active[0]
df.global.ui.main.mode=10
df.global.selection_rect.start_x=0
df.global.selection_rect.start_y=0
df.global.selection_rect.start_z=610
df.global.selection_rect.end_x=-14300
df.global.selection_rect.end_y=9000
df.global.selection_rect.end_z=0
df.global.cursor.x=400
df.global.cursor.y=400
df.global.cursor.z=0
dfhack.gui.getCurViewscreen():feed_key(1)
df.global.cursor.x=adv.pos.x
df.global.cursor.y=adv.pos.y
df.global.cursor.z=adv.pos.z
dfhack.gui.getCurViewscreen():feed_key(1)
dfhack.run_command('revflood')

end
function addToEntity(entity,unit,addtoLead)
    local nem=dfhack.units.getNemesis(unit)
    local hfig=nem.figure
    hfig.entity_links:insert("#",{new=df.histfig_entity_link_memberst,entity_id=entity.id,link_strength=100})
    entity.nemesis_ids:insert("#",nem.id)
    entity.nemesis:insert("#",nem)
    entity.histfig_ids:insert("#",hfig.id)
    entity.hist_figures:insert("#",hfig)
    if addtoLead then
        local lead_id
        for k,v in pairs(entity.positions.own) do
            if v.flags.IS_LEADER==true then
                lead_id=v.id
                break
            end
        end
        if lead_id~=nil then
            for k,v in pairs(entity.positions.assignments) do
                if v.position_id==lead_id  then
                        v.histfig=hfig.id
                    break
                end
            end
        end
    end
end

ui.civ_id=adv.civ_id
ui.race_id=adv.race
--[[for kui,vra in pairs(ui.unk_races) do
if vra~=nil then
print=("hey does this work")
vra:insert("#", ui.race_id)
--df.global.ui.unk_races:insert("#",adv.race)
else
break
end
end]]--
df.global.pause_state=true


ui.unk_races:insert("#",adv.race)
--if ui.unk_races==0 then ui.unk_races:insert("#",adv.race) end
ui.site_id=site.id
if ui.main.fortress_site==nil then ui.main.fortress_site=site end
--if site.entity_links==nil then site.entity_links:insert("#", {new=true, df.entity_site_link, target=site.id, entity_id=ui.fortress_entity.id, flags[0]=true, flags[5]=true }) end end
if site.entity_links==nil then site.entity_links:insert("#", {new=true, df.entity_site_link, target=site.id, entity_id=ui.fortress_entity.id,entity_site_link_flags.residence, entity_site_link_flags.trade_partner }) end
--if site.entity_links==nil then site.entity_links:insert("#", {new=true, df.entity_site_link, target=site.id, entity_id=ui.fortress_entity.id}) end
ui.group_id=h_ent.id
ui.game_state=2
addToEntity(h_ent,adv,true)
if #ui.alerts.list==0 then
    ui.alerts.list:insert("#",{new=true,name="Dummy alert"})
    ui.alerts.next_id=1
end
--fix training info
if h_ent.training_knowledge == nil then
    h_ent.training_knowledge={new=true}
end
df.global.gamemode=df.game_mode.DWARF
df.global.gametype=df.game_type.DWARF_MAIN
if df.global.gview.view.child.child==nil then df.global.gview.view.child=df.viewscreen_dwarfmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
 end
 cleardesignate()
    print("Mode change complete. Now save and load")
else
    local adv=dfhack.gui.getSelectedUnit(true)
    if adv then
        --swap units...
    end
    df.global.gamemode=df.game_mode.ADVENTURE
    df.global.gametype=df.game_type.ADVENTURE_MAIN
df.global.gview.view.child=df.viewscreen_dungeonmodest:new()
df.global.gview.view.child.parent=df.global.gview.view
    print("Mode change complete. Now save and load")
end


this is still a work in progress as it's potential to say lose progress or crash, or accidentally maroon your citizens in locations.
edit: ok so after some time I think I got most of my concerns with switching between fort mode and adv mode and now probably don't need to run a bunch of extra scripts after running the modified tofort script warmist made
which I updated and added under the title tofort7.lua so all you really need is for going from fort mode to adv mode is that you assign an adventurer first using any bodyswap script.

edit: ok so uhh went and added another additional tofort modification called tofort8.

[myk]

Just a public service announcement, we're planning on turning down Ruby support within the next few DFHack releases. If you don't know what this means, then it probably won't affect you at all, and you don't need to worry about it and you can stop reading now : )

For those of you still reading, here's the longer explanation. There are currently two scripting languages supported by DFHack: Lua and Ruby. Lua is (by a large margin) the better supported of the two languages. Most of DFHack's scripts are written in Lua. Some developers have preferred writing scripts in Ruby, and there was enough support for Ruby scripts to modify DF game state and call a subset of the DFHack API. However, the Ruby runtime has become very difficult to maintain and is causing compatibility issues on some systems. The plan is:
1) rewrite DFHack's Ruby scripts in Lua (commands you run on the DFHack prompt won't change)
2) print a warning if a Ruby script is run
3) sometime in the future, remove the Ruby plugin entirely

The warning in (2) should only ever be seen by players who have written their own ruby scripts. We'll keep the warning in place for a while, hopefully giving those players enough time to migrate their scripts to Lua.

If you have any strong objections to this plan, please make your voice heard here or on the GitHub issue.

[catagris]

I am running into an issue, when I run the command ./dfhack I get the error:

Code: [Select]

env: ‘./libs/Dwarf_Fortress’: No such file or directory
The install directory is

Code: [Select]

/usr/share/games/dwarf-fortress/gamedata
My GCC version is

Code: [Select]

gcc (Debian 10.2.1-6) 10.2.1 20210110
I installed dfhack version

Code: [Select]

dfhack-0.47.05-r5-Linux-64bit-gcc-7.tar.bz2
Thank you for any help

[myk]

This sounds like a symlink problem. In the directory where you run ./dfhack, what is the output of

ls -l . ./libs

? Are there symlinks that point to non-existent directories?

[Ziusudra]

The install directory is

Code: [Select]

/usr/share/games/dwarf-fortress/gamedata
I installed dfhack version

Code: [Select]

dfhack-0.47.05-r5-Linux-64bit-gcc-7.tar.bz2

You can't install DFHack directly onto the Debian DF packages - those packages change the locations of DF's files in ways that DFHack can't find them.

If you want to use DFHack on Debian, you either need to do a manual install of DF in your home and install/run DFHack on that, or find or create a DFHack deb package that somehow accounts for where the DF deb package put the DF files. For example, the experimental DF deb package puts the missing file in /usr/lib/games/dwarf-fortress/libs/Dwarf_Fortress, and that /usr/games/dwarf-fortress is probably a script that creates a folder in your home that mimics the default DF folder layout so that DF can find it's files.

Edit: Or use the LinuxDwarfPack release deb package instead - though that's a bit behind, you can find more recent versions here.

[A_Curious_Cat]

The recent FotF talk about keyboard and mouse support (especially, iirc, about the possibility of removing the ability to move the cursor with the keyboard) has got me wondering…

How will DFHack be affected by the Steam release?

[myk]

It's certainly been on my mind. Most viewscreens will have to be re-reverse engineered. A lot of code interacts with the input system, intercepting keys or feeding keys into the UI. Depending on how the input system is changing, that might all have to get adapted.

Quickfort should work fine for #dig, #build, and #zone blueprints since they modify memory structures directly. #query and #config blueprints do actually send keystrokes, so that might need rework. #place blueprints have a hybrid approach (memory is modified directly to create the stockpiles, but they are configured via the UI), so they'll need some thought too.

We did spend some time preparing for potential toolchain changes (e.g. compiler version), but Toady confirmed that no toolchain changes are planned for the steam release. That will help things go a little faster (if it remains true) since memory layouts are unlikely to change for existing structures.

The short of it is that we won't really know what we have to do until we get our hands on a release binary. I do expect a lot of work verifying the functionality of each and every plugin and script. If functionality is broken in ways that are not easy to fix, we might do a limited release that only includes stuff that works, adding elements back to the release as we adapt them.

In preparation, I've started writing more integration tests for scripts. That will help cut down on the manual testing required. If we do limited releases, the scripts with integration tests will likely get released first since we can be more confident that they will *keep* working as we make other internal changes.

[Rumrusher]

ok so poking around with the switching between adv mode and fort mode script warmist made years ago, and stumble upon some weird quirk from not filling out the ui.main.fortress_entity and ui.main.fortress_site data.

mostly that if those are still connected to the previous fort site this will connect to the squads and military and nobles from that site.
also the civ id, site id, group id mostly controls who you control on the current site.
so technically it's possible to dfhack switch between groups of different civilians from different civ ids then control them in fort mode.
but also assign them to the military and add them to the main civ that's off site... or assign them to the noble position off site.

though it does feel a bit bittersweet given if I knew about this sooner I could have been interweaving fort mode and adv mode together with dfhack back when warmist originally made the tofort script.

but other than wishful thinking of the past, I ended up tweaking it so the script will check to see if you're on the correct site and assign the correct fortress entity and fortress site to fort mode.

[lethosor]

The recent FotF talk about keyboard and mouse support (especially, iirc, about the possibility of removing the ability to move the cursor with the keyboard) has got me wondering…

How will DFHack be affected by the Steam release?

If the initial release is Windows-only, that will significantly slow development. We may not be able to make much progress at all until there are releases for other platforms because a lot of us are using Linux, and most of our CI only runs in Linux too.

There was a suggestion that came up on Discord within hours of the FotF post about re-adding the keyboard cursor with a plugin. I think it would be doable - we effectively already support the opposite of this with mousequery. Any tools that rely on the existing keyboard cursor for user input (gui/liquids, gui/teleport, etc.) will probably need to be adjusted to work with the mouse and/or a keyboard cursor plugin.

[Quarque]

Is this the right place to report a bug in the eventful module? If you use the registerReaction(reaction_name,callback) to modify a reaction, it seems that the callback function never receives the 7th argument (call_native).

Can be reproduced with the following script, that should make brewing require water:

Spoiler (click to show/hide)

-- Forces brewing in a still to require water
local eventful = require 'plugins.eventful'
local utils = require 'utils'
function usewater(reaction,reaction_product,unit,input_items,input_reagents,output_items,call_native)
   local building = dfhack.buildings.findAtTile(unit.pos)
   local pos = {}
   pos.x1 = building.x1
   pos.x2 = building.x2
   pos.y1 = building.y1
   pos.y2 = building.y2
   pos.z = building.z
   for x = pos.x1-1, pos.x2+1, 1 do
      for y = pos.y1-1, pos.y2+1, 1 do
         baseBlock = dfhack.maps.ensureTileBlock(x,y,pos.z)
         liquidBlock = dfhack.maps.ensureTileBlock(x,y,pos.z-1)
         if liquidBlock.designation[x%16][y%16].flow_size > 0 and liquidBlock.designation[x%16][y%16].liquid_type == false then
            liquidBlock.designation[x%16][y%16].flow_size = liquidBlock.designation[x%16][y%16].flow_size - 1
            call_native.value=true
            return
         end
      end
   end
   dfhack.gui.showZoomAnnouncement(df.announcement_type.CANCEL_JOB, unit.pos, dfhack.TranslateName(unit.name).." cancels "..reaction.name..": Needs water." , COLOR_RED, true)
   call_native.value=false
   -- Force the job to fail.  Create no Products; do not provide any experience points in the associated Skill. 
   -- Note: the failed job WILL consume the normal set of Reagents.
   dfhack.job.setJobCooldown(building, unit, 5) -- Prevent the worker from immediately re-attempting the failed Job.
   return
end

dfhack.onStateChange.loadUseLiquid = function(code)
   if code==SC_MAP_LOADED then
      for i,reaction in ipairs(df.global.world.raws.reactions.reactions) do
         if string.startswith(reaction.code,'BREW_DRINK') then
            eventful.registerReaction(reaction.code,usewater)
            print('reaction should now require water: ')
            print(reaction.code)
         end
      end
   elseif code==SC_MAP_UNLOADED then
   end
end

if dfhack.isMapLoaded() then dfhack.onStateChange.loadUseLiquid(SC_MAP_LOADED) end

[myk]

Thanks for bringing this to our attention! It's best to report issues like this on the issue tracker so we can assign someone to look into it. That way, you'll also get notified when the issue is fixed!

(Btw I looked at the code, and you're absolutely right. The parameter just isn't being passed)

Actually actually, there are two callbacks, onReactionCompleting, which passes call_native, and onReactionComplete, which does not (because by the time that event fires, the native callback has already been called). Iow, I'll look into this more. It might be a documentation issue.

[Quarque]

Thank you for checking so quickly! I will report the issue on the tracker.

[Rumrusher]

ok wrote a script that grabs the squad members from your fort and plops them into your adv mode session
though after running into a bunch of roadblocks the rough coding only checks for the df.global.ui.squad data than say scanning through squads and checking his figs being tied to the adventurer.
so the use of this script is for mainly for grabbing an militia commander adventurer and enlisting folks into your fort's military then summoning them to your location, and making it so your fort's militia could show up and be used when you switch over to fort mode with the previously posted modified tofort scripts which sets up doing site invasions.

Code: [Select]

function SummonSquad()
for ks,vs in pairs(df.global.world.armies.all) do
if vs.flags[0]== true  then
if df.global.ui.squads.list~=nil then
for li2,nk2 in pairs (df.global.ui.squads.list) do
for li3,nk3 in pairs (nk2.positions) do
Awombo=df.global.world.nemesis.all[vs.members[0].nemesis_id].figure
if nk3.occupant~=-1 or nk3.occupant==Awombo.id then
wombo=df.global.world.history.figures[nk3.occupant].nemesis_id
Awombo=df.global.world.history.figures[nk3.occupant].nemesis_id
vs.members:insert("#",{new=true,nemesis_id=wombo})
end
end
end
end
end
end
end