168 lines
7.3 KiB
Lua
168 lines
7.3 KiB
Lua
-- AD Park Guard
|
|
-- AutoDrive gemmer køretøjers og redskabers parkering som markør-NUMMER (advd.parkDestination). Slettes en markør
|
|
-- (også når spilleren sletter vejpunkter med en markør på), nulstiller AD parkeringer på den markør og trækker 1 fra
|
|
-- alle højere numre (ADGraphManager:removeMapMarker). Oprettes markøren igen med samme navn, peger parkeringerne
|
|
-- forkert (in-game 8/10 savegame4: bagklipperen blev sat af ved "P Front Mower", T7's plads blev "Connect P Rear
|
|
-- Mower"). Vagten husker hver parkering ved NAVN og retter nummeret, når listen ændres: øjebliksbilledet fryses ved
|
|
-- sletning, og parkeringer rettes til markøren med det huskede navn, så snart den findes (igen). Spillerens eget
|
|
-- valg af parkering (AD's "tildel parkering") opdaterer billedet med det samme.
|
|
-- Ren logik testes med luajit; spil-adapteren nederst.
|
|
|
|
ADParkGuard = {}
|
|
ADParkGuard.LOG_PREFIX = "ADSmartPickup: parkeringsvagt: "
|
|
ADParkGuard.SNAPSHOT_MS = 5000 -- så tit billedet opdateres, når intet er frosset
|
|
ADParkGuard.PENDING_MS = 10 * 60 * 1000 -- så længe ventes på at en slettet markør oprettes igen
|
|
|
|
local snapshot = setmetatable({}, {__mode = "k"}) -- køretøj -> markørnavn
|
|
local frozenAt = nil
|
|
local lastSnapshot = nil
|
|
|
|
-- ---- ren logik ----
|
|
|
|
-- entries = {{key, index}}; nameOf(index) -> navn | nil. -> {[key] = navn} (kun gyldige parkeringer)
|
|
function ADParkGuard.capture(entries, nameOf)
|
|
local result = {}
|
|
for _, entry in ipairs(entries) do
|
|
local name = type(entry.index) == "number" and entry.index >= 1 and nameOf(entry.index) or nil
|
|
if name ~= nil then result[entry.key] = name end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- remembered = {[key] = navn}; entries = {{key, index}}; nameOf(index), indexOf(navn) -> nummer | nil.
|
|
-- -> rettelser {{key, from, to, name}}, ventende (antal huskede navne der ikke findes som markør lige nu)
|
|
function ADParkGuard.repairs(remembered, entries, nameOf, indexOf)
|
|
local fixes, waiting = {}, 0
|
|
for _, entry in ipairs(entries) do
|
|
local name = remembered[entry.key]
|
|
if name ~= nil then
|
|
local current = type(entry.index) == "number" and entry.index >= 1 and nameOf(entry.index) or nil
|
|
if current ~= name then
|
|
local target = indexOf(name)
|
|
if target ~= nil then
|
|
table.insert(fixes, {key = entry.key, from = entry.index, to = target, name = name})
|
|
else
|
|
waiting = waiting + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return fixes, waiting
|
|
end
|
|
|
|
-- Skal billedet stadig være frosset? (ventende rettelser, og ikke for længe siden)
|
|
function ADParkGuard.stayFrozen(frozenSince, nowMs, waiting)
|
|
if frozenSince == nil then return false end
|
|
return waiting > 0 and nowMs - frozenSince < ADParkGuard.PENDING_MS
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local function now()
|
|
if g_currentMission ~= nil and type(g_currentMission.time) == "number" then return g_currentMission.time end
|
|
return os.clock() * 1000
|
|
end
|
|
|
|
local function label(vehicle)
|
|
return tostring(ADRuns ~= nil and ADRuns.vehicleLabel(vehicle) or (vehicle.getName ~= nil and vehicle:getName()) or "?")
|
|
end
|
|
|
|
local function entries()
|
|
local list = {}
|
|
if g_currentMission == nil or g_currentMission.vehicleSystem == nil then return list end
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
if vehicle.advd ~= nil then table.insert(list, {key = vehicle, index = vehicle.advd.parkDestination}) end
|
|
end
|
|
return list
|
|
end
|
|
|
|
local function lookups(graph)
|
|
local markers = graph:getMapMarkers() or {}
|
|
local nameOf = function(index) local marker = markers[index] return marker ~= nil and marker.name or nil end
|
|
local indexOf = function(name)
|
|
for index, marker in ipairs(markers) do
|
|
if marker.name == name then return index end
|
|
end
|
|
return nil
|
|
end
|
|
return nameOf, indexOf
|
|
end
|
|
|
|
local function refresh(graph, only)
|
|
local nameOf = lookups(graph)
|
|
local list = entries()
|
|
if only ~= nil then
|
|
local filtered = {}
|
|
for _, entry in ipairs(list) do if only[entry.key] then table.insert(filtered, entry) end end
|
|
list = filtered
|
|
end
|
|
if only == nil then
|
|
-- helt nyt billede: køretøjer hvis parkering er slettet/ugyldig må ikke beholde et gammelt navn
|
|
for key in pairs(snapshot) do snapshot[key] = nil end
|
|
end
|
|
for key, name in pairs(ADParkGuard.capture(list, nameOf)) do snapshot[key] = name end
|
|
end
|
|
|
|
function ADParkGuard.install(adEnv)
|
|
local graph = adEnv ~= nil and adEnv.ADGraphManager or nil
|
|
if graph == nil or graph.removeMapMarker == nil or graph.spuParkGuard then return false end
|
|
graph.spuParkGuard = true
|
|
refresh(graph)
|
|
lastSnapshot = now()
|
|
local originalRemove = graph.removeMapMarker
|
|
graph.removeMapMarker = function(self, ...)
|
|
-- billedet fryses FØR AD nulstiller/trækker fra: det er de rigtige navne
|
|
if frozenAt == nil then pcall(refresh, graph) end
|
|
frozenAt = now()
|
|
return originalRemove(self, ...)
|
|
end
|
|
-- spillerens eget valg af parkering: opdatér med det samme (også mens billedet er frosset)
|
|
local autoDrive = adEnv.AutoDrive
|
|
if autoDrive ~= nil and autoDrive.setActualParkDestination ~= nil then
|
|
local originalSet = autoDrive.setActualParkDestination
|
|
autoDrive.setActualParkDestination = function(vehicle, ...)
|
|
local result = originalSet(vehicle, ...)
|
|
pcall(function()
|
|
local units = {}
|
|
-- AD sætter parkeringen på det valgte redskab (getSelectedWorkTool) — alle redskaber og vogne tages med
|
|
for _, unit in ipairs(autoDrive.getAllUnits ~= nil and autoDrive.getAllUnits(vehicle) or {}) do units[unit] = true end
|
|
for _, unit in ipairs(autoDrive.getAllImplements ~= nil and autoDrive.getAllImplements(vehicle, true) or {}) do units[unit] = true end
|
|
units[vehicle] = true
|
|
for unit in pairs(units) do snapshot[unit] = nil end
|
|
refresh(graph, units)
|
|
end)
|
|
return result
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
function ADParkGuard.tick(adEnv)
|
|
local graph = adEnv ~= nil and adEnv.ADGraphManager or nil
|
|
if graph == nil or not graph.spuParkGuard then return end
|
|
local t = now()
|
|
if frozenAt == nil then
|
|
if lastSnapshot == nil or t - lastSnapshot >= ADParkGuard.SNAPSHOT_MS then
|
|
lastSnapshot = t
|
|
refresh(graph)
|
|
end
|
|
return
|
|
end
|
|
local nameOf, indexOf = lookups(graph)
|
|
local fixes, waiting = ADParkGuard.repairs(snapshot, entries(), nameOf, indexOf)
|
|
for _, fix in ipairs(fixes) do
|
|
local vehicle = fix.key
|
|
local ok = pcall(vehicle.advd.setParkDestination, vehicle.advd, vehicle, fix.to, false)
|
|
Logging.info(ADParkGuard.LOG_PREFIX .. "'%s' parkering rettet til '%s' (AD havde nr. %s, nu nr. %d)%s", label(vehicle), fix.name,
|
|
tostring(fix.from), fix.to, ok and "" or " — FEJLEDE")
|
|
end
|
|
if not ADParkGuard.stayFrozen(frozenAt, t, waiting) then
|
|
if waiting > 0 then
|
|
Logging.info(ADParkGuard.LOG_PREFIX .. "%d parkering(er) peger på en slettet markør, der ikke er oprettet igen", waiting)
|
|
end
|
|
frozenAt = nil
|
|
lastSnapshot = t
|
|
refresh(graph)
|
|
end
|
|
end
|