198 lines
11 KiB
Lua
198 lines
11 KiB
Lua
-- AD Unload Kick
|
|
-- AutoDrive holder af og til ved aflæsningsmålet uden at aflæsse: sidste vejpunkt, "UnloadAtDestinationTask",
|
|
-- ingen forhindring/trafik, læsset falder ikke. Stop + start i samme tilstand (som HUD'ens knap) får den til at
|
|
-- finde triggeren (in-game 16/10: 'Slurry' ved Liquid Buy Silo — spilleren stoppede og startede, så aflæssede den).
|
|
|
|
ADUnloadKick = {}
|
|
|
|
ADUnloadKick.CHECK_INTERVAL_MS = 10000
|
|
ADUnloadKick.STILL_MS = 60000 -- så længe ved målet uden at aflæsse før et skub
|
|
ADUnloadKick.MAX_KICKS = 2 -- skub pr. vindue
|
|
ADUnloadKick.WINDOW_MS = 10 * 60 * 1000
|
|
ADUnloadKick.STILL_SPEED = 0.00028 -- som AD's egen stoppedTimer (m/ms)
|
|
ADUnloadKick.UNLOAD_TASK = "UnloadAtDestinationTask"
|
|
ADUnloadKick.NEAR_END_WP = 2 -- AD-stoppet så mange vejpunkter før enden tæller som ved målet
|
|
|
|
local watch = setmetatable({}, {__mode = "k"}) -- [vehicle] = {stillMs, startFill}
|
|
local kicks = setmetatable({}, {__mode = "k"}) -- [vehicle] = {times...}
|
|
local told = setmetatable({}, {__mode = "k"}) -- [vehicle] = true: spilleren har fået besked om, at skub ikke hjalp
|
|
local timerMs = 0
|
|
local nowMs = 0
|
|
|
|
-- Ren: skal køretøjet have et skub? s = {held, helper, alWait, filledToUnload, unloading, atEnd, paused, obstacle, traffic, fill, startFill, stillMs,
|
|
-- recentKicks}
|
|
function ADUnloadKick.shouldKick(s)
|
|
if s.held or s.helper or s.alWait or not s.unloading or not s.atEnd or s.paused or s.obstacle or s.traffic then
|
|
return false
|
|
end
|
|
if (s.fill or 0) <= 0 then return false end
|
|
-- under AD's aflæsningsgrænse: en genstart sender vognen tilbage efter mere i stedet for at aflæsse (review) —
|
|
-- undtagen moddens egne flow-vogne (managed): dem sætter kick() midlertidigt grænsen til 0 % for (in-game 17/10:
|
|
-- 'Chicken Food' med 500.000 l hvede i en 1.000.000 l-vogn stod 9 min ved hønsehuset, canDischargeToObject=false)
|
|
if s.filledToUnload == false and not s.managed then return false end
|
|
if s.startFill ~= nil and (s.fill or 0) < s.startFill - 1 then return false end -- aflæsser faktisk
|
|
if (s.stillMs or 0) < ADUnloadKick.STILL_MS then return false end
|
|
return (s.recentKicks or 0) < ADUnloadKick.MAX_KICKS
|
|
end
|
|
|
|
-- Ren: står vognen "ved målet"? s = {current, count, stopping, tipping}. Sidste punkt; AD stoppet selv tæt på enden;
|
|
-- eller AD stoppet selv for at tippe ved en trigger undervejs (in-game 19/10 10:10: 'Chicken Food' stod 15 min ved
|
|
-- vejpunkt 2 af 5 med tipper=true og 259.388 l hvede, der ikke faldt — før talte kun de sidste 2 punkter)
|
|
-- reached = AD's målNået (ruten er så ryddet: wp=0/nil — in-game 19/10 'Sheep Food' ved Sheep 1 Food blev aldrig skubbet)
|
|
function ADUnloadKick.isAtEnd(s)
|
|
if s.reached == true then return true end
|
|
if s.current == nil or (s.count or 0) <= 0 then return false end
|
|
if s.current >= s.count then return true end
|
|
return s.stopping == true and (s.current >= s.count - ADUnloadKick.NEAR_END_WP or s.tipping == true)
|
|
end
|
|
|
|
local function name(vehicle)
|
|
local ok, text = pcall(vehicle.getName, vehicle)
|
|
return ok and tostring(text) or "?"
|
|
end
|
|
|
|
-- -> fyldniveau, AD's "fyldt nok til at aflæsse" (nil = ukendt)
|
|
local function fillOf(AD, vehicle)
|
|
local ok, level, _, filledToUnload = pcall(function()
|
|
return AD.getAllFillLevels(AD.getAllUnits(vehicle))
|
|
end)
|
|
if not ok then return 0, nil end
|
|
return tonumber(level) or 0, filledToUnload
|
|
end
|
|
|
|
local function stateOf(vehicle)
|
|
local ad = vehicle.ad
|
|
local task = ad.taskModule ~= nil and ad.taskModule.activeTask or nil
|
|
local dpm, cdm, sdm = ad.drivePathModule, ad.collisionDetectionModule, ad.specialDrivingModule
|
|
local wayPoints, current = nil, nil
|
|
if dpm ~= nil and dpm.getWayPoints ~= nil then wayPoints, current = dpm:getWayPoints() end
|
|
-- AD stopper selv vognen inden sidste punkt, når triggeren er inden for rækkevidde (in-game 16/10: 'Slurry'
|
|
-- holdt 820 s ved wp 2/3 med "stopper=true") — det tæller som ved målet
|
|
local stopping = sdm ~= nil and sdm.isStoppingVehicle ~= nil and sdm:isStoppingVehicle() == true
|
|
local count = wayPoints ~= nil and #wayPoints or 0
|
|
-- Smart Pickup holder den selv (Wait-punkt / udkørsel venter på plads): ikke et skub
|
|
local held = (ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil)
|
|
or (ADOutbound ~= nil and ADOutbound.getHoldFor ~= nil and ADOutbound.getHoldFor(vehicle) ~= nil)
|
|
local stateModule = ad.stateModule
|
|
return {
|
|
held = held,
|
|
-- markarbejdets vogne (AD med Courseplay som hjælper): stop giver vognen til Courseplay — dem styrer moden selv
|
|
helper = stateModule.getStartHelper ~= nil and stateModule:getStartHelper() == true,
|
|
-- AD venter selv på AutoLoad-/balleaflæsning
|
|
alWait = task ~= nil and task.state ~= nil and task.state == 3,
|
|
unloading = task ~= nil and task.taskType == ADUnloadKick.UNLOAD_TASK,
|
|
atEnd = ADUnloadKick.isAtEnd({current = current, count = count, stopping = stopping,
|
|
reached = dpm ~= nil and dpm.isTargetReached ~= nil and dpm:isTargetReached() == true,
|
|
tipping = ad.trailerModule ~= nil and ad.trailerModule.isUnloading == true}),
|
|
paused = dpm ~= nil and dpm.isPaused == true,
|
|
obstacle = cdm ~= nil and cdm.detectedObstable == true,
|
|
traffic = cdm ~= nil and cdm.trafficVehicle ~= nil,
|
|
}
|
|
end
|
|
|
|
local function recentKicks(vehicle)
|
|
local list, kept = kicks[vehicle] or {}, {}
|
|
for _, at in ipairs(list) do
|
|
if nowMs - at < ADUnloadKick.WINDOW_MS then table.insert(kept, at) end
|
|
end
|
|
kicks[vehicle] = kept
|
|
return #kept
|
|
end
|
|
|
|
-- Delvist læs (under AD's "Unload fill level"): sæt grænsen til 0 % lige før genstarten, så AD's hent/aflever-tilstand
|
|
-- vælger AFLEVER og ikke kører tilbage efter mere. Gendannes ved næste tjek (RESTORE_AFTER_MS).
|
|
ADUnloadKick.RESTORE_AFTER_MS = 5000
|
|
local restorePending = setmetatable({}, {__mode = "k"}) -- vehicle -> {current, new, at}
|
|
local function lowerUnloadFillLevel(vehicle)
|
|
local setting = vehicle.ad.settings ~= nil and vehicle.ad.settings.unloadFillLevel or nil
|
|
if setting == nil or restorePending[vehicle] ~= nil then return false end
|
|
restorePending[vehicle] = {current = setting.current, new = setting.new, at = nowMs}
|
|
setting.current, setting.new = 1, 1 -- indeks 1 = 0 %
|
|
return true
|
|
end
|
|
function ADUnloadKick.restoreSettings()
|
|
for vehicle, saved in pairs(restorePending) do
|
|
if nowMs - saved.at >= ADUnloadKick.RESTORE_AFTER_MS then
|
|
local setting = vehicle.ad ~= nil and vehicle.ad.settings ~= nil and vehicle.ad.settings.unloadFillLevel or nil
|
|
if setting ~= nil then setting.current, setting.new = saved.current, saved.new end
|
|
restorePending[vehicle] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Stop og start i samme tilstand, som AD's HUD (ADInputManager:input_start_stop -> mode:start).
|
|
local function kick(AD, vehicle, partial)
|
|
if partial then lowerUnloadFillLevel(vehicle) end
|
|
vehicle:stopAutoDrive()
|
|
local stateModule = vehicle.ad.stateModule
|
|
local mode = stateModule.getCurrentMode ~= nil and stateModule:getCurrentMode() or nil
|
|
if mode ~= nil and mode.start ~= nil then
|
|
mode:start(AD.USER_PLAYER or 1)
|
|
else
|
|
vehicle:startAutoDrive()
|
|
end
|
|
if not stateModule:isActive() then error("AutoDrive startede ikke igen — start den selv") end
|
|
end
|
|
|
|
-- adEnv = AutoDrive-miljøet (ADSmartPickup's getAutoDriveEnv): AutoDrive er ikke global i vores mod
|
|
function ADUnloadKick.tick(adEnv, dt)
|
|
timerMs = timerMs + (dt or 0)
|
|
nowMs = nowMs + (dt or 0)
|
|
local AD = adEnv ~= nil and adEnv.AutoDrive or nil
|
|
if timerMs < ADUnloadKick.CHECK_INTERVAL_MS or AD == nil then return end
|
|
local elapsed = timerMs
|
|
timerMs = 0
|
|
ADUnloadKick.restoreSettings()
|
|
local vehicles = g_currentMission ~= nil and g_currentMission.vehicleSystem ~= nil and g_currentMission.vehicleSystem.vehicles or {}
|
|
for _, vehicle in pairs(vehicles) do
|
|
local ad = vehicle.ad
|
|
local active = ad ~= nil and ad.stateModule ~= nil and ad.stateModule:isActive()
|
|
and (vehicle.lastSpeedReal or 0) < ADUnloadKick.STILL_SPEED
|
|
local okState, s = false, nil
|
|
if active then okState, s = pcall(stateOf, vehicle) end
|
|
if not okState or s == nil or not s.unloading or not s.atEnd then
|
|
watch[vehicle] = nil
|
|
else
|
|
local w = watch[vehicle]
|
|
if w == nil then
|
|
-- første gang set ved målet: tæl fra nu (ikke tiden før)
|
|
w = {stillMs = 0, startFill = (fillOf(AD, vehicle))}
|
|
watch[vehicle] = w
|
|
else
|
|
w.stillMs = w.stillMs + elapsed
|
|
end
|
|
s.fill, s.filledToUnload = fillOf(AD, vehicle)
|
|
-- læsset falder: tæl forfra fra det nye niveau (review 19/10: et stop efter en delvis tømning blev aldrig skubbet)
|
|
if s.fill < w.startFill - 1 then w.startFill, w.stillMs = s.fill, 0 end
|
|
s.startFill, s.stillMs = w.startFill, w.stillMs
|
|
s.recentKicks = recentKicks(vehicle)
|
|
-- moddens egen flow-vogn: målet er valgt af moden, og den husker det efter genstarten
|
|
s.managed = ADRunsController ~= nil and ADRunsController.getActiveRunForVehicle ~= nil
|
|
and ADRunsController.getActiveRunForVehicle(vehicle) ~= nil
|
|
-- skub opbrugt og stadig intet: spilleren får besked én gang (review 19/10: ellers to genstarte hvert 10. min for evigt)
|
|
if s.recentKicks >= ADUnloadKick.MAX_KICKS and ADUnloadKick.shouldKick({unloading = true, atEnd = true, fill = s.fill,
|
|
filledToUnload = s.filledToUnload, managed = s.managed, startFill = s.startFill, stillMs = s.stillMs, recentKicks = 0})
|
|
and not told[vehicle] then
|
|
told[vehicle] = true
|
|
local text = string.format("'%s' står ved aflæsningen med %.0f l, der ikke kommer af — tjek målet/vognen", tostring(ADRuns ~= nil and ADRuns.vehicleLabel(vehicle) or name(vehicle)), s.fill)
|
|
Logging.info("ADSmartPickup: %s (AutoDrive genstartet %d gange uden virkning)", text, s.recentKicks)
|
|
if ADFieldJobs ~= nil and ADFieldJobs.notify ~= nil then pcall(ADFieldJobs.notify, text, true) end
|
|
elseif s.recentKicks < ADUnloadKick.MAX_KICKS then
|
|
told[vehicle] = nil
|
|
end
|
|
if ADUnloadKick.shouldKick(s) then
|
|
local ok, err = pcall(kick, AD, vehicle, s.filledToUnload == false)
|
|
table.insert(kicks[vehicle], nowMs)
|
|
watch[vehicle] = nil
|
|
if ok then
|
|
Logging.info("ADSmartPickup: '%s' holdt %d s ved aflæsningsmålet uden at aflæsse (%.0f l) — AutoDrive genstartet",
|
|
name(vehicle), math.floor(s.stillMs / 1000), s.fill)
|
|
else
|
|
Logging.warning("ADSmartPickup: '%s' holdt ved aflæsningsmålet uden at aflæsse — genstart fejlede: %s",
|
|
name(vehicle), tostring(err))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|