1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
local domain = require("clever_f.domain")
local sequence_state = require("clever_f.sequence_state")
local M = {}
local RepeatResolver = {}
M.RepeatResolver = RepeatResolver
M.Decision = {
ACQUIRE = "acquire",
REPEAT = "repeat",
}
M.ACQUIRE = M.Decision.ACQUIRE
M.REPEAT = M.Decision.REPEAT
local resolver_records = setmetatable({}, { __mode = "k" })
local function fail(message, level)
error(message, (level or 1) + 1)
end
local function is_nonnegative_integer(value)
return type(value) == "number"
and value >= 0
and value < math.huge
and value == math.floor(value)
end
local function require_policy(service)
if service ~= nil and (type(service) ~= "table"
or type(service.sample_timeouts) ~= "function")
then
fail("RepeatResolver policy must provide sample_timeouts", 3)
end
return service
end
local resolver_metatable = {
__index = RepeatResolver,
__newindex = function()
fail("RepeatResolver values are immutable", 2)
end,
__tostring = function()
return "repeat-resolver"
end,
__metatable = "clever_f.repeat_resolver.RepeatResolver",
}
function RepeatResolver.new(options)
if RepeatResolver.is(options) then
return options
end
if options == nil then
options = {}
elseif sequence_state.is(options) then
options = { state = options }
elseif type(options) ~= "table" then
fail("RepeatResolver options must be a table", 2)
end
local state = options.state or sequence_state.get()
if not sequence_state.is(state) then
fail("RepeatResolver state must be the plugin-global SequenceState", 2)
end
local resolver = setmetatable({}, resolver_metatable)
resolver_records[resolver] = {
policy = require_policy(options.policy or options.policy_service),
state = state,
}
return resolver
end
function RepeatResolver.is(value)
return type(value) == "table" and resolver_records[value] ~= nil
end
function RepeatResolver:previous_landing(context)
context = domain.ModeContext.from_full_mode(context)
return resolver_records[self].state:get_previous_landing(context)
end
function RepeatResolver:decide(context, current_position, macro_state)
current_position = domain.Position.coerce(current_position)
local landing = self:previous_landing(context)
if landing == nil or not domain.Position.equal(landing, current_position) then
return M.Decision.ACQUIRE
end
if domain.MacroState.new(macro_state).executing then
return M.Decision.ACQUIRE
end
return M.Decision.REPEAT
end
RepeatResolver.eligibility = RepeatResolver.decide
RepeatResolver.resolve_eligibility = RepeatResolver.decide
function RepeatResolver:sample_repeat_timeout_ms()
local service = resolver_records[self].policy
if service == nil then
fail("RepeatResolver requires a policy to sample repeat timeout", 2)
end
local sampled = service:sample_timeouts()
local timeout = type(sampled) == "table" and sampled.repeat_timeout_ms or nil
if not is_nonnegative_integer(timeout) then
fail("repeat_timeout_ms sample must be a nonnegative integer", 2)
end
return timeout
end
RepeatResolver.sample_repeat_timeout = RepeatResolver.sample_repeat_timeout_ms
function M.new(options)
return RepeatResolver.new(options)
end
M.landing = function(context, options)
return RepeatResolver.new(options):previous_landing(context)
end
function M.decide(context, current_position, macro_state, options)
return RepeatResolver.new(options):decide(
context,
current_position,
macro_state
)
end
M.eligibility = M.decide
function M.sample_repeat_timeout_ms(options)
return RepeatResolver.new(options):sample_repeat_timeout_ms()
end
setmetatable(M, {
__call = function(_, options)
return RepeatResolver.new(options)
end,
})
return M
|
