453 lines
25 KiB
Lua
453 lines
25 KiB
Lua
-- AD Load Diag
|
|
-- Diagnose når AutoDrive står ved et LOAD-mål uden at fylde (in-game 30/9: Fendt + MEGA-sprøjte ved "Market Price
|
|
-- Liquid Fill Station"). AutoDrive fylder kun, når en fyldenhed står i triggerens boks (trigger.fillableObjects) og
|
|
-- triggeren har varen. Efter REPORT_MS ved målet uden fremgang skrives én linje: markør, vare, og for hver vogn den
|
|
-- nærmeste AD-læssetrigger (afstand, har varen?, står vognen i boksen?). Kun når en trigger med varen er inden for
|
|
-- NEAR_M (holder ved Wait-punkter logges ikke). Ingen indgreb — kun log.
|
|
|
|
ADLoadDiag = {}
|
|
ADLoadDiag.LOG_PREFIX = "ADSmartPickup: pålæsning: "
|
|
-- før udkørslens "intet at læsse" (30 s), ellers når beskeden aldrig ud (in-game 10/10)
|
|
ADLoadDiag.REPORT_MS = 25000
|
|
ADLoadDiag.NEAR_M = 20 -- m: trigger med varen herinden for = køretøjet står ved stationen (ellers Wait/mark: ingen log)
|
|
|
|
-- ---- ren logik ----
|
|
|
|
-- state (pr. opgave), dt, reached (ved målet), level (liter på vognene) -> true når der skal rapporteres (én gang pr.
|
|
-- ankomst). Fremgang eller kørsel nulstiller.
|
|
function ADLoadDiag.tick(state, dt, reached, level)
|
|
if not reached then
|
|
state.ms, state.reported, state.level = 0, false, nil
|
|
return false
|
|
end
|
|
if state.level == nil or level > state.level then
|
|
state.level, state.ms = level, 0
|
|
return false
|
|
end
|
|
state.ms = (state.ms or 0) + (dt or 0)
|
|
if state.reported or state.ms < ADLoadDiag.REPORT_MS then return false end
|
|
state.reported = true
|
|
return true
|
|
end
|
|
|
|
-- distances = afstande fra vognene til nærmeste AD-trigger med varen -> står ved stationen?
|
|
function ADLoadDiag.atStation(distances)
|
|
for _, d in ipairs(distances or {}) do
|
|
if d <= ADLoadDiag.NEAR_M then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- ---- spil ----
|
|
|
|
local fillTypeName = ADUtil.fillTypeName
|
|
|
|
local function inBox(trigger, trailer)
|
|
for key, entry in pairs(trigger.fillableObjects or {}) do
|
|
if key == trailer or (type(entry) == "table" and entry.object == trailer) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Ren: hvor triggerens midte ligger set fra vognens påfyldningspunkt i TRAKTORENS retning (x til siden, y op/ned,
|
|
-- z frem/tilbage) -> læsbar tekst, der siger hvilken vej sporet/markøren skal rykkes (in-game 17/10: Supercis 800 ved
|
|
-- 'Slurry Tank' stod 0,4 m fra triggeren langs vejen, men 1,5 m til siden — ikke i boksen)
|
|
function ADLoadDiag.describeOffset(x, y, z, radius)
|
|
if x == nil or y == nil or z == nil then return nil end
|
|
local parts = {}
|
|
-- Giants: Y op, Z frem, højrehåndet -> +X peger til VENSTRE for traktoren (venstre hjul har positiv x i køretøjs-XML)
|
|
if math.abs(x) >= 0.05 then table.insert(parts, string.format("%.1f m til %s", math.abs(x), x > 0 and "venstre" or "højre")) end
|
|
if math.abs(z) >= 0.05 then table.insert(parts, string.format("%.1f m %s", math.abs(z), z < 0 and "bagud" or "frem")) end
|
|
if math.abs(y) >= 0.05 then table.insert(parts, string.format("%.1f m %s", math.abs(y), y < 0 and "lavere" or "højere")) end
|
|
local where = #parts > 0 and table.concat(parts, ", ") or "lige dér"
|
|
return string.format("triggerens midte ligger %s i forhold til tankens påfyldningspunkt%s", where,
|
|
radius ~= nil and string.format(" (triggerens radius %.1f m)", radius) or "")
|
|
end
|
|
|
|
-- Triggerens midte i verden: bounding-sfærens centrum (nodens nulpunkt sidder tit i et hjørne), ellers nodens nulpunkt.
|
|
-- -> x, y, z, radius | nil. Bruges også af ADLoadRoll, så rulning og diagnose måler det samme sted (17/10: rulningen
|
|
-- målte til nodens nulpunkt og planlagde 0,4 m, mens midten lå 1,3-2,9 m længere fremme).
|
|
function ADLoadDiag.triggerCenter(trigger)
|
|
local node = trigger ~= nil and trigger.triggerNode or nil
|
|
if node == nil then return nil end
|
|
local cx, cy, cz, radius = 0, 0, 0, nil
|
|
if getShapeBoundingSphere ~= nil then
|
|
local okR, sx, sy, sz, r = pcall(getShapeBoundingSphere, node)
|
|
if okR and type(r) == "number" then
|
|
radius = r
|
|
if type(sx) == "number" and type(sy) == "number" and type(sz) == "number" then cx, cy, cz = sx, sy, sz end
|
|
end
|
|
end
|
|
local x, y, z = localToWorld(node, cx, cy, cz)
|
|
return x, y, z, radius
|
|
end
|
|
|
|
-- Triggerens midte set fra den første fyldenheds exactFillRootNode, i traktorens retning.
|
|
local function fillOffset(trigger, trailer, fillType, vehicle)
|
|
local node = trigger.triggerNode
|
|
if node == nil or trailer.getFillUnits == nil or vehicle == nil or vehicle.rootNode == nil then return nil end
|
|
for i = 1, #(trailer:getFillUnits() or {}) do
|
|
if trailer.getFillUnitSupportsFillType == nil or trailer:getFillUnitSupportsFillType(i, fillType) then
|
|
local fillNode = trailer.getFillUnitExactFillRootNode ~= nil and trailer:getFillUnitExactFillRootNode(i) or nil
|
|
if fillNode ~= nil then
|
|
local fx, fy, fz = getWorldTranslation(fillNode)
|
|
local tx, ty, tz, radius = ADLoadDiag.triggerCenter(trigger)
|
|
if tx == nil then return nil end
|
|
local x, _, z = worldDirectionToLocal(vehicle.rootNode, tx - fx, 0, tz - fz)
|
|
return ADLoadDiag.describeOffset(x, ty - fy, z, radius)
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- AD's egne porte for pålæsning ved triggeren (AutoDrive.getTriggerAndTrailerPairs + tryLoadingAtTrigger): pr. fyldenhed
|
|
-- understøtter/tillader varen, fri plads, varevalget matcher, vognen i triggerens liste, kildens niveau, trigger i gang.
|
|
local function adGates(adEnv, vehicle, trailer, trigger, fillType)
|
|
local autoDrive = adEnv.AutoDrive
|
|
local parts = {}
|
|
local farmId = vehicle.getActiveFarm ~= nil and vehicle:getActiveFarm() or nil
|
|
local sourceLevel = nil
|
|
if trigger.source ~= nil and trigger.source.getAllFillLevels ~= nil then
|
|
local ok, levels = pcall(trigger.source.getAllFillLevels, trigger.source, farmId)
|
|
if ok and type(levels) == "table" then sourceLevel = levels[fillType] end
|
|
end
|
|
table.insert(parts, string.format("kilde(%s)=%s", tostring(farmId), tostring(sourceLevel)))
|
|
table.insert(parts, "trigger.isLoading=" .. tostring(trigger.isLoading))
|
|
-- spillets LoadTrigger starter kun med et gyldigt fyldobjekt (onFillTypeSelection -> setIsLoading)
|
|
local valid = trigger.validFillableObject
|
|
table.insert(parts, string.format("valid=%s/%s autoStart=%s", tostring(valid ~= nil and (valid.getName ~= nil and valid:getName() or "ja") or nil),
|
|
tostring(trigger.validFillableFillUnitIndex), tostring(trigger.autoStart)))
|
|
-- spillets egen port kræver spilleren i sædet (requiresActiveVehicle); AD går uden om den via sin egen krog på
|
|
-- onFillTypeSelection — derfor vises også, om triggeren har AD's krog
|
|
local okA, activatable = pcall(function() return trigger.getIsFillableObjectAvailable ~= nil and trigger:getIsFillableObjectAvailable() end)
|
|
table.insert(parts, string.format("spillerport=%s AD-krog=%s", okA and tostring(activatable) or "fejl", tostring(ADLoadDiag.hasAdHook(trigger))))
|
|
local selected = vehicle.ad.stateModule.getSelectedFillTypes ~= nil and vehicle.ad.stateModule:getSelectedFillTypes() or {}
|
|
for i = 1, #(trailer:getFillUnits() or {}) do
|
|
local supports = trailer:getFillUnitSupportsFillType(i, fillType)
|
|
local allows = trailer.getFillUnitAllowsFillType == nil or trailer:getFillUnitAllowsFillType(i, fillType)
|
|
local okM, match = pcall(autoDrive.fillTypesMatch, vehicle, trigger, trailer, selected, i)
|
|
local okL, inList = pcall(autoDrive.trailerIsInTriggerList, trailer, trigger, i)
|
|
local okT, viaTrigger = pcall(function() return ToolType ~= nil and trailer.getFillUnitSupportsToolType ~= nil and trailer:getFillUnitSupportsToolType(i, ToolType.TRIGGER) end)
|
|
table.insert(parts, string.format("enhed%d: understøtter=%s tillader=%s fri=%.0f varevalg=%s iListe=%s trigger-værktøj=%s", i, tostring(supports), tostring(allows),
|
|
trailer:getFillUnitFreeCapacity(i) or -1, okM and tostring(match) or "fejl", okL and tostring(inList) or "fejl", okT and tostring(viaTrigger) or "fejl"))
|
|
end
|
|
local tm = vehicle.ad.trailerModule
|
|
if tm ~= nil then
|
|
table.insert(parts, string.format("AD: isLoading=%s trigger=%s activeAtTrigger=%s startforsøg=%s", tostring(tm.isLoading), tostring(tm.trigger ~= nil),
|
|
tostring(tm.isActiveAtTrigger ~= nil and tm:isActiveAtTrigger()), tostring(tm.countLoading)))
|
|
end
|
|
-- LoadAtDestinationTask afslutter straks ved rotation "kun pålæsning"/"fortsæt ved tom silo" — medmindre modden holder vognen
|
|
local okR, rotate = pcall(autoDrive.getSetting, "rotateTargets", vehicle)
|
|
local okC, continueEmpty = pcall(autoDrive.getSetting, "continueOnEmptySilo", vehicle)
|
|
local okW, wait = pcall(function() return ADSmartPickup ~= nil and ADSmartPickup.shouldWaitForLoading ~= nil and ADSmartPickup.shouldWaitForLoading(vehicle) end)
|
|
table.insert(parts, string.format("rotér=%s fortsætTom=%s smartHolder=%s", okR and tostring(rotate) or "?", okC and tostring(continueEmpty) or "?", okW and tostring(wait) or "?"))
|
|
-- AD's egen beslutningskæde: autoload-gren (aldrig trigger), "giv videre til CP", og hvad AD selv finder af par
|
|
local stateModule = vehicle.ad.stateModule
|
|
local okH, canRestart = pcall(function() return stateModule.getCanRestartHelper ~= nil and stateModule:getCanRestartHelper() end)
|
|
table.insert(parts, string.format("hasAL=%s cpOvertag=%s mode=%s", tostring(vehicle.ad.hasAL), okH and tostring(canRestart) or "?",
|
|
tostring(stateModule.getMode ~= nil and stateModule:getMode() or "?")))
|
|
local okP, pairs_ = pcall(autoDrive.getTriggerAndTrailerPairs, vehicle, 1000)
|
|
if okP and type(pairs_) == "table" then
|
|
local found = {}
|
|
for _, pair in pairs(pairs_) do
|
|
table.insert(found, string.format("%s/enhed%s fyld=%s", tostring(pair.trailer ~= nil and pair.trailer.getName ~= nil and pair.trailer:getName() or "?"),
|
|
tostring(pair.fillUnitIndex), tostring(pair.hasFill)))
|
|
end
|
|
table.insert(parts, "ADpar=" .. (#found > 0 and table.concat(found, ",") or "ingen"))
|
|
else
|
|
table.insert(parts, "ADpar=fejl: " .. tostring(pairs_))
|
|
end
|
|
return table.concat(parts, " ")
|
|
end
|
|
|
|
local function describeTrailer(adEnv, trailer, fillType, vehicle)
|
|
local node = trailer.components ~= nil and trailer.components[1] ~= nil and trailer.components[1].node or trailer.rootNode
|
|
if node == nil then return nil end
|
|
local tx, _, tz = getWorldTranslation(node)
|
|
local nearest, nearestOk = nil, nil
|
|
for _, trigger in pairs(adEnv.ADTriggerManager.getLoadTriggers() or {}) do
|
|
local x, _, z = adEnv.ADTriggerManager.getTriggerPos(trigger)
|
|
if x ~= nil and (x ~= 0 or z ~= 0) then
|
|
local d = math.sqrt((x - tx) ^ 2 + (z - tz) ^ 2)
|
|
local ok = adEnv.ADTriggerManager.triggerSupportsFillType(trigger, fillType)
|
|
if nearest == nil or d < nearest.d then nearest = {d = d, ok = ok, trigger = trigger} end
|
|
if ok and (nearestOk == nil or d < nearestOk.d) then nearestOk = {d = d, trigger = trigger} end
|
|
end
|
|
end
|
|
-- traktoren med AD-navnet (modelnavnet er ens for alle af samme model)
|
|
local name = (trailer.spec_motorized ~= nil and trailer.ad ~= nil) and ADRuns.vehicleLabel(trailer)
|
|
or (trailer.getName ~= nil and trailer:getName() or "?")
|
|
local parts = {}
|
|
if nearest ~= nil then
|
|
table.insert(parts, string.format("nærmeste AD-trigger %.1f m (%s varen, %s)", nearest.d, nearest.ok and "har" or "UDEN",
|
|
inBox(nearest.trigger, trailer) and "vognen i boksen" or "vognen IKKE i boksen"))
|
|
end
|
|
if nearestOk ~= nil and (nearest == nil or nearestOk.trigger ~= nearest.trigger) then
|
|
table.insert(parts, string.format("nærmeste med varen %.1f m (%s)", nearestOk.d,
|
|
inBox(nearestOk.trigger, trailer) and "i boksen" or "ikke i boksen"))
|
|
end
|
|
if nearestOk == nil then table.insert(parts, "INGEN AD-læssetrigger med varen") end
|
|
if nearestOk ~= nil and not inBox(nearestOk.trigger, trailer) then
|
|
local okO, offset = pcall(fillOffset, nearestOk.trigger, trailer, fillType, vehicle)
|
|
if okO and offset ~= nil then table.insert(parts, offset) end
|
|
end
|
|
if nearestOk ~= nil and vehicle ~= nil and trailer.getFillUnits ~= nil then
|
|
local okG, gates = pcall(adGates, adEnv, vehicle, trailer, nearestOk.trigger, fillType)
|
|
table.insert(parts, "[" .. (okG and gates or ("fejl: " .. tostring(gates))) .. "]")
|
|
end
|
|
return string.format("'%s': %s", tostring(name), table.concat(parts, ", ")), nearestOk ~= nil and nearestOk.d or nil
|
|
end
|
|
|
|
local function report(adEnv, task)
|
|
local vehicle = task.vehicle
|
|
local fillType = vehicle.ad.stateModule.getFillType ~= nil and vehicle.ad.stateModule:getFillType() or nil
|
|
local marker = task.destinationID ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(task.destinationID) or nil
|
|
local lines, distances = {}, {}
|
|
for _, trailer in ipairs(task.trailers or {}) do
|
|
if trailer.getFillUnits ~= nil and #trailer:getFillUnits() > 0 then
|
|
local ok, line, distance = pcall(describeTrailer, adEnv, trailer, fillType, vehicle)
|
|
if ok and line ~= nil then table.insert(lines, line) end
|
|
if ok and distance ~= nil then table.insert(distances, distance) end
|
|
end
|
|
end
|
|
-- holder ved Wait/mark (ingen trigger med varen tæt på): det er ikke en fejlet pålæsning
|
|
if not ADLoadDiag.atStation(distances) then return end
|
|
local maxDistance = adEnv.AutoDrive.getMaxTriggerDistance ~= nil and adEnv.AutoDrive.getMaxTriggerDistance(vehicle) or nil
|
|
Logging.warning(ADLoadDiag.LOG_PREFIX .. "'%s' står ved '%s' uden at fylde %s i %d s (AD-triggerafstand %s m): %s",
|
|
tostring(ADRuns.vehicleLabel(vehicle)), tostring(marker ~= nil and marker.name or task.destinationID), fillTypeName(fillType),
|
|
math.floor(ADLoadDiag.REPORT_MS / 1000), tostring(maxDistance), #lines > 0 and table.concat(lines, "; ") or "ingen vogne med fyldenheder")
|
|
end
|
|
|
|
local states = setmetatable({}, {__mode = "k"})
|
|
|
|
function ADLoadDiag.after(adEnv, task, dt)
|
|
local vehicle = task.vehicle
|
|
if vehicle == nil or vehicle.ad == nil or vehicle.ad.drivePathModule == nil then return end
|
|
local state = states[task]
|
|
if state == nil then
|
|
state = {}
|
|
states[task] = state
|
|
end
|
|
local reached = vehicle.ad.drivePathModule:isTargetReached() and not vehicle.ad.trailerModule:isActiveAtTrigger()
|
|
local level = adEnv.AutoDrive.getAllFillLevels(task.trailers) or 0
|
|
if ADLoadDiag.tick(state, dt, reached, level) then report(adEnv, task) end
|
|
-- vogn med et læs af en anden vare: kør ud og tøm (ADForeignRest)
|
|
if ADForeignRest ~= nil then
|
|
local ok, err = pcall(ADForeignRest.after, adEnv, task, dt, reached, level)
|
|
if not ok then Logging.warning(ADLoadDiag.LOG_PREFIX .. "fremmed læs: %s", tostring(err)) end
|
|
end
|
|
end
|
|
|
|
-- ---- sporing af AD's startforsøg og spillets LoadTrigger (kun moddens køretøjer) ----
|
|
-- 17/10: Supercis stod i boksen ved 'Cow 5 Slurry' med alle porte grønne, men fyldningen gik aldrig i gang.
|
|
-- Sporingen viser, om AD kalder triggeren, om triggeren går i gang, og hvad kilden gav i første fyld-tik.
|
|
|
|
ADLoadDiag.TRACE_MS = 10000 -- mindst så længe mellem to "AD forsøgte"-linjer pr. køretøj (AD prøver igen hvert par sekunder)
|
|
|
|
-- har triggeren AD's krog på onFillTypeSelection? (en kopi af LoadTrigger lavet før AD indlæses mangler den,
|
|
-- og så kan kun spilleren i sædet starte fyldningen)
|
|
function ADLoadDiag.hasAdHook(trigger)
|
|
-- almindeligt opslag: i moddens miljø ligger spillets klasser bag en metatabel, som rawget springer over (17/10: sporingen blev aldrig installeret)
|
|
local class = LoadTrigger
|
|
if trigger == nil or class == nil or class.onFillTypeSelection == nil then return nil end
|
|
return trigger.onFillTypeSelection == class.onFillTypeSelection
|
|
end
|
|
|
|
-- ren: AD's startforsøg: triggerens tilstand før/efter, objekter i boksen, krog
|
|
function ADLoadDiag.describeAttempt(wasLoading, isLoading, objectCount, hasHook)
|
|
return string.format("trigger i gang før=%s efter=%s, %d i boksen, AD-krog=%s",
|
|
tostring(wasLoading), tostring(isLoading), objectCount or 0, tostring(hasHook))
|
|
end
|
|
|
|
-- ren: første fyld-tik: hvad der blev bedt om, og hvad kilden gav
|
|
function ADLoadDiag.describeFill(asked, applied)
|
|
if applied == nil then return string.format("bad om %.2f l, kilden svarede nil", asked or 0) end
|
|
return string.format("bad om %.2f l, fik %.2f l", asked or 0, applied)
|
|
end
|
|
|
|
local function isManaged(vehicle)
|
|
return vehicle ~= nil and ADSmartPickup ~= nil and ADSmartPickup.getActivePickup ~= nil
|
|
and ADSmartPickup.getActivePickup(vehicle) ~= nil
|
|
end
|
|
|
|
local function rootOf(object)
|
|
if object == nil then return nil end
|
|
if object.getRootVehicle ~= nil then
|
|
local ok, root = pcall(object.getRootVehicle, object)
|
|
if ok and root ~= nil then return root end
|
|
end
|
|
return object.rootVehicle
|
|
end
|
|
|
|
local function triggerName(trigger)
|
|
local source = trigger ~= nil and trigger.source or nil
|
|
if source ~= nil and source.getName ~= nil then
|
|
local ok, name = pcall(source.getName, source)
|
|
if ok and name ~= nil then return tostring(name) end
|
|
end
|
|
return "?"
|
|
end
|
|
|
|
local function countObjects(trigger)
|
|
local n = 0
|
|
for _ in pairs(trigger.fillableObjects or {}) do n = n + 1 end
|
|
return n
|
|
end
|
|
|
|
local function nowMs()
|
|
return g_time or (os.clock() * 1000)
|
|
end
|
|
|
|
local lastAttempt = setmetatable({}, {__mode = "k"}) -- køretøj -> tidsstempel (ms) for seneste logget forsøg
|
|
local lastTriggerLog = setmetatable({}, {__mode = "k"}) -- trigger -> {start, stop, fill} ms: højst én linje pr. slags pr. TRACE_MS
|
|
local function triggerLogDue(trigger, kind)
|
|
local now = nowMs()
|
|
local entry = lastTriggerLog[trigger]
|
|
if entry == nil then entry = {}; lastTriggerLog[trigger] = entry end
|
|
if entry[kind] ~= nil and now - entry[kind] < ADLoadDiag.TRACE_MS then return false end
|
|
entry[kind] = now
|
|
return true
|
|
end
|
|
local fillLogged = setmetatable({}, {__mode = "k"}) -- trigger -> true når første fyld-tik er logget for denne start
|
|
local tracedStart = setmetatable({}, {__mode = "k"}) -- trigger -> moddens køretøj, som triggeren fylder for (sat ved start)
|
|
|
|
|
|
|
|
-- AD's ADTrailerModule:startLoadingAtTrigger: log hvad triggeren gjorde ved forsøget
|
|
local function traceAttempt(module, trigger, fillType, fillUnitIndex, trailer, original)
|
|
local vehicle = module.vehicle
|
|
local wasLoading = trigger ~= nil and trigger.isLoading or false
|
|
local result = original(module, trigger, fillType, fillUnitIndex, trailer)
|
|
if trigger == nil or not isManaged(vehicle) then return result end
|
|
local now = nowMs()
|
|
if lastAttempt[vehicle] ~= nil and now - lastAttempt[vehicle] < ADLoadDiag.TRACE_MS then return result end
|
|
lastAttempt[vehicle] = now
|
|
Logging.info(ADLoadDiag.LOG_PREFIX .. "AD forsøgte at starte ved '%s' for '%s' (%s, fyldenhed %s): %s",
|
|
triggerName(trigger), tostring(ADRuns.vehicleLabel(vehicle)), fillTypeName(fillType), tostring(fillUnitIndex),
|
|
ADLoadDiag.describeAttempt(wasLoading, trigger.isLoading, countObjects(trigger), ADLoadDiag.hasAdHook(trigger)))
|
|
return result
|
|
end
|
|
|
|
-- spillets LoadTrigger:setIsLoading: start/stop for moddens køretøjer
|
|
local function traceSetIsLoading(trigger, isLoading, targetObject, fillUnitIndex, fillType, noEventSend, original)
|
|
local object = targetObject or trigger.currentFillableObject
|
|
local vehicle = rootOf(object)
|
|
local result = original(trigger, isLoading, targetObject, fillUnitIndex, fillType, noEventSend)
|
|
tracedStart[trigger] = nil
|
|
if isManaged(vehicle) then
|
|
if isLoading then
|
|
fillLogged[trigger] = nil
|
|
tracedStart[trigger] = vehicle
|
|
if triggerLogDue(trigger, "start") then
|
|
pcall(Logging.info, ADLoadDiag.LOG_PREFIX .. "triggeren '%s' går i gang for '%s' (%s, fyldenhed %s)",
|
|
triggerName(trigger), tostring(ADRuns.vehicleLabel(vehicle)), fillTypeName(fillType), tostring(fillUnitIndex))
|
|
end
|
|
elseif triggerLogDue(trigger, "stop") then
|
|
pcall(Logging.info, ADLoadDiag.LOG_PREFIX .. "triggeren '%s' stopper for '%s'%s", triggerName(trigger),
|
|
tostring(ADRuns.vehicleLabel(vehicle)), fillLogged[trigger] and "" or " (uden et eneste fyld-tik)")
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- kildens niveau for varen (den gårds, der fylder), vognens frie plads i fyldenheden og triggerens plads på kortet
|
|
local function fillContext(trigger, vehicle)
|
|
local parts = {}
|
|
pcall(function()
|
|
local fillType = trigger.selectedFillType
|
|
local farmId = vehicle ~= nil and vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() or nil
|
|
local levels = trigger.source ~= nil and trigger.source.getAllFillLevels ~= nil and trigger.source:getAllFillLevels(farmId) or nil
|
|
table.insert(parts, string.format("kilde %s l", levels ~= nil and fillType ~= nil and tostring(math.floor((levels[fillType] or 0) + 0.5)) or "?"))
|
|
local object, unit = trigger.currentFillableObject, trigger.fillUnitIndex
|
|
if object ~= nil and unit ~= nil and object.getFillUnitFreeCapacity ~= nil then
|
|
table.insert(parts, string.format("fri %.0f l", object:getFillUnitFreeCapacity(unit) or -1))
|
|
end
|
|
local cx, _, cz = ADLoadDiag.triggerCenter(trigger)
|
|
if cx ~= nil and cz ~= nil then
|
|
table.insert(parts, string.format("trigger ved x=%.0f z=%.0f", cx, cz))
|
|
end
|
|
end)
|
|
return table.concat(parts, ", ")
|
|
end
|
|
|
|
local function logFirstFill(trigger, vehicle, delta, result)
|
|
if not triggerLogDue(trigger, "fill") then return end
|
|
Logging.info(ADLoadDiag.LOG_PREFIX .. "første fyld-tik ved '%s' for '%s': %s (%s)", triggerName(trigger),
|
|
tostring(ADRuns.vehicleLabel(vehicle)), ADLoadDiag.describeFill(tonumber(delta), tonumber(result)), fillContext(trigger, vehicle))
|
|
end
|
|
|
|
-- spillets LoadTrigger:update: første fyld-tik efter start — hvad kilden faktisk gav. Kun for en start, der er sporet
|
|
-- (tracedStart), så spillerens egen fyldning koster intet pr. frame.
|
|
local function traceUpdate(trigger, dt, original)
|
|
local vehicle = tracedStart[trigger]
|
|
local source = trigger.source
|
|
if vehicle == nil or fillLogged[trigger] or not trigger.isLoading or source == nil
|
|
or source.addFillLevelToFillableObject == nil then
|
|
return original(trigger, dt)
|
|
end
|
|
-- logges i selve tikket: giver kilden 0, stopper triggeren i samme update, og stop-linjen skal komme efter.
|
|
-- Metoden er normalt nedarvet fra klassen: gendan instansens eget felt (nil), ikke en kopi af klassens funktion.
|
|
local own = rawget(source, "addFillLevelToFillableObject")
|
|
local add = source.addFillLevelToFillableObject
|
|
source.addFillLevelToFillableObject = function(self, ...)
|
|
local delta = select(4, ...)
|
|
local result = add(self, ...)
|
|
if not fillLogged[trigger] then
|
|
fillLogged[trigger] = true
|
|
pcall(logFirstFill, trigger, vehicle, delta, result)
|
|
end
|
|
return result
|
|
end
|
|
local ok, result = pcall(original, trigger, dt)
|
|
source.addFillLevelToFillableObject = own
|
|
if not ok then error(result, 0) end
|
|
return result
|
|
end
|
|
|
|
local isTraceInstalled = false
|
|
|
|
function ADLoadDiag.installTrace(adEnv)
|
|
if isTraceInstalled then return end
|
|
-- almindeligt opslag: i moddens miljø ligger spillets klasser bag en metatabel, som rawget springer over (17/10: sporingen blev aldrig installeret)
|
|
local class = LoadTrigger
|
|
local module = adEnv ~= nil and adEnv.ADTrailerModule or nil
|
|
if class == nil or class.setIsLoading == nil or class.update == nil or module == nil or module.startLoadingAtTrigger == nil then
|
|
Logging.warning(ADLoadDiag.LOG_PREFIX .. "sporing ikke installeret (LoadTrigger=%s, ADTrailerModule=%s)", tostring(class ~= nil), tostring(module ~= nil))
|
|
return
|
|
end
|
|
isTraceInstalled = true
|
|
Logging.info(ADLoadDiag.LOG_PREFIX .. "sporing af AD's startforsøg og spillets LoadTrigger er aktiv")
|
|
local originalAttempt = module.startLoadingAtTrigger
|
|
module.startLoadingAtTrigger = function(self, trigger, fillType, fillUnitIndex, trailer)
|
|
return traceAttempt(self, trigger, fillType, fillUnitIndex, trailer, originalAttempt)
|
|
end
|
|
local originalSet = class.setIsLoading
|
|
class.setIsLoading = function(self, isLoading, targetObject, fillUnitIndex, fillType, noEventSend)
|
|
return traceSetIsLoading(self, isLoading, targetObject, fillUnitIndex, fillType, noEventSend, originalSet)
|
|
end
|
|
local originalUpdate = class.update
|
|
class.update = function(self, dt)
|
|
return traceUpdate(self, dt, originalUpdate)
|
|
end
|
|
end
|
|
|
|
local isInstalled = false
|
|
|
|
function ADLoadDiag.install(adEnv)
|
|
local task = adEnv ~= nil and adEnv.LoadAtDestinationTask or nil
|
|
if isInstalled or task == nil or task.update == nil or adEnv.ADTriggerManager == nil then return end
|
|
isInstalled = true
|
|
local original = task.update
|
|
task.update = function(self, dt)
|
|
local result = original(self, dt)
|
|
local ok, err = pcall(ADLoadDiag.after, adEnv, self, dt)
|
|
if not ok and not self.spuDiagFailed then
|
|
self.spuDiagFailed = true
|
|
Logging.warning(ADLoadDiag.LOG_PREFIX .. "diagnose fejlede: %s", tostring(err))
|
|
end
|
|
return result
|
|
end
|
|
ADLoadDiag.installTrace(adEnv)
|
|
end
|