tracker: sticky selection and Ctrl+Home walk-to; walltones: conventional volume
Tracker selection now survives a rescan. The scan is rebuilt every turn and both lists are distance-sorted, so holding a bare index meant one step by the player silently re-pointed the selection at a different rat. The tracker now remembers identity instead -- the actor table for creatures, coordinates for tiles -- and re-derives the indices in reanchor() after each rescan. Selection is dropped only when the thing genuinely stops being reported (out of FoV, killed, picked up), and the existing clamp then falls back to the nearest. Ctrl+Home walks to the selection, reusing the exact shape of the game's own click-to-path in ingame.mousepressed: calculatePathFromPlayer, then either bufferInput or playerInput for a one-step path. Interruptions and threatened- player truncation therefore behave the way a mouse click does. Most things worth tracking stand on impassable tiles, which calculatePathFromPlayer refuses outright, so we fall back to the cheapest of the 8 neighbours and say "next to" rather than "to". Guarded on states.getCurrent() == "ingame": elsewhere the input buffer belongs to another state and feeding it moves would be a bug. Wall tones now follow the usual proximity convention -- a near wall is loud, one out at radius is quiet. It was inverted, which read backwards in play since a nearby wall is the more urgent fact. config.louderWhenFurther still flips it. Testbed covers both: selection identity across a forced rescan, and that Ctrl+Home moves the player without breaking out of the map. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Accessibility Mod
co-authored by
Claude Opus 5
Claude Opus 5
parent
6380998376
commit
81a209b600
+208
-4
@@ -6,6 +6,7 @@
|
||||
-- PageUp / PageDown kind "rat"
|
||||
-- Shift+PageUp / Shift+PageDown instance that specific rat
|
||||
-- Home announce distance + direction
|
||||
-- Ctrl+Home walk there (what a left click does)
|
||||
--
|
||||
-- Two hard rules:
|
||||
--
|
||||
@@ -28,9 +29,15 @@ local categoryIndex = 1
|
||||
local kindIndex = 1
|
||||
local instanceIndex = 1
|
||||
|
||||
local scan -- { [categoryKey] = { kinds = { {key, name, instances={{x,y},..}}, .. } } }
|
||||
local scan -- { [categoryKey] = { kinds = { {key, name, instances={{x,y,ref},..}}, .. } } }
|
||||
local scanSignature
|
||||
|
||||
-- What the player last deliberately selected, so a rescan can put the cursor back
|
||||
-- on it. Indices alone are useless here: the lists are distance-sorted, so a
|
||||
-- single step re-orders them and a bare index silently selects a different rat.
|
||||
local selectedKindKey -- string, or nil
|
||||
local selectedInstance -- {ref = actor} for creatures, {x, y} for tiles
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Scanning
|
||||
--------------------------------------------------------------------------------
|
||||
@@ -66,7 +73,9 @@ local function newBucket()
|
||||
return {kinds = {}, byKind = {}}
|
||||
end
|
||||
|
||||
local function addTo(bucket, kindKey, kindName, x, y)
|
||||
-- ref, when given, is the actor table itself: a creature's identity survives it
|
||||
-- walking, its coordinates do not.
|
||||
local function addTo(bucket, kindKey, kindName, x, y, ref)
|
||||
if not kindKey then
|
||||
return
|
||||
end
|
||||
@@ -79,7 +88,7 @@ local function addTo(bucket, kindKey, kindName, x, y)
|
||||
bucket.kinds[#bucket.kinds + 1] = kind
|
||||
end
|
||||
|
||||
kind.instances[#kind.instances + 1] = {x = x, y = y}
|
||||
kind.instances[#kind.instances + 1] = {x = x, y = y, ref = ref}
|
||||
end
|
||||
|
||||
function tracker.rescan(force)
|
||||
@@ -110,7 +119,7 @@ function tracker.rescan(force)
|
||||
local visible = level.FoV and level.FoV[actor.x] and level.FoV[actor.x][actor.y]
|
||||
if visible then
|
||||
addTo(buckets.creatures, categories.actorKind(actor),
|
||||
categories.actorName(actor), actor.x, actor.y)
|
||||
categories.actorName(actor), actor.x, actor.y, actor)
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -166,9 +175,85 @@ function tracker.rescan(force)
|
||||
|
||||
scan = buckets
|
||||
scanSignature = signature
|
||||
tracker.reanchor()
|
||||
return scan
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Selection stability
|
||||
--
|
||||
-- The scan is rebuilt from scratch every turn and both lists are distance-sorted,
|
||||
-- so the same rat is at a different index each time it or the player moves. We
|
||||
-- therefore track the selection by identity and re-derive the indices after every
|
||||
-- rescan. The selection is only dropped when the thing genuinely stops being
|
||||
-- reported -- out of FoV, killed, picked up.
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
local function sameInstance(instance, wanted)
|
||||
if not instance or not wanted then
|
||||
return false
|
||||
end
|
||||
if wanted.ref then
|
||||
return instance.ref == wanted.ref
|
||||
end
|
||||
return instance.ref == nil and instance.x == wanted.x and instance.y == wanted.y
|
||||
end
|
||||
|
||||
-- Record what is selected right now. Called after every deliberate move of the
|
||||
-- selection, never during a rescan.
|
||||
local function remember()
|
||||
local category = categories.list[categoryIndex]
|
||||
local bucket = scan and category and scan[category.key]
|
||||
local kind = bucket and bucket.kinds[kindIndex]
|
||||
|
||||
selectedKindKey = kind and kind.key or nil
|
||||
|
||||
local instance = kind and kind.instances[instanceIndex]
|
||||
if instance then
|
||||
selectedInstance = instance.ref and {ref = instance.ref} or {x = instance.x, y = instance.y}
|
||||
else
|
||||
selectedInstance = nil
|
||||
end
|
||||
end
|
||||
|
||||
function tracker.reanchor()
|
||||
local category = categories.list[categoryIndex]
|
||||
local bucket = scan and category and scan[category.key]
|
||||
|
||||
if not bucket or not selectedKindKey then
|
||||
return
|
||||
end
|
||||
|
||||
local foundKind
|
||||
for i, kind in ipairs(bucket.kinds) do
|
||||
if kind.key == selectedKindKey then
|
||||
kindIndex, foundKind = i, kind
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if not foundKind then
|
||||
-- The kind is gone from view entirely. Let the clamp in currentKind pick
|
||||
-- whatever is nearest and stop pretending we still have a selection.
|
||||
selectedKindKey, selectedInstance = nil, nil
|
||||
return
|
||||
end
|
||||
|
||||
if not selectedInstance then
|
||||
return
|
||||
end
|
||||
|
||||
for i, instance in ipairs(foundKind.instances) do
|
||||
if sameInstance(instance, selectedInstance) then
|
||||
instanceIndex = i
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
-- Kind still visible, this particular one is not.
|
||||
selectedInstance = nil
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Access
|
||||
--------------------------------------------------------------------------------
|
||||
@@ -204,6 +289,23 @@ local function currentInstance()
|
||||
return kind.instances[instanceIndex], kind
|
||||
end
|
||||
|
||||
-- What is selected right now, after any pending rescan. Used by the testbed, and
|
||||
-- handy for anything that wants to follow the tracker cursor.
|
||||
function tracker.currentSelection()
|
||||
local instance, kind = currentInstance()
|
||||
if not instance then
|
||||
return nil
|
||||
end
|
||||
return {
|
||||
category = currentCategory() and currentCategory().key,
|
||||
kind = kind.key,
|
||||
name = kind.name,
|
||||
x = instance.x,
|
||||
y = instance.y,
|
||||
ref = instance.ref,
|
||||
}
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Announcements
|
||||
--------------------------------------------------------------------------------
|
||||
@@ -284,6 +386,7 @@ function tracker.cycleCategory(delta)
|
||||
categoryIndex = cycle(categoryIndex, delta, #categories.list)
|
||||
kindIndex = 1
|
||||
instanceIndex = 1
|
||||
remember()
|
||||
announceCategory()
|
||||
end
|
||||
|
||||
@@ -295,6 +398,7 @@ function tracker.cycleKind(delta)
|
||||
end
|
||||
kindIndex = cycle(kindIndex, delta, #bucket.kinds)
|
||||
instanceIndex = 1
|
||||
remember()
|
||||
announceKind()
|
||||
end
|
||||
|
||||
@@ -305,6 +409,7 @@ function tracker.cycleInstance(delta)
|
||||
return
|
||||
end
|
||||
instanceIndex = cycle(instanceIndex, delta, #kind.instances)
|
||||
remember()
|
||||
announceInstance()
|
||||
end
|
||||
|
||||
@@ -338,6 +443,104 @@ function tracker.announceLocation()
|
||||
speech.say(table.concat(parts, ", "), true)
|
||||
end
|
||||
|
||||
-- Ctrl+Home: actually go there.
|
||||
--
|
||||
-- This is the keyboard equivalent of a left click on the tile (states/ingame.lua
|
||||
-- mousepressed): build a path with calculatePathFromPlayer, then hand it to the
|
||||
-- level's input buffer with the ingame state as the owner. We deliberately use
|
||||
-- the game's own two-branch shape -- a one-step path goes through playerInput
|
||||
-- directly, because bufferInput for a single move re-enters the buffer machinery
|
||||
-- for no reason.
|
||||
--
|
||||
-- Most things worth tracking stand on impassable tiles (a rat, a chest), and
|
||||
-- calculatePathFromPlayer refuses those outright. So when the tile itself has no
|
||||
-- path we path to the best neighbouring tile instead, which is what a player
|
||||
-- clicking a monster expects to happen anyway.
|
||||
local function pathTo(level, x, y)
|
||||
local ok, path = pcall(level.calculatePathFromPlayer, x, y)
|
||||
if ok and path and #path > 0 then
|
||||
return path, true
|
||||
end
|
||||
|
||||
local best
|
||||
for dx = -1, 1 do
|
||||
for dy = -1, 1 do
|
||||
if dx ~= 0 or dy ~= 0 then
|
||||
local okNear, near = pcall(level.calculatePathFromPlayer, x + dx, y + dy)
|
||||
if okNear and near and #near > 0 and (not best or #near < #best) then
|
||||
best = near
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return best, false
|
||||
end
|
||||
|
||||
function tracker.walkToSelection()
|
||||
local instance, kind = currentInstance()
|
||||
|
||||
if not instance then
|
||||
local category = currentCategory()
|
||||
speech.say((category and category.name or "Tracker") .. ", nothing selected", true)
|
||||
return
|
||||
end
|
||||
|
||||
-- Walking is only meaningful on the map. In a menu or the observe cursor the
|
||||
-- input buffer belongs to another state and feeding it moves would be a bug.
|
||||
local okStates, states = pcall(require, "states")
|
||||
if not okStates or states.getCurrent() ~= "ingame" then
|
||||
speech.say("Cannot walk from here", true)
|
||||
return
|
||||
end
|
||||
|
||||
local level = getLevel()
|
||||
local actor = level and level.playerActor
|
||||
if not actor then
|
||||
return
|
||||
end
|
||||
|
||||
if instance.x == actor.x and instance.y == actor.y then
|
||||
speech.say(kind.name .. ", already here", true)
|
||||
return
|
||||
end
|
||||
|
||||
local path, exact = pathTo(level, instance.x, instance.y)
|
||||
if not path then
|
||||
speech.say(kind.name .. ", no path", true)
|
||||
return
|
||||
end
|
||||
|
||||
-- Same module key states.lua uses, so we share its cached instance.
|
||||
local okIngame, ingame = pcall(require, "states/ingame")
|
||||
if not okIngame then
|
||||
return
|
||||
end
|
||||
|
||||
pcall(level.skipAllAnimations)
|
||||
|
||||
local okMove, err
|
||||
if #path == 1 then
|
||||
okMove, err = pcall(level.playerInput, "move",
|
||||
actor.x + path[1].dx, actor.y + path[1].dy, ingame)
|
||||
else
|
||||
okMove, err = pcall(level.bufferInput, "move", path, ingame)
|
||||
end
|
||||
|
||||
if not okMove then
|
||||
print("[accessibility] walk to selection failed: " .. tostring(err))
|
||||
speech.say(kind.name .. ", cannot walk there", true)
|
||||
return
|
||||
end
|
||||
|
||||
-- calculatePathFromPlayer truncates to a single step while the player is
|
||||
-- threatened, so the spoken count is the number of steps that will actually
|
||||
-- be taken, not the distance to the target.
|
||||
speech.say(string.format("Walking %s %s, %d %s",
|
||||
exact and "to" or "next to", kind.name,
|
||||
#path, #path == 1 and "step" or "steps"), true)
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Key registration
|
||||
--------------------------------------------------------------------------------
|
||||
@@ -353,6 +556,7 @@ function tracker.registerKeys(hotkeys)
|
||||
hotkeys.bind("pagedown", nil, function() tracker.cycleKind(1) end)
|
||||
|
||||
hotkeys.bind("home", nil, tracker.announceLocation)
|
||||
hotkeys.bind("home", "ctrl", tracker.walkToSelection)
|
||||
end
|
||||
|
||||
return tracker
|
||||
|
||||
Reference in New Issue
Block a user