-- AD Wait Pool -- Fælles pulje af Wait-punkter (markører i mapper med ordet "Wait" i navnet) med -- reservationer, nærmeste-ledige-opslag, rutetjek og omdirigering af en AutoDrive-opgave. -- Bruges af adUnloadWait (rest-læs ved fuldt mål) og adOutbound (hold uden tur). -- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging) local function logInfo(...) return (ADLog or Logging).info(...) end ADWaitPool = {} -- ADCache-opslag der også virker uden adCache (tests) local function cacheGet(bucket, key, ttlMs, fn) if ADCacheGet == nil then return fn() end return ADCacheGet(bucket, key, ttlMs, fn) end ADWaitPool.LOG_PREFIX = "ADSmartPickup: " -- sættes af den der installerer opgave-hooks (task.STATE_DRIVING); 2 er AD's værdi ADWaitPool.STATE_DRIVING = 2 -- markør-id -> køretøj der har reserveret Wait-punktet ADWaitPool.claims = setmetatable({}, {__mode = "v"}) -- poolGroup: run'ets Wait-mappe; tom/nil = alle Wait-mapper. function ADWaitPool.getCandidates(adEnv, poolGroup) return cacheGet("waitCandidates", tostring(poolGroup or ""), 10000, function() return ADWaitPool.findCandidates(adEnv, poolGroup) end) end function ADWaitPool.findCandidates(adEnv, poolGroup) local candidates = {} for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do local isInPool = poolGroup == nil or poolGroup == "" or marker.group == poolGroup if isInPool and ADSupplyPlanner.isWaitMarker(marker) then local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id) if wayPoint ~= nil then table.insert(candidates, {marker = marker, x = wayPoint.x, z = wayPoint.z}) end end end return candidates end function ADWaitPool.claim(markerId, vehicle) ADWaitPool.claims[markerId] = vehicle end function ADWaitPool.getOwner(markerId) return ADWaitPool.claims[markerId] end function ADWaitPool.releaseVehicle(vehicle) for markerId, owner in pairs(ADWaitPool.claims) do if owner == vehicle then ADWaitPool.claims[markerId] = nil end end end local function getVehiclePosition(vehicle) if vehicle.rootNode == nil then return nil end local x, _, z = getWorldTranslation(vehicle.rootNode) return x, z end -- Nærmeste ledige (eller eget reserverede) Wait-punkt fra vognens position; isReachable(candidate) -- valgfri. nil uden position eller uden brugbart punkt. Reserverer IKKE selv. ADWaitPool.OCCUPIED_RADIUS = 6 -- Positioner for ANDRE motoriserede køretøjer (ikke vognen selv eller dens redskaber) — til at se om et -- Wait-punkt fysisk er optaget, også uden reservation (fx lige efter en omplanlægning). -- Alle motoriserede køretøjers positioner, delt mellem opslag i 0,5 s (ikke én runde pr. vogn pr. opslag). local function allVehiclePositions() return cacheGet("vehiclePositions", "all", 500, function() local list = {} local system = g_currentMission ~= nil and g_currentMission.vehicleSystem or nil for _, other in pairs(system ~= nil and system.vehicles or {}) do if other.spec_motorized ~= nil and other.rootNode ~= nil then local ok, x, _, z = pcall(getWorldTranslation, other.rootNode) if ok and x ~= nil then table.insert(list, {vehicle = other, x = x, z = z}) end end end return list end) end local function otherVehiclePositions(vehicle) local positions = {} local own = {} if vehicle.getChildVehicles ~= nil then local ok, children = pcall(vehicle.getChildVehicles, vehicle) for _, child in pairs(ok and children or {}) do own[child] = true end end own[vehicle] = true for _, entry in ipairs(allVehiclePositions()) do if not own[entry.vehicle] then table.insert(positions, entry) end end return positions end -- Midtpunkt af punkter {x, z} (fx flowets kilde-markører) -> x, z eller nil. function ADWaitPool.anchorOf(points) if points == nil or #points == 0 then return nil end local sx, sz = 0, 0 for _, point in ipairs(points) do sx, sz = sx + point.x, sz + point.z end return sx / #points, sz / #points end -- anchorX/anchorZ (valgfri): vælg nærmest dette punkt i stedet for traktoren (flow med "All": nærmest kilderne). function ADWaitPool.pickFree(adEnv, vehicle, poolGroup, isReachable, anchorX, anchorZ) local x, z = getVehiclePosition(vehicle) if anchorX ~= nil and anchorZ ~= nil then x, z = anchorX, anchorZ end if x == nil then return nil end local candidates = ADWaitPool.getCandidates(adEnv, poolGroup) local occupied = ADSupplyPlanner.markOccupiedWaitPoints(candidates, otherVehiclePositions(vehicle), ADWaitPool.OCCUPIED_RADIUS) return ADSupplyPlanner.pickNearestFreeWaitPoint(candidates, ADWaitPool.claims, x, z, vehicle, isReachable, occupied) end -- Ender ruten i målet? (AutoDrive returnerer tom/afkortet liste når der ingen vej er.) local function pathReaches(path, wayPointId) return path ~= nil and #path > 0 and path[#path].id == wayPointId end -- Sendes AutoDrive mod et punkt uden rute, viser den "cannot reach" og slukker sig selv. -- getPathTo/pathFromTo er rene opslag uden bivirkninger. -- Reserve: bredde-først gennem vejnettets udgange fra traktorens nærmeste waypoint. AD's getPathTo kan -- sige nej trods en vej (set ved et Wait-punkt: ruten fandtes fra alle omkringliggende waypoints). ADWaitPool.GRAPH_SEARCH_LIMIT = 200000 -- over kortets vejpunkter (48.000 i savegame8), så søgningen aldrig stopper for tidligt local loggedFallback = {} -- Nåelighedsmængde pr. startpunkt: når en søgning IKKE finder målet, har den gennemløbet hele den komponent, -- startpunktet ligger i — mængden gemmes REACH_SET_MS, og de næste mål fra samme start er rene opslag (in-game -- 17/10 11:12: nettet skilt ad under ombygning -> hvert uopnåeligt mål kostede en fuld gennemsøgning af 48.000 -- punkter, 500+ pr. minut, 1 s-hak). Nulstilles med rutecachen (AD's markChanges). ADWaitPool.REACH_SET_MS = 10000 ADWaitPool.REACH_SET_MAX = 32 -- hver mængde kan være ~48k poster (1-2 MB): udløbne smides ud ved indsættelse, loft derover local reachSets = {} -- startId -> {set = {[id] = true}, at = ms} local reachSetCount = 0 local function storeReachSet(startId, set, now) local count = 0 for id, entry in pairs(reachSets) do if now - entry.at >= ADWaitPool.REACH_SET_MS then reachSets[id] = nil else count = count + 1 end end if count >= ADWaitPool.REACH_SET_MAX then reachSets, count = {}, 0 end if reachSets[startId] == nil then count = count + 1 end reachSets[startId] = {set = set, at = now} reachSetCount = count end local function clockMsEarly() local ok, ms = pcall(function() return netGetTime() end) return ok and type(ms) == "number" and ms or nil end -- Bredde-først fra et vejpunkt til et andet (ren graf-søgning, ingen AD-opslag). local function graphReachesFrom(adEnv, startId, targetId) local graph = adEnv.ADGraphManager if startId == nil or targetId == nil or graph.getWayPointById == nil then return false end local now = clockMsEarly() local known = reachSets[startId] if known ~= nil and now ~= nil and now - known.at < ADWaitPool.REACH_SET_MS then return known.set[targetId] == true end local seen, queue, head = {[startId] = true}, {startId}, 1 while queue[head] ~= nil and head <= ADWaitPool.GRAPH_SEARCH_LIMIT do local id = queue[head] head = head + 1 if id == targetId then return true end local wayPoint = graph:getWayPointById(id) for _, nextId in ipairs(wayPoint ~= nil and wayPoint.out or {}) do if not seen[nextId] then seen[nextId] = true table.insert(queue, nextId) end end end -- hele komponenten gennemløbet uden at finde målet: husk mængden (kun når søgningen ikke blev afbrudt af grænsen) if queue[head] == nil and now ~= nil then storeReachSet(startId, seen, now) end return false end local function graphReaches(adEnv, vehicle, targetId) if vehicle.getClosestWayPoint == nil then return false end local ok, startId = pcall(vehicle.getClosestWayPoint, vehicle) if not ok or startId == nil then return false end return graphReachesFrom(adEnv, startId, targetId) end -- Rutesvar gemmes ROUTE_CACHE_MS pr. mål og 10 m-område: holdende vogne spørger hvert 5. s for hver -- kandidat, og AD's stifinding (+ reserve-søgningen) gennem hele vejnettet gav et hak hvert 5. s -- (in-game 26/9). Vejnettet ændrer sig ikke så hurtigt. 17/10: 30 s var lig ventende vognes 30 s-tjek af andre -- mål, så hvert tjek ramte lige efter udløb (48.000 vejpunkter: 600 ms pr. AD-opslag, 2 s-frames hvert minut); -- nu 2 min med spredning, så vognenes tjek ikke falder i samme frame. ADWaitPool.ROUTE_CACHE_MS = 120000 ADWaitPool.ROUTE_CACHE_JITTER = 0.5 -- hver post lever ROUTE_CACHE_MS × (1 .. 1+JITTER) ADWaitPool.ROUTE_CELL_M = 10 ADWaitPool.SLOW_ROUTE_MS = 3 local routeCache = {} local routeCacheSize = 0 ADWaitPool.ROUTE_CACHE_MAX = 2000 local function remember(key, result, at) if routeCache[key] == nil then routeCacheSize = routeCacheSize + 1 if routeCacheSize > ADWaitPool.ROUTE_CACHE_MAX then routeCache, routeCacheSize = {}, 1 end end routeCache[key] = {result = result, at = at, ttl = ADWaitPool.ROUTE_CACHE_MS * (1 + math.random() * ADWaitPool.ROUTE_CACHE_JITTER)} end local function cacheFresh(cached, now) return cached ~= nil and now - cached.at < (cached.ttl or ADWaitPool.ROUTE_CACHE_MS) end -- Budget pr. frame for langsomme rutesvar (AD's vejfinding, 90-640 ms pr. uopnåeligt mål): efter en nulstilling af -- cachen (AD-nettet redigeret) blev ellers alle mål genberegnet i ét frame (in-game 17/10: 53 kald, 4,5 s frame). -- Over budgettet serveres det gamle (forældede) svar, og posten genberegnes i et senere frame. ADWaitPool.FRAME_BUDGET_MS = 100 local frameKey, frameSpent = nil, 0 function ADWaitPool.isOverBudget(frameId) if frameId ~= frameKey then frameKey, frameSpent = frameId, 0 end return frameSpent >= ADWaitPool.FRAME_BUDGET_MS end function ADWaitPool.noteSpent(frameId, ms) if frameId ~= frameKey then frameKey, frameSpent = frameId, 0 end frameSpent = frameSpent + (ms or 0) end local function frameId(now) return (g_currentMission ~= nil and type(g_currentMission.time) == "number") and g_currentMission.time or now end local function clockMs() local ok, ms = pcall(function() return netGetTime() end) if ok and type(ms) == "number" then return ms end return nil end local function routeKey(vehicle, wayPointId) if vehicle.rootNode == nil or getWorldTranslation == nil then return nil end local ok, x, _, z = pcall(getWorldTranslation, vehicle.rootNode) if not ok or x == nil then return nil end local cell = ADWaitPool.ROUTE_CELL_M return string.format("%s:%d:%d", tostring(wayPointId), math.floor(x / cell), math.floor(z / cell)) end local function nextToTarget(adEnv, vehicle, wayPointId) local graph = adEnv.ADGraphManager local target = graph.getWayPointById ~= nil and graph:getWayPointById(wayPointId) or nil if target == nil or vehicle.rootNode == nil or getWorldTranslation == nil then return false end local ok, x, _, z = pcall(getWorldTranslation, vehicle.rootNode) if not ok or x == nil then return false end local limit = graph.MIN_START_DISTANCE or (ADGraphManager ~= nil and ADGraphManager.MIN_START_DISTANCE) or 8 return (target.x - x) ^ 2 + (target.z - z) ^ 2 < limit * limit end -- Vej = vejnettets egen bredde-først-søgning ELLER AD's getPathTo (svaret er det samme "eller" som før 17/10, men -- den billige søgning spørges først: AD's stifinding over 48.000 vejpunkter tog 600 ms pr. kald og gav 2 s-frames). -- Vognen står så tæt på målet, at AD kører direkte (ADGraphManager.MIN_START_DISTANCE) local function computeRoute(adEnv, vehicle, wayPointId) local graph = adEnv.ADGraphManager if graphReaches(adEnv, vehicle, wayPointId) then return true end -- AD's getPathTo kræver vehicle.ad.frontNode (findMatchingWayPointForVehicle); uden den giver motoren en -- scriptfejl i loggen, selv i pcall (in-game 16/10: foderkøb via findBuyMarker) — så kun graf-tjekket local noFront = vehicle.ad ~= nil and vehicle.ad.frontNode == nil -- AD's eget startpunkt (bedste retning inden for 20 m) som anden netsøgning i stedet for AD's vejfinding: -- den kostede 90-640 ms pr. uopnåeligt mål (in-game 17/10 11:07: 14 kald = 1,7 s i udkørslens turvalg), og -- netsøgningen fra AD's start giver samme svar — AD's vejfinding løber selv over wayPoint.out if not noFront and vehicle.ad ~= nil and graph.findMatchingWayPointForVehicle ~= nil and vehicle.getWayPointIdsInRange ~= nil then local okS, start = pcall(graph.findMatchingWayPointForVehicle, graph, vehicle) local startId = okS and ((type(start) == "table" and start.id) or (type(start) == "number" and start)) or nil if startId ~= nil and graphReachesFrom(adEnv, startId, wayPointId) then if not loggedFallback[wayPointId] and Logging ~= nil and Logging.info ~= nil then loggedFallback[wayPointId] = true logInfo("ADSmartPickup: vejnettet fra nærmeste vejpunkt nåede ikke markør %s, men fra AutoDrives startpunkt gør det — godtages", tostring(wayPointId)) end return true end return nextToTarget(adEnv, vehicle, wayPointId) end if not noFront and pathReaches(graph:getPathTo(vehicle, wayPointId), wayPointId) then -- vejnettet fra nærmeste vejpunkt nåede ikke frem, men AD's eget startpunkt gør (sjældent: nærmeste punkt -- ligger på en blind sidegren) if not loggedFallback[wayPointId] and Logging ~= nil and Logging.info ~= nil then loggedFallback[wayPointId] = true logInfo("ADSmartPickup: vejnettet fra nærmeste vejpunkt nåede ikke markør %s, men AutoDrives rutesøgning gør — godtages", tostring(wayPointId)) end return true end return false end function ADWaitPool.hasRouteTo(adEnv, vehicle, wayPointId) local graph = adEnv.ADGraphManager if graph.getPathTo == nil then return true end -- frakoblet vogn (dvale-tjekket): AD's rutesøgning læser vehicle.ad.frontNode og fejler — godtag; turen -- rutetjekkes igen af traktoren, når flowet er vækket if vehicle ~= nil and vehicle.ad == nil and vehicle.spec_attachable ~= nil and vehicle.spec_motorized == nil then return true end local now = clockMs() local key = now ~= nil and routeKey(vehicle, wayPointId) or nil local cached = key ~= nil and routeCache[key] or nil if cacheFresh(cached, now) then return cached.result end -- forældet svar, men dette frames budget er brugt: svar som sidst, genberegnes i et senere frame if cached ~= nil and ADWaitPool.isOverBudget(frameId(now)) then return cached.result end local result = computeRoute(adEnv, vehicle, wayPointId) if key ~= nil then local spent = (clockMs() or now) - now ADWaitPool.noteSpent(frameId(now), spent) remember(key, result, now) if spent > ADWaitPool.SLOW_ROUTE_MS and Logging ~= nil and Logging.info ~= nil and (ADWaitPool.lastSlowLog == nil or now - ADWaitPool.lastSlowLog > 60000) then ADWaitPool.lastSlowLog = now logInfo("ADSmartPickup: rutetjek til markør %s tog %.1f ms (%s) — gemmes nu i %d-%d s", tostring(wayPointId), spent, result and "vej" or "ingen vej", ADWaitPool.ROUTE_CACHE_MS / 1000, ADWaitPool.ROUTE_CACHE_MS * (1 + ADWaitPool.ROUTE_CACHE_JITTER) / 1000) end end return result end -- Rute mellem to markører: afhænger ikke af vognens position, så svaret gemmes længe (5 min). Profiler -- 26/9: "rutetjek frem+tilbage" tog 30-39 ms pr. kald og blev regnet igen hver gang vognen havde flyttet sig -- 10 m — det gav hak på 44-67 ms hvert minut. ADWaitPool.MARKER_ROUTE_MS = 300000 local markerRoutes = {} function ADWaitPool.hasMarkerRoute(adEnv, fromWayPointId, toWayPointId) local graph = adEnv.ADGraphManager if graph.pathFromTo == nil then return true end local key = tostring(fromWayPointId) .. ">" .. tostring(toWayPointId) local now = clockMs() local cached = markerRoutes[key] if cached ~= nil and now ~= nil and now - cached.at < ADWaitPool.MARKER_ROUTE_MS then return cached.result end if cached ~= nil and now ~= nil and ADWaitPool.isOverBudget(frameId(now)) then return cached.result end -- vejnettets egen søgning først (17/10: AD's pathFromTo tog 400-850 ms over 48.000 vejpunkter) local result = graphReachesFrom(adEnv, fromWayPointId, toWayPointId) or pathReaches(graph:pathFromTo(fromWayPointId, toWayPointId), toWayPointId) if now ~= nil then ADWaitPool.noteSpent(frameId(now), (clockMs() or now) - now) markerRoutes[key] = {result = result, at = now + math.random() * ADWaitPool.MARKER_ROUTE_MS * 0.5} end return result end function ADWaitPool.resetMarkerRoutes() markerRoutes = {} end -- Alle rutesvar forældes: ved indlæsning og når AD-vejnettet ændres (slettet/ny vej må ikke leve 2-3 min i cachen). -- Svarene beholdes som forældede, så de kan serveres, mens genberegningen fordeles over frames (budgettet). function ADWaitPool.resetRouteCache() for _, entry in pairs(routeCache) do entry.at = -math.huge end for _, entry in pairs(markerRoutes) do entry.at = -math.huge end reachSets, reachSetCount = {}, 0 end -- AD's ADGraphManager:markChanges() kaldes ved hver redigering af vejnettet (22 steder i AD) -> glem rutesvarene. local installedGraph = nil function ADWaitPool.install(adEnv) ADWaitPool.resetRouteCache() local graph = adEnv ~= nil and adEnv.ADGraphManager or nil if graph == nil or graph.markChanges == nil or installedGraph == graph then return false end installedGraph = graph local original = graph.markChanges graph.markChanges = function(self, ...) ADWaitPool.resetRouteCache() return original(self, ...) end return true end function ADWaitPool.hasRouteBothWays(adEnv, vehicle, toWayPointId, homeWayPointId) local graph = adEnv.ADGraphManager if graph.getPathTo == nil or graph.pathFromTo == nil then return true end -- kendt hjem (kilden): vognen kører hjem -> mål -> hjem; markør til markør, gemt længe if homeWayPointId ~= nil then return ADWaitPool.hasMarkerRoute(adEnv, homeWayPointId, toWayPointId) and ADWaitPool.hasMarkerRoute(adEnv, toWayPointId, homeWayPointId) end local now = clockMs() local key = now ~= nil and routeKey(vehicle, tostring(toWayPointId) .. ">" .. tostring(homeWayPointId)) or nil local cached = key ~= nil and routeCache[key] or nil if cacheFresh(cached, now) then return cached.result end if cached ~= nil and ADWaitPool.isOverBudget(frameId(now)) then return cached.result end local result = computeRoute(adEnv, vehicle, toWayPointId) and (graphReachesFrom(adEnv, toWayPointId, homeWayPointId) or pathReaches(graph:pathFromTo(toWayPointId, homeWayPointId), homeWayPointId)) if key ~= nil then ADWaitPool.noteSpent(frameId(now), (clockMs() or now) - now) remember(key, result, now) end return result end -- Står AD midt i en (blokeret) af-/pålæsning, stoppes den pænt først — ellers kører -- traktoren væk med tippet vogn. Kun opgavens destination ændres. function ADWaitPool.redirect(task, destinationID) local trailerModule = task.vehicle.ad.trailerModule if trailerModule ~= nil and trailerModule.isActiveAtTrigger ~= nil and trailerModule:isActiveAtTrigger() then if trailerModule.stopUnloading ~= nil then trailerModule:stopUnloading() end if trailerModule.stopLoading ~= nil then trailerModule:stopLoading() end end task.destinationID = destinationID task.state = ADWaitPool.STATE_DRIVING task.vehicle.ad.drivePathModule:setPathTo(destinationID) end -- Hvem holder hvor (GUI'ets Wait-puljer-visning). Sorteret på mappe, dernæst markør-id. function ADWaitPool.getClaims(adEnv) local result = {} local graph = adEnv ~= nil and adEnv.ADGraphManager or (FS25_AutoDrive ~= nil and FS25_AutoDrive.ADGraphManager or nil) for markerId, vehicle in pairs(ADWaitPool.claims) do local marker = graph ~= nil and graph.getMapMarkerByWayPointId ~= nil and graph:getMapMarkerByWayPointId(markerId) or nil if marker ~= nil then table.insert(result, {marker = marker, vehicle = vehicle}) end end table.sort(result, function(a, b) if a.marker.group ~= b.marker.group then return tostring(a.marker.group) < tostring(b.marker.group) end return a.marker.id < b.marker.id end) return result end