498 lines
18 KiB
Text
498 lines
18 KiB
Text
-- How a KarisFramework game and its Forge port are driven for comparison (FORGE.md section
|
|
-- 14.1): the same policy, read off the same state in either. A run presses START on the
|
|
-- attract loop, then answers each move a few frames into its window -- the right answer, or a
|
|
-- wrong one for every fifth move so deaths and continues are exercised -- and takes the one
|
|
-- continue offered. Both scripts hand this file a view of their state (karisView) and a way
|
|
-- to press and release a switch (karisPress); this file does the deciding.
|
|
--
|
|
-- The trace both print: every disc seek, and every change of the framework's screen, step,
|
|
-- level, scene, move, score, and lives, in the framework's numbers.
|
|
KARIS_SEED = 20260914
|
|
|
|
local lastLine = nil
|
|
local pressed = nil -- The switch held down this frame, released the next.
|
|
local started = false
|
|
local coined = false
|
|
local continued = false
|
|
local answered = {} -- Windows already answered, by "level/scene/move/lives".
|
|
local tried = {} -- Moves met before, by "level/scene/move": a retry after a death.
|
|
|
|
-- What the drive does with a move, so that every path of a loop is walked: most moves are
|
|
-- answered right; every fifth is answered wrong (a stray input, a wrong option, a mash
|
|
-- broken by a stray input); every seventh is left unanswered (the window runs out). A move
|
|
-- met again after a death is answered right. PORT_WRONG_EVERY and PORT_MISS_EVERY set the
|
|
-- two counts, for a run that goes deeper into a game with few lives.
|
|
local WRONG_EVERY = tonumber(os.getenv("PORT_WRONG_EVERY")) or 5
|
|
local MISS_EVERY = tonumber(os.getenv("PORT_MISS_EVERY")) or 7
|
|
local function wrongMove(view)
|
|
return (view.move % WRONG_EVERY == 0) and not view.retry
|
|
end
|
|
local function missedMove(view)
|
|
return (view.move % MISS_EVERY == 0) and (view.move % WRONG_EVERY ~= 0) and not view.retry
|
|
end
|
|
local seeks = 0
|
|
local plan = nil -- Kimmy: the presses planned for the window being answered.
|
|
local held = {} -- Kimmy: the switches the plan holds down, by switch.
|
|
local menuAt = 0 -- Kimmy: the frame a menu was last answered on.
|
|
KARIS_FRAMES = tonumber(os.getenv("PORT_FRAMES")) or 60000
|
|
|
|
-- The framework's move numbers as switches; Kimmy's diagonals are two of them.
|
|
local SWITCH_OF = { [1] = SWITCH_UP, [2] = SWITCH_DOWN, [3] = SWITCH_LEFT, [4] = SWITCH_RIGHT, [5] = SWITCH_BUTTON1, [6] = SWITCH_BUTTON2, [7] = SWITCH_BUTTON3 }
|
|
local PAIR_OF = { [9] = { 1, 3 }, [10] = { 1, 4 }, [11] = { 2, 3 }, [12] = { 2, 4 } }
|
|
local KIMMY = { COMBO = 20, MULTI = 21, LOOP = 22, MASH = 23, HOLD = 24, LETGO = 25, PATH = 51, YESNO = 52, TIMED = 53, ANYTHING = 54, NOTHING = 55, UD = 151, LR = 153, B1B2 = 155 }
|
|
|
|
-- The KarisFramework's compound kinds, and the MazescaterFramework's (LINEA), as what they
|
|
-- take, by the framework's numbers: a sequence's inputs in turn (a circle is five, back to
|
|
-- its start), a mash's input (or the two it alternates), a hold's input, and the inputs a
|
|
-- combination wants together.
|
|
local SEQ_OF = { [35] = { 3, 2, 4, 1, 3 }, [36] = { 4, 2, 3, 1, 4 },
|
|
[156] = { 1, 3 }, [157] = { 1, 4 }, [158] = { 2, 3 }, [159] = { 2, 4 }, [160] = { 3, 1 }, [161] = { 4, 1 }, [162] = { 3, 2 }, [163] = { 4, 2 },
|
|
[170] = { 4, 3 }, [171] = { 3, 4 }, [172] = { 1, 2 }, [173] = { 2, 1 },
|
|
[149] = { 2, 3, 5 }, [150] = { 2, 4, 5 }, [151] = { 1, 3, 5 }, [152] = { 1, 4, 5 }, [164] = { 3, 1, 5 }, [165] = { 4, 1, 5 }, [166] = { 4, 2, 5 }, [167] = { 3, 2, 5 },
|
|
[168] = { 2, 3, 6 }, [169] = { 2, 4, 6 }, [174] = { 1, 3, 6 }, [175] = { 1, 4, 6 }, [176] = { 3, 1, 6 }, [177] = { 4, 1, 6 }, [178] = { 4, 2, 6 }, [179] = { 3, 2, 6 },
|
|
[180] = { 2, 3, 1 }, [181] = { 2, 4, 1 }, [182] = { 3, 2, 4 }, [183] = { 3, 1, 4 }, [184] = { 4, 2, 3 }, [185] = { 4, 1, 3 }, [186] = { 1, 3, 2 }, [187] = { 1, 4, 2 },
|
|
[216] = { 3, 2, 4, 1, 3 }, [219] = { 2, 4, 1, 3, 2 }, [218] = { 4, 1, 3, 2, 4 }, [217] = { 1, 3, 2, 4, 1 },
|
|
[212] = { 3, 1, 4, 2, 3 }, [213] = { 1, 4, 2, 3, 1 }, [214] = { 4, 2, 3, 1, 4 }, [215] = { 2, 3, 1, 4, 2 } }
|
|
local MASH_OF = { [17] = { 5 }, [18] = { 5 }, [19] = { 5 }, [27] = { 3, 4 }, [28] = { 3, 4 }, [29] = { 3, 4 }, [30] = { 5, 6 }, [31] = { 5, 6 }, [32] = { 5, 6 },
|
|
[153] = { 5, 7 }, [154] = { 5, 7 }, [155] = { 5, 7 }, [188] = { 6 }, [189] = { 6 }, [190] = { 6 }, [192] = { 7 }, [193] = { 7 }, [194] = { 7 },
|
|
[196] = { 3 }, [197] = { 3 }, [198] = { 3 }, [200] = { 4 }, [201] = { 4 }, [202] = { 4 }, [204] = { 1 }, [205] = { 1 }, [206] = { 1 }, [208] = { 2 }, [209] = { 2 }, [210] = { 2 } }
|
|
local HOLD_OF = { [21] = 1, [22] = 2, [23] = 3, [24] = 4, [25] = 5 }
|
|
local TOGETHER = { [9] = { 1, 3 }, [10] = { 1, 4 }, [11] = { 2, 3 }, [12] = { 2, 4 }, [13] = { 5, 1 }, [14] = { 5, 2 }, [15] = { 5, 3 }, [16] = { 5, 4 },
|
|
[220] = { 6, 1 }, [221] = { 6, 2 }, [222] = { 6, 3 }, [223] = { 6, 4 }, [224] = { 7, 1 }, [225] = { 7, 2 }, [226] = { 7, 3 }, [227] = { 7, 4 },
|
|
[228] = { 5, 1, 3 }, [229] = { 5, 1, 4 }, [230] = { 5, 2, 3 }, [231] = { 5, 2, 4 }, [232] = { 6, 1, 3 }, [233] = { 6, 1, 4 }, [234] = { 6, 2, 3 }, [235] = { 6, 2, 4 },
|
|
[236] = { 7, 1, 3 }, [237] = { 7, 1, 4 }, [238] = { 7, 2, 3 }, [239] = { 7, 2, 4 } }
|
|
local KARIS_LETGO, KARIS_MULTI = 20, 33
|
|
|
|
|
|
-- The switches an input number stands for.
|
|
local function switchesOf(kind)
|
|
if PAIR_OF[kind] then
|
|
return { SWITCH_OF[PAIR_OF[kind][1]], SWITCH_OF[PAIR_OF[kind][2]] }
|
|
end
|
|
|
|
return { SWITCH_OF[kind] }
|
|
end
|
|
|
|
|
|
-- A plan's steps: what to press and let go on which frame.
|
|
local function planPress(steps, frame, switches)
|
|
steps[frame] = steps[frame] or { press = {}, release = {} }
|
|
for _, s in ipairs(switches) do
|
|
table.insert(steps[frame].press, s)
|
|
end
|
|
end
|
|
local function planRelease(steps, frame, switches)
|
|
steps[frame] = steps[frame] or { press = {}, release = {} }
|
|
for _, s in ipairs(switches) do
|
|
table.insert(steps[frame].release, s)
|
|
end
|
|
end
|
|
local function planTap(steps, frame, switches)
|
|
planPress(steps, frame, switches)
|
|
planRelease(steps, frame + 1, switches)
|
|
end
|
|
|
|
|
|
-- A switch a move does not accept, for a wrong answer.
|
|
local function wrongFor(accepted)
|
|
for _, candidate in ipairs({ 2, 1, 3, 4, 6 }) do
|
|
local ok = true
|
|
|
|
for _, a in ipairs(accepted) do
|
|
if a == candidate then
|
|
ok = false
|
|
end
|
|
if PAIR_OF[a] and ((PAIR_OF[a][1] == candidate) or (PAIR_OF[a][2] == candidate)) then
|
|
ok = false
|
|
end
|
|
end
|
|
if ok then
|
|
return { SWITCH_OF[candidate] }
|
|
end
|
|
end
|
|
|
|
return { SWITCH_BUTTON2 }
|
|
end
|
|
|
|
|
|
-- A plan: what to press and let go on which frames, for one window.
|
|
local function planFor(view)
|
|
local w = view.window
|
|
local at = w.from + 3
|
|
local steps = {}
|
|
local wrong = wrongMove(view)
|
|
local kind = w.kind
|
|
|
|
if missedMove(view) then
|
|
-- Left unanswered: the window runs out.
|
|
elseif ((kind >= 1) and (kind <= 7)) or ((kind >= 9) and (kind <= 12)) then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor({ kind, w.alt }))
|
|
else
|
|
planTap(steps, at, switchesOf(kind))
|
|
end
|
|
elseif (kind == KIMMY.MASH) and wrong then
|
|
-- A mash broken by a stray input.
|
|
planTap(steps, at, wrongFor({ w.alt or 5 }))
|
|
elseif kind == KIMMY.COMBO then
|
|
local both = switchesOf(w.alt)
|
|
|
|
for _, s in ipairs(switchesOf(w.alt2)) do
|
|
both[#both + 1] = s
|
|
end
|
|
planTap(steps, at, both)
|
|
elseif kind == KIMMY.HOLD then
|
|
planPress(steps, at, switchesOf(w.alt))
|
|
planRelease(steps, w.to, switchesOf(w.alt))
|
|
elseif kind == KIMMY.LETGO then
|
|
planPress(steps, w.from - 4, { SWITCH_BUTTON1 })
|
|
planRelease(steps, w.from + 2, { SWITCH_BUTTON1 })
|
|
elseif kind == KIMMY.MASH then
|
|
local turn = 0
|
|
|
|
for frame = at, w.to - 2, 2 do
|
|
local which
|
|
|
|
if w.alt == KIMMY.UD then
|
|
which = (turn % 2 == 0) and { SWITCH_UP } or { SWITCH_DOWN }
|
|
elseif w.alt == KIMMY.LR then
|
|
which = (turn % 2 == 0) and { SWITCH_LEFT } or { SWITCH_RIGHT }
|
|
elseif w.alt == KIMMY.B1B2 then
|
|
which = (turn % 2 == 0) and { SWITCH_BUTTON1 } or { SWITCH_BUTTON2 }
|
|
else
|
|
which = switchesOf(w.alt or 5)
|
|
end
|
|
planTap(steps, frame, which)
|
|
turn = turn + 1
|
|
end
|
|
elseif (kind == KIMMY.MULTI) or (kind == KIMMY.LOOP) then
|
|
local start = at + ((kind == KIMMY.MULTI) and (w.alt2 or 0) or 0)
|
|
|
|
for i, step in ipairs(view.multi or {}) do
|
|
planTap(steps, start + 2 * (i - 1), switchesOf(step))
|
|
end
|
|
elseif kind == KIMMY.PATH then
|
|
local p = view.path or {}
|
|
|
|
if wrong then
|
|
planTap(steps, at, wrongFor({ p[1], p[3], p[5], p[7] }))
|
|
elseif p[1] and (p[1] > 0) then
|
|
planTap(steps, at, switchesOf(p[1]))
|
|
end
|
|
elseif kind == KIMMY.YESNO then
|
|
if view.move % 2 == 0 then
|
|
planTap(steps, at, { SWITCH_BUTTON1 })
|
|
end
|
|
elseif kind == KIMMY.TIMED then
|
|
local first = (view.timed or {})[w.alt or view.move]
|
|
|
|
if first and (first[2] + 1 >= w.from) and (first[2] + 1 <= w.to) then
|
|
planTap(steps, first[2] + 1, switchesOf(first[1]))
|
|
end
|
|
elseif kind == KIMMY.ANYTHING then
|
|
planTap(steps, at, { SWITCH_BUTTON1 })
|
|
elseif kind == KIMMY.NOTHING then
|
|
if wrong then
|
|
planTap(steps, at, { SWITCH_BUTTON1 })
|
|
end
|
|
end
|
|
|
|
return { steps = steps, from = w.from - 6, to = w.to + 2 }
|
|
end
|
|
|
|
|
|
-- A map-mode plan: the ancestor's kinds. A single input tapped; MASH (8) tapped every other
|
|
-- frame; an ACT combo (9 to 12) as the button with a direction; a diagonal (13 to 16) as two
|
|
-- directions; SKIP (17) left alone. Every fifth move is answered wrong.
|
|
local RDG_ACT = { [9] = { 5, 1 }, [10] = { 5, 2 }, [11] = { 5, 3 }, [12] = { 5, 4 }, [13] = { 1, 3 }, [14] = { 1, 4 }, [15] = { 2, 3 }, [16] = { 2, 4 } }
|
|
|
|
local function planForRdg(view)
|
|
local w = view.window
|
|
local at = w.from + 3
|
|
local steps = {}
|
|
local wrong = wrongMove(view)
|
|
local kind = w.kind
|
|
|
|
|
|
if missedMove(view) then
|
|
-- Left unanswered: the window runs out.
|
|
elseif (kind >= 1) and (kind <= 7) then
|
|
if wrong then
|
|
planTap(steps, at, { (kind == 1) and SWITCH_DOWN or SWITCH_UP })
|
|
else
|
|
planTap(steps, at, { SWITCH_OF[kind] })
|
|
end
|
|
elseif (kind == (view.mashKind or 8)) and wrong then
|
|
-- A mash broken by a stray direction.
|
|
planTap(steps, at, { SWITCH_UP })
|
|
elseif kind == (view.mashKind or 8) then
|
|
for frame = at, w.to - 2, 2 do
|
|
planTap(steps, frame, { SWITCH_BUTTON1 })
|
|
end
|
|
elseif (view.pairs or RDG_ACT)[kind] and view.zone then
|
|
-- A shot: the pointer into the zone (or well outside it) the frame before the button,
|
|
-- in the raw coordinates the game scales by its ratios.
|
|
local z = view.zone
|
|
local r = view.mouse or { 1, 1, 0, 0 }
|
|
local mx = wrong and (z[3] + 200) or ((z[1] + z[3]) / 2)
|
|
local my = wrong and (z[4] + 200) or ((z[2] + z[4]) / 2)
|
|
|
|
steps[at - 1] = steps[at - 1] or { press = {}, release = {} }
|
|
steps[at - 1].mouse = { math.floor((mx + r[3]) / r[1]), math.floor((my + r[4]) / r[2]) }
|
|
planTap(steps, at, { SWITCH_BUTTON1 })
|
|
elseif (view.pairs or RDG_ACT)[kind] then
|
|
local pair = (view.pairs or RDG_ACT)[kind]
|
|
|
|
if wrong then
|
|
planTap(steps, at, { SWITCH_BUTTON2 })
|
|
else
|
|
planTap(steps, at, { SWITCH_OF[pair[1]], SWITCH_OF[pair[2]] })
|
|
end
|
|
end
|
|
|
|
return { steps = steps, from = w.from - 6, to = w.to + 2 }
|
|
end
|
|
|
|
|
|
-- A KarisFramework plan for a compound move: a hold pressed from three frames into the
|
|
-- window to its end; a let-go held from before the window and released within it; a mash
|
|
-- tapped every other frame (a run, MASH2, and MASH3 alternating their two); a sequence or a
|
|
-- circle a step every other frame; a multi tapped as many times as its row asks; a
|
|
-- combination pressed together. Every fifth move is answered wrong (a stray input, or
|
|
-- nothing for a let-go); every seventh is left unanswered.
|
|
local function planForKaris(view)
|
|
local w = view.window
|
|
local at = w.from + 3
|
|
local steps = {}
|
|
local wrong = wrongMove(view)
|
|
local kind = w.kind
|
|
|
|
local function switches(list)
|
|
local result = {}
|
|
|
|
for _, m in ipairs(list) do
|
|
result[#result + 1] = SWITCH_OF[m]
|
|
end
|
|
|
|
return result
|
|
end
|
|
|
|
if missedMove(view) then
|
|
-- Left unanswered: the window runs out.
|
|
elseif HOLD_OF[kind] then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor({ HOLD_OF[kind] }))
|
|
else
|
|
planPress(steps, at, { SWITCH_OF[HOLD_OF[kind]] })
|
|
planRelease(steps, w.to, { SWITCH_OF[HOLD_OF[kind]] })
|
|
end
|
|
elseif kind == KARIS_LETGO then
|
|
if not wrong then
|
|
planPress(steps, w.from - 4, { SWITCH_BUTTON1 })
|
|
planRelease(steps, w.from + 2, { SWITCH_BUTTON1 })
|
|
end
|
|
elseif MASH_OF[kind] then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor(MASH_OF[kind]))
|
|
else
|
|
local turn = 0
|
|
|
|
for frame = at, w.to - 2, 2 do
|
|
planTap(steps, frame, { SWITCH_OF[MASH_OF[kind][(turn % #MASH_OF[kind]) + 1]] })
|
|
turn = turn + 1
|
|
end
|
|
end
|
|
elseif SEQ_OF[kind] then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor(SEQ_OF[kind]))
|
|
else
|
|
for i, m in ipairs(SEQ_OF[kind]) do
|
|
planTap(steps, at + 2 * (i - 1), { SWITCH_OF[m] })
|
|
end
|
|
end
|
|
elseif kind == KARIS_MULTI then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor({ w.alt }))
|
|
else
|
|
for i = 1, (w.alt2 or 1) do
|
|
planTap(steps, at + 2 * (i - 1), { SWITCH_OF[w.alt] })
|
|
end
|
|
end
|
|
elseif TOGETHER[kind] then
|
|
if wrong then
|
|
planTap(steps, at, wrongFor(TOGETHER[kind]))
|
|
else
|
|
planTap(steps, at, switches(TOGETHER[kind]))
|
|
end
|
|
end
|
|
|
|
return { steps = steps, from = w.from - 6, to = w.to + 2 }
|
|
end
|
|
|
|
|
|
-- A choice: step down to the right option (a wrong one every fifth move), then take it.
|
|
function answerChoice(view, key, w)
|
|
if (view.frame >= w.from + 3) and (view.frame <= w.to) then
|
|
local want = nil
|
|
local wrong = wrongMove(view)
|
|
|
|
for at, index in ipairs(view.order or {}) do
|
|
if view.choices[index] and (view.choices[index].right ~= wrong) and (want == nil or not wrong) then
|
|
want = at
|
|
end
|
|
end
|
|
if want and (view.choice < want) then
|
|
pressed = SWITCH_DOWN
|
|
karisPress(pressed, true)
|
|
elseif want and (view.choice == want) and not answered[key] then
|
|
answered[key] = true
|
|
pressed = SWITCH_BUTTON1
|
|
karisPress(pressed, true)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-- Runs the plan for this frame.
|
|
local function followPlan(frame)
|
|
local step = plan and plan.steps[frame]
|
|
|
|
if step then
|
|
if step.mouse then
|
|
karisMouse(step.mouse[1], step.mouse[2])
|
|
end
|
|
for _, s in ipairs(step.press) do
|
|
if not held[s] then
|
|
held[s] = true
|
|
karisPress(s, true)
|
|
end
|
|
end
|
|
for _, s in ipairs(step.release) do
|
|
if held[s] then
|
|
held[s] = nil
|
|
karisPress(s, false)
|
|
end
|
|
end
|
|
end
|
|
if plan and (frame > plan.to) then
|
|
for s in pairs(held) do
|
|
karisPress(s, false)
|
|
end
|
|
held = {}
|
|
plan = nil
|
|
end
|
|
end
|
|
|
|
|
|
function karisTraceSeek(frame)
|
|
seeks = seeks + 1
|
|
debugPrint(string.format("TRACE seek %d", frame))
|
|
end
|
|
|
|
|
|
-- Presses what the policy says this frame. view: { screen, step, level, scene, move, frame,
|
|
-- window = { from, to, kind, death, alt }, choices = { { right }, ... }, order, choice }.
|
|
function karisDrive(view)
|
|
if pressed then
|
|
karisPress(pressed, false)
|
|
pressed = nil
|
|
end
|
|
local line = string.format("TRACE screen %s step %s level %s scene %s move %s score %s lives %s", tostring(view.screen), tostring(view.step), tostring(view.level), tostring(view.scene), tostring(view.move), tostring(view.score), tostring(view.lives))
|
|
|
|
if line ~= lastLine then
|
|
lastLine = line
|
|
debugPrint(line .. " disc " .. tostring(view.frame))
|
|
end
|
|
-- A coin on the attract loop when the game is not free play, then START once it has begun
|
|
-- playing.
|
|
if (view.screen == 0) and not started and (view.frame >= 150) and (not view.freeplay) and (view.credits == 0) and not coined then
|
|
coined = true
|
|
pressed = SWITCH_COIN1
|
|
karisPress(pressed, true)
|
|
return
|
|
end
|
|
if (view.screen == 0) and not started and (view.frame >= 160) and (view.freeplay or (view.credits > 0)) then
|
|
started = true
|
|
pressed = SWITCH_START1
|
|
karisPress(pressed, true)
|
|
return
|
|
end
|
|
-- Kimmy's menus: the new-game menu (a level the framework never numbered, so nil) takes
|
|
-- the button for NEW GAME; the level select takes the button for the level shown.
|
|
if view.kimmy and started and ((view.screen == nil) or (view.screen == 117)) and (view.frame ~= menuAt) and (view.frames > menuAt + 30) then
|
|
menuAt = view.frames
|
|
pressed = SWITCH_BUTTON1
|
|
karisPress(pressed, true)
|
|
return
|
|
end
|
|
-- The continue screen: taken once.
|
|
if (view.screen == 100) and (view.step == 1) and not continued then
|
|
continued = true
|
|
pressed = SWITCH_START1
|
|
karisPress(pressed, true)
|
|
return
|
|
end
|
|
if (view.screen ~= 103) or (view.window == nil) then
|
|
if plan then
|
|
followPlan(view.frame)
|
|
end
|
|
return
|
|
end
|
|
-- A move is answered once per life: a game that rewinds to the move after a death
|
|
-- (the later map-mode copies) asks it again, and the drive answers it right that time.
|
|
local moveKey = tostring(view.level) .. "/" .. tostring(view.scene) .. "/" .. tostring(view.move)
|
|
local key = moveKey .. "/" .. tostring(view.lives)
|
|
local w = view.window
|
|
|
|
view.retry = (tried[moveKey] ~= nil)
|
|
|
|
if view.kimmy or view.rdg then
|
|
-- A Kimmy or map-mode move: a plan of presses for the window, made when it comes into
|
|
-- view.
|
|
if (view.step == 1) and (plan == nil) and not answered[key] and (view.frame >= w.from - 6) and (view.frame <= w.to) then
|
|
answered[key] = true
|
|
tried[moveKey] = true
|
|
plan = view.rdg and planForRdg(view) or planFor(view)
|
|
elseif view.rdg and (view.step == ((view.timegal and 12) or 11)) and view.choices then
|
|
answerChoice(view, key, w)
|
|
end
|
|
followPlan(view.frame)
|
|
elseif view.step == 1 then
|
|
local kind = w.kind
|
|
|
|
if (kind >= 1) and (kind <= 7) then
|
|
-- Waiting for a single input: answer three frames into the window.
|
|
if (view.frame >= w.from + 3) and (view.frame <= w.to) and not answered[key] then
|
|
answered[key] = true
|
|
tried[moveKey] = true
|
|
if not missedMove(view) then
|
|
local wrong = wrongMove(view)
|
|
local press = wrong and ((kind == 1) and SWITCH_DOWN or SWITCH_UP) or SWITCH_OF[kind]
|
|
|
|
pressed = press
|
|
karisPress(press, true)
|
|
end
|
|
end
|
|
elseif (plan == nil) and not answered[key] and (view.frame >= w.from - 6) and (view.frame <= w.to) and (HOLD_OF[kind] or MASH_OF[kind] or SEQ_OF[kind] or TOGETHER[kind] or (kind == KARIS_LETGO) or (kind == KARIS_MULTI)) then
|
|
-- A compound move: a plan of presses over the window, made as it comes into view.
|
|
answered[key] = true
|
|
tried[moveKey] = true
|
|
plan = planForKaris(view)
|
|
end
|
|
followPlan(view.frame)
|
|
elseif (view.step == 19) and view.choices then
|
|
answerChoice(view, key, w)
|
|
elseif plan then
|
|
-- The move is judged: what the plan still holds is let go, and the rest of it dropped.
|
|
for s in pairs(held) do
|
|
karisPress(s, false)
|
|
end
|
|
held, plan = {}, nil
|
|
end
|
|
end
|
|
|
|
|
|
-- The run is long enough when the game has been played through a continue and out.
|
|
function karisDone(view)
|
|
return continued and (view.screen == 0) and (seeks > 0)
|
|
end
|