diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c64255..1b12bc0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ står i [docs/BRUGERMANUAL.md](docs/BRUGERMANUAL.md) (dansk) og [docs/USER_MANUA ## 1.62 — Kæder slås selv til +- **1.62.271** Nyt: **AutoDrive skubbes, når den holder ved aflæsningsmålet uden at aflæsse** (in-game 16/10: 'Slurry' holdt ved Liquid Buy Silo igen og igen; stop + start fik den til at aflæsse). Holder et køretøj i AD's aflæsningsopgave ved sidste vejpunkt i 60 s med et læs over AD's aflæsningsgrænse, der ikke falder, og uden forhindring/trafik, stoppes og startes AutoDrive i samme tilstand — højst 2 gange pr. 10 min. Ikke markarbejdets vogne (Courseplay-hjælper), ikke vogne Smart Pickup selv holder, ikke mens AD venter på AutoLoad. Loggen: "… holdt N s ved aflæsningsmålet uden at aflæsse — AutoDrive genstartet". - **1.62.270** Nyt: **balleopsamling tæller modulerne på marken** (brugerønske 16/10: vognene tager kun 1-3 moduler ad gangen, og F39 gik videre med moduler liggende). Efter ballehøst (bomuld) går marken først videre, når ingen løse moduler ligger inden for markgrænsen; ellers sendes en ballesamler ud igen. Efter 5 ture går marken videre alligevel og giver besked om, hvor mange der ligger tilbage. Ingen moduler på marken: trinnet springes over. - **1.62.269** Rettet: **forkert ballesamler til bomuldsmoduler** (in-game 16/10 F39: spillerens Pickup 2017 blev sendt ud, Courseplay fandt intet at samle, og marken gik videre til kultivering med modulerne liggende). På en bomuldsmark skal ballesamleren beviseligt kunne bære modulerne (SQUAREBALE_/ROUNDBALE_COTTON, fx Lizard Module 4). - **1.62.268** Rettet: **bomuldsmoduler sendt til en silo uden ballestation** (in-game 16/10 F39: 'Ballesamler 1' skulle køre modulerne til TMR Silo Farma, der tager bomuld løst, men ingen baller — spillet advarer selv "does not have a BaleUnloadTrigger for fillType 'COTTON'"). Ballemål skal nu have en ballestation til varen (samme regel som spillet); stationer uden springes over, også ved salg. diff --git a/FS25_ADSmartPickup/adSmartPickup.lua b/FS25_ADSmartPickup/adSmartPickup.lua index 05b3b08..6d30220 100644 --- a/FS25_ADSmartPickup/adSmartPickup.lua +++ b/FS25_ADSmartPickup/adSmartPickup.lua @@ -1807,6 +1807,10 @@ function ADSmartPickup:update(dt) end end if ADStuckDiag ~= nil then pcall(ADStuckDiag.tick, dt) end + if ADUnloadKick ~= nil then + local okKick, errKick = pcall(ADUnloadKick.tick, getAutoDriveEnv(), dt) + if not okKick then Logging.warning(ADSmartPickup.LOG_PREFIX .. "aflæsnings-skub fejlede: %s", tostring(errKick)) end + end if ADRunsController ~= nil and ADRunsController.adoptLoadedThrottled ~= nil then pcall(ADRunsController.adoptLoadedThrottled, getAutoDriveEnv(), dt) end diff --git a/FS25_ADSmartPickup/adUnloadKick.lua b/FS25_ADSmartPickup/adUnloadKick.lua new file mode 100644 index 0000000..92ed5da --- /dev/null +++ b/FS25_ADSmartPickup/adUnloadKick.lua @@ -0,0 +1,137 @@ +-- 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" + +local watch = setmetatable({}, {__mode = "k"}) -- [vehicle] = {stillMs, startFill} +local kicks = setmetatable({}, {__mode = "k"}) -- [vehicle] = {times...} +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) + if s.filledToUnload == false 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 + +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 = ad.drivePathModule, ad.collisionDetectionModule + local wayPoints, current = nil, nil + if dpm ~= nil and dpm.getWayPoints ~= nil then wayPoints, current = dpm:getWayPoints() end + -- 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 = wayPoints ~= nil and current ~= nil and #wayPoints > 0 and current >= #wayPoints, + 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 + +-- Stop og start i samme tilstand, som AD's HUD (ADInputManager:input_start_stop -> mode:start). +local function kick(AD, vehicle) + 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 + 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) + s.startFill, s.stillMs = w.startFill, w.stillMs + s.recentKicks = recentKicks(vehicle) + if ADUnloadKick.shouldKick(s) then + local ok, err = pcall(kick, AD, vehicle) + 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 diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index 326f633..8931912 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.270.0 + 1.62.271.0 <en>AD Smart Pickup</en> @@ -16,6 +16,7 @@ +