246 lines
13 KiB
Lua
246 lines
13 KiB
Lua
-- 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
|