Files
fs25-adsmartpickup/FS25_ADSmartPickup/adUnloadRoll.lua
T

246 lines
13 KiB
Lua
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
-- AD Unload Roll
-- AutoDrive standser aflæsningen, når traktorens NÆSE når markøren. Med et langt vogntog (724 Vario + 2×
-- Carat 140 TD, in-game 6/10 ved Silo 4) står den fulde bageste vogns tippested så et par meter FØR risten,
-- og AD venter for evigt ("Wait at unload point until unloaded somehow"). Ligger en trigger, der tager varen,
-- lige foran en fuld vogns tippested, ruller traktoren her langsomt frem, til AD selv begynder at tippe.
-- Markørerne må ikke flyttes i stedet: vejen svinger ofte lige efter siloen, og så kender moden ikke længere
-- siloen ved markøren (MAX_TRIGGER_LATERAL_OFFSET).
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
local function logInfo(...) return (ADLog or Logging).info(...) end
ADUnloadRoll = {}
ADUnloadRoll.LOG_PREFIX = "ADSmartPickup: aflæsning: "
-- m: tættere på er tippestedet allerede over triggeren. 0,1 (før 0,3): 'Unloader F7' holdt med triggeren 0,3 m foran,
-- kunne ikke tippe og blev ikke rullet (in-game 19/10 15:14)
ADUnloadRoll.MIN_AHEAD = 0.1
-- m: længere frem rulles ikke — så er det ikke markørens trigger. 12 (før 8): lange læssevogne (BOSS ALPIN 251) stod 8,1 m før
-- fårestaldens trug og blev holdende (in-game 19/10 01:29 'Sheep Food')
ADUnloadRoll.MAX_AHEAD = 12
ADUnloadRoll.MAX_LATERAL = 2 -- m til siden: vognen følger sporet lige frem
ADUnloadRoll.OVERSHOOT = 1.5 -- m forbi planen uden at AD tipper -> giv op
ADUnloadRoll.TIMEOUT_MS = 25000 -- 12 m ved 3 km/t + acceleration (review 19/10)
ADUnloadRoll.SETTLE_MS = 1500 -- målet nået så længe, uden at AD tipper, før der rulles
ADUnloadRoll.ROLL_SPEED = 3 -- km/t
ADUnloadRoll.MIN_FILL = 100 -- l: mindre end det tæller vognen som tom
ADUnloadRoll.SEARCH_RADIUS = 14 -- m fra tippestedet til triggere der overvejes
-- ---- ren logik ----
-- offsets = {{x, z}}: triggere set fra en fuld vogns tippested i traktorens rum (z > 0 = foran).
-- -> meter der skal rulles (nærmeste brugbare), eller nil
function ADUnloadRoll.plan(offsets)
local best = nil
for _, offset in ipairs(offsets or {}) do
if offset.z > ADUnloadRoll.MIN_AHEAD and offset.z <= ADUnloadRoll.MAX_AHEAD
and math.abs(offset.x) <= ADUnloadRoll.MAX_LATERAL and (best == nil or offset.z < best) then
best = offset.z
end
end
return best
end
-- s = {unloading, traveled, planned, elapsedMs} -> "done" | "drive" | "giveUp"
function ADUnloadRoll.step(s)
if s.unloading then return "done" end
if (s.elapsedMs or 0) >= ADUnloadRoll.TIMEOUT_MS then return "giveUp" end
if s.traveled > s.planned + ADUnloadRoll.OVERSHOOT then return "giveUp" end
return "drive"
end
-- ---- spil ----
local rolls = setmetatable({}, {__mode = "k"}) -- køretøj -> {task, start, planned, elapsedMs}
local tried = setmetatable({}, {__mode = "k"}) -- aflæsningsopgave -> true (kun ét forsøg pr. tur)
local settle = setmetatable({}, {__mode = "k"}) -- aflæsningsopgave -> ms med målet nået uden tipning
local function vehicleName(vehicle)
if ADRuns ~= nil and ADRuns.vehicleLabel ~= nil then return tostring(ADRuns.vehicleLabel(vehicle)) end
return vehicle ~= nil and vehicle.getName ~= nil and vehicle:getName() or "?"
end
local function triggerAccepts(trigger, fillType)
if trigger.getIsFillTypeAllowed ~= nil then
local ok, allowed = pcall(trigger.getIsFillTypeAllowed, trigger, fillType)
if ok then return allowed == true end
end
return trigger.fillTypes == nil or trigger.fillTypes[fillType] == true
end
-- Alle aflæsningstriggere moden må bruge: siloers/fabrikkers (storageSystem) og staldenes fodertrug — trugene ligger
-- ikke i storageSystem, men i staldens spec_husbandryFood.feedingTroughs (in-game 19/10: 'Sheep Food' stod 8 m før
-- fårestaldens trug, og fremrulningen så slet ikke truget). Stalden skal være gårdens efter samme regel som siloerne
-- (adgangstjek, ellers ADPrices.isOwnedBy — kortanlæg med ejer 15), og et fuldt trug tæller ikke (review 19/10).
-- fillType: kun trug med plads til varen (nil = alle). -> {trigger, ...}
local function penUsable(farmId, placeable)
local access = g_currentMission ~= nil and g_currentMission.accessHandler or nil
if access ~= nil and access:canFarmAccess(farmId, placeable) then return true end
return ADPrices ~= nil and ADPrices.isOwnedBy ~= nil and ADPrices.isOwnedBy(placeable, farmId) == true
end
local function troughHasRoom(trigger, fillType)
local target = trigger.target
if fillType == nil or target == nil or target.getFreeCapacity == nil then return true end
local ok, free = pcall(target.getFreeCapacity, target, fillType)
return not ok or free == nil or free > 0
end
function ADUnloadRoll.candidateTriggers(farmId, fillType)
local list = {}
local storage = g_currentMission ~= nil and g_currentMission.storageSystem or nil
for _, station in pairs(storage ~= nil and storage:getUnloadingStations() or {}) do
if ADSmartPickup == nil or ADSmartPickup.canUseStation == nil or ADSmartPickup.canUseStation(farmId, station) then
for _, trigger in pairs(station.unloadTriggers or {}) do table.insert(list, trigger) end
end
end
local placeables = g_currentMission ~= nil and g_currentMission.placeableSystem ~= nil and g_currentMission.placeableSystem.placeables or {}
for _, placeable in ipairs(placeables) do
local food = placeable.spec_husbandryFood
if farmId ~= nil and food ~= nil and food.feedingTroughs ~= nil and penUsable(farmId, placeable) then
for _, trigger in ipairs(food.feedingTroughs) do
if troughHasRoom(trigger, fillType) then table.insert(list, trigger) end
end
end
end
return list
end
-- Triggere foran de fulde vognes tippesteder, i traktorens rum. -> {{x, z}}
local function offsetsFor(adEnv, vehicle)
local offsets = {}
if vehicle.rootNode == nil then return offsets end
local farmId = ADSmartPickup ~= nil and ADSmartPickup.getFarmId ~= nil and ADSmartPickup.getFarmId(vehicle)
or (vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() or nil)
for _, unit in ipairs(adEnv.AutoDrive.getAllDischargeableUnits(vehicle) or {}) do
local object = unit.object
local level = object ~= nil and object.getFillUnitFillLevel ~= nil and object:getFillUnitFillLevel(unit.fillUnitIndex) or 0
local dischargeNode = level >= ADUnloadRoll.MIN_FILL and object.getCurrentDischargeNode ~= nil and object:getCurrentDischargeNode() or nil
if dischargeNode ~= nil and dischargeNode.node ~= nil then
local fillType = object:getFillUnitFillType(unit.fillUnitIndex)
local nx, _, nz = getWorldTranslation(dischargeNode.node)
for _, trigger in ipairs(ADUnloadRoll.candidateTriggers(farmId, fillType)) do
local node = trigger.exactFillRootNode
if node ~= nil and triggerAccepts(trigger, fillType) then
local tx, _, tz = getWorldTranslation(node)
if math.sqrt((tx - nx) ^ 2 + (tz - nz) ^ 2) <= ADUnloadRoll.SEARCH_RADIUS then
local x, _, z = worldDirectionToLocal(vehicle.rootNode, tx - nx, 0, tz - nz)
table.insert(offsets, {x = x, z = z})
end
end
end
end
end
return offsets
end
local function isAdUnloading(vehicle)
local trailerModule = vehicle.ad ~= nil and vehicle.ad.trailerModule or nil
if trailerModule == nil then return false end
return trailerModule.isUnloading == true or (trailerModule.isActiveAtTrigger ~= nil and trailerModule:isActiveAtTrigger() == true)
end
local function positionOf(vehicle)
local x, _, z = getWorldTranslation(vehicle.rootNode)
return {x = x, z = z}
end
-- Skal opgaven rulle frem nu? -> planlagt afstand eller nil
local function shouldRoll(adEnv, task, dt)
local vehicle = task.vehicle
if tried[task] or task.isContinued or task.state ~= (task.STATE_DRIVING or 2) then return nil end
if vehicle.ad.drivePathModule == nil or not vehicle.ad.drivePathModule:isTargetReached() or isAdUnloading(vehicle) then
settle[task] = 0
return nil
end
if ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil then return nil end
settle[task] = (settle[task] or 0) + dt
if settle[task] < ADUnloadRoll.SETTLE_MS then return nil end
tried[task] = true
-- fuldt mål: Wait-logikken tager sig af det — at rulle frem hjælper ikke
if ADUnloadWait ~= nil and ADUnloadWait.getRestLoad ~= nil and ADSmartPickup ~= nil and ADSmartPickup.getTargetFreeCapacity ~= nil then
local fillType = ADUnloadWait.getRestLoad(adEnv, vehicle)
local free = fillType ~= nil and ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType) or nil
if free ~= nil and free < ADUnloadRoll.MIN_FILL then return nil end
end
local offsets = offsetsFor(adEnv, vehicle)
local planned = ADUnloadRoll.plan(offsets)
if planned == nil and offsets ~= nil and offsets[1] ~= nil then
-- diagnose: hvorfor rulles der ikke (nærmeste trigger set fra tippestedet)
local near = nil
for _, o in ipairs(offsets) do
if near == nil or o.x * o.x + o.z * o.z < near.x * near.x + near.z * near.z then near = o end
end
logInfo("ADSmartPickup: aflæsning: '%s' ruller ikke frem — nærmeste trigger %.1f m %s, %.1f m til siden (grænser %.1f-%.0f m frem, %.0f m til siden)",
tostring(vehicleName(vehicle)), math.abs(near.z), near.z >= 0 and "foran" or "bagved", math.abs(near.x),
ADUnloadRoll.MIN_AHEAD, ADUnloadRoll.MAX_AHEAD, ADUnloadRoll.MAX_LATERAL)
end
return planned
end
local function stop(vehicle, dt)
local sdm = vehicle.ad.specialDrivingModule
if sdm ~= nil and sdm.stopVehicle ~= nil then
sdm:stopVehicle()
if sdm.update ~= nil then sdm:update(dt) end
end
end
-- Ét skridt af rulningen. -> true når den er slut (AD overtager igen)
local function rollStep(adEnv, task, roll, dt)
local vehicle = task.vehicle
roll.elapsedMs = roll.elapsedMs + dt
if vehicle.ad.trailerModule ~= nil then vehicle.ad.trailerModule:update(dt) end
local p = positionOf(vehicle)
local traveled = math.sqrt((p.x - roll.start.x) ^ 2 + (p.z - roll.start.z) ^ 2)
local action = ADUnloadRoll.step({unloading = isAdUnloading(vehicle), traveled = traveled, planned = roll.planned,
elapsedMs = roll.elapsedMs})
if action == "done" then
stop(vehicle, dt)
logInfo(ADUnloadRoll.LOG_PREFIX .. "'%s' rullede %.1f m frem og tipper nu", vehicleName(vehicle), traveled)
return true
elseif action == "giveUp" then
stop(vehicle, dt)
Logging.warning(ADUnloadRoll.LOG_PREFIX .. "'%s' rullede %.1f m uden at kunne tippe — giver op", vehicleName(vehicle), traveled)
return true
end
local sdm = vehicle.ad.specialDrivingModule
if sdm ~= nil and sdm.releaseVehicle ~= nil then sdm:releaseVehicle() end
if vehicle.startMotor ~= nil and not vehicle:getIsMotorStarted() and vehicle:getCanMotorRun() then vehicle:startMotor() end
local x, y, z = localToWorld(vehicle.rootNode, 0, 0, 10)
local lx, lz = adEnv.AutoDrive.getDriveDirection(vehicle, x, y, z)
adEnv.AutoDrive.driveInDirection(vehicle, dt, 30, 0.3, 0.2, 20, true, true, lx, lz, ADUnloadRoll.ROLL_SPEED, 1)
return false
end
local isInstalled = false
function ADUnloadRoll.install(adEnv)
local task = adEnv ~= nil and adEnv.UnloadAtDestinationTask or nil
if isInstalled or task == nil or task.update == nil or adEnv.AutoDrive == nil
or adEnv.AutoDrive.driveInDirection == nil or adEnv.AutoDrive.getDriveDirection == nil then
return
end
isInstalled = true
local originalUpdate = task.update
task.update = function(self, dt)
local vehicle = self.vehicle
local roll = vehicle ~= nil and rolls[vehicle] or nil
if roll ~= nil and roll.task == self then
local ok, finished = pcall(rollStep, adEnv, self, roll, dt)
if not ok then Logging.warning(ADUnloadRoll.LOG_PREFIX .. "rul frem: %s", tostring(finished)) end
if ok and not finished then return end
rolls[vehicle] = nil
elseif vehicle ~= nil then
local ok, planned = pcall(shouldRoll, adEnv, self, dt)
if not ok then
Logging.warning(ADUnloadRoll.LOG_PREFIX .. "rul frem: %s", tostring(planned))
elseif planned ~= nil then
rolls[vehicle] = {task = self, start = positionOf(vehicle), planned = planned, elapsedMs = 0}
logInfo(ADUnloadRoll.LOG_PREFIX .. "'%s' står %.1f m før aflæsningen — ruller frem", vehicleName(vehicle), planned)
return
end
end
return originalUpdate(self, dt)
end
end