-- 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). ADUnloadRoll = {} ADUnloadRoll.LOG_PREFIX = "ADSmartPickup: aflæsning: " ADUnloadRoll.MIN_AHEAD = 0.3 -- m: tættere på er tippestedet allerede over triggeren ADUnloadRoll.MAX_AHEAD = 8 -- m: længere frem rulles ikke — så er det ikke markørens trigger 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 = 20000 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 -- Triggere foran de fulde vognes tippesteder, i traktorens rum. -> {{x, z}} local function offsetsFor(adEnv, vehicle) local offsets = {} local storage = g_currentMission ~= nil and g_currentMission.storageSystem or nil if storage == nil or vehicle.rootNode == nil then return offsets end local farmId = 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, ny, nz = getWorldTranslation(dischargeNode.node) for _, station in pairs(storage:getUnloadingStations()) do if ADSmartPickup == nil or ADSmartPickup.canUseStation == nil or ADSmartPickup.canUseStation(farmId, station) then for _, trigger in pairs(station.unloadTriggers or {}) 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 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 return ADUnloadRoll.plan(offsetsFor(adEnv, vehicle)) 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) Logging.info(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} Logging.info(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