Files
fs25-adsmartpickup/FS25_ADSmartPickup/adStatusHud.lua
T

667 lines
32 KiB
Lua

-- AD Status Hud
-- Statusvinduet på skærmen (i stil med Simple Inspector): slås til/fra med input-handlingen SPU_TOGGLE_STATUS
-- (standard numpad *; skifter fra -> problemer -> alt). Øjebliksbilledet bygges af modens egne statusfunktioner (samme som fanerne) højst
-- hvert sekund i update() og kun mens vinduet er tændt; draw() tegner kun de cachede linjer og bredder.
-- Tasten skifter fra -> kun problemer -> alt -> fra (ADStatusView mode "problems"/"all").
-- Synligheden, tilstanden og positionen gemmes pr. bruger i modSettings/FS25_ADSmartPickup/status.xml (standard skjult,
-- øverst til højre). Vinduet flyttes ved at trække i det med venstre musetast, når musemarkøren er fremme.
-- Kører kun på en klient (ikke dedikeret server). Alle spilkald er beskyttet; fejl logges én gang pr. nøgle.
ADStatusHud = {}
ADStatusHud.LOG_PREFIX = "ADSmartPickup: status: "
ADStatusHud.REFRESH_MS = 1000
ADStatusHud.STUCK_WARN_MS = 120000 -- stået stille så længe (uden at Smart Pickup holder den) = advarsel
ADStatusHud.TEXT_SIZE_PX = 14
ADStatusHud.MARGIN_PX = 8
ADStatusHud.SCREEN_OFFSET_PX = 16 -- afstand til skærmens højre kant
ADStatusHud.TOP_Y = 1 - 0.12 -- øverste kant (normaliseret); under spillets info-boks
ADStatusHud.SETTINGS_DIR = "modSettings/FS25_ADSmartPickup/"
ADStatusHud.SETTINGS_FILE = "status.xml"
ADStatusHud.SETTINGS_ROOT = "adSmartPickupStatus"
ADStatusHud.HEADER_COLOR = {1, 1, 1, 1}
ADStatusHud.visible = false
ADStatusHud.mode = "problems" -- "problems" = kun problembørn, "all" = alt
ADStatusHud.waitingSince = {} -- "runId:vehicleId" -> tid (ms) flowlinjen blev gul
ADStatusHud.lines = {} -- {{text, level, header, color, width}}
ADStatusHud.layout = nil -- {x, y, top, width, height, textSize, marginX, marginY, padding}
-- Flyttet position (nil = standard): anchor "right" = x er højre kant, "left" = x er venstre kant. Vinduets bredde
-- skifter med teksten hvert sekund, så den kant, der er nærmest skærmkanten, står fast (vokser væk fra kanten).
ADStatusHud.position = nil -- {x, top, anchor}
ADStatusHud.drag = nil -- {grabX, grabY} mens vinduet trækkes
local timerMs = 0
local settingsLoaded = false
local overlays = nil
local loggedErrors = {}
local registerToggleActionRef -- sat nederst (tastens handler til krogen)
-- ---- hjælpere ----
local function logOnce(key, err)
if loggedErrors[key] then return end
loggedErrors[key] = true
if Logging ~= nil and Logging.warning ~= nil then
Logging.warning(ADStatusHud.LOG_PREFIX .. "%s fejlede: %s", tostring(key), tostring(err))
end
end
local function guarded(key, fn, ...)
local ok, result = pcall(fn, ...)
if not ok then
logOnce(key, result)
return nil
end
return result
end
local function textOf(key)
if g_i18n == nil then return key end
local ok, text = pcall(g_i18n.getText, g_i18n, key)
return ok and text or key
end
function ADStatusHud.isClient()
local mission = g_currentMission
if mission == nil or mission.getIsClient == nil then return false end
local ok, isClient = pcall(mission.getIsClient, mission)
return ok and isClient == true
end
-- Fanernes egne tekst-/statusfunktioner ligger som metoder på SmartPickupFrame og bruger kun self.i18n:
-- en let "frame" med spillets i18n genbruger dem uden at røre menuen. "Start afvist" (lastStartFailed, rødt flow)
-- huskes på den rigtige ESC-fane (ADSmartPickup.guiFrame): tabellen deles, så vinduet viser samme farve som
-- Flows-listen (flowLevel rydder en afvisning når flowet kører — det samme som fanen selv gør).
local function frameProxy()
if SmartPickupFrame == nil then return nil end
local real = ADSmartPickup ~= nil and ADSmartPickup.guiFrame or nil
local failed = {}
if type(real) == "table" then
if type(real.lastStartFailed) ~= "table" then real.lastStartFailed = {} end
failed = real.lastStartFailed
end
return setmetatable({i18n = g_i18n, lastStartFailed = failed}, {__index = SmartPickupFrame})
end
local function fillTitle(fillType)
if fillType == nil or g_fillTypeManager == nil then return "?" end
local title = g_fillTypeManager.getFillTypeTitleByIndex ~= nil and g_fillTypeManager:getFillTypeTitleByIndex(fillType)
or g_fillTypeManager:getFillTypeNameByIndex(fillType)
return tostring(title or "?")
end
-- ---- øjebliksbillede ----
local WAGON_ACTIONS = {
fetching = {key = "spu_status_act_fetchWagon", level = "waiting"},
waiting = {key = "spu_status_act_waitWagon", level = "waiting"},
emptying = {key = "spu_status_act_emptying", level = "running"},
homing = {key = "spu_status_act_homing", level = "running"},
}
-- Traktorens handling som kort tekst + niveau (ADRunsController.getVehicleActivity som Flows-fanen).
local function vehicleAction(adEnv, vehicle)
local wagonState = ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) or nil
if wagonState ~= nil and WAGON_ACTIONS[wagonState] ~= nil then
return textOf(WAGON_ACTIONS[wagonState].key), WAGON_ACTIONS[wagonState].level
end
local activity = ADRunsController.getVehicleActivity(adEnv, vehicle)
local place = tostring(activity.place or "?")
if activity.kind == "stopped" then
return textOf("spu_activity_stopped"), "stopped"
elseif activity.kind == "waiting" then
return string.format(textOf("spu_status_act_waiting"), place), "waiting"
elseif activity.kind == "holding" then
return string.format(textOf("spu_status_act_holding"), place), "waiting"
elseif activity.kind == "empty" and activity.fillType ~= nil then
return string.format(textOf("spu_status_act_fetch"), fillTitle(activity.fillType), place), "running"
end
return string.format(textOf("spu_status_act_driving"), place), "running"
end
-- Fyld i % af hele vogntoget (AutoDrives egne opgørelser, som kildevalget bruger); nil uden kapacitet.
local function fillPercent(adEnv, vehicle)
local autoDrive = adEnv.AutoDrive
if autoDrive == nil or autoDrive.getAllUnits == nil or autoDrive.getAllFillLevels == nil then return nil end
local level, capacity = autoDrive.getAllFillLevels(autoDrive.getAllUnits(vehicle))
if type(level) ~= "number" or type(capacity) ~= "number" or capacity <= 0 then return nil end
return math.max(0, math.min(100, level / capacity * 100))
end
local function farmVehiclesById(adEnv)
local byId = {}
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local id = ADRunsController.getVehicleId(vehicle)
if id ~= nil then byId[id] = vehicle end
end
return byId
end
local function nowMs()
if type(g_time) == "number" then return g_time end
local mission = g_currentMission
return mission ~= nil and type(mission.time) == "number" and mission.time or 0
end
-- Hvor længe linjen har været gul (ms); nil når den ikke er gul. seen samler de nøgler, der stadig er gule.
local function waitingFor(key, level, seen)
if level ~= "waiting" then return nil end
seen[key] = true
local since = ADStatusHud.waitingSince[key]
if since == nil then
since = nowMs()
ADStatusHud.waitingSince[key] = since
end
return nowMs() - since
end
-- Én linje pr. traktor i et kørende flow (flows der kan stoppes: startet, eller holder vogn/henter).
function ADStatusHud.flowEntries(adEnv, proxy)
local entries = {}
if ADRunsController == nil or ADRunsController.store == nil or ADFlowView == nil then return entries end
local byId = farmVehiclesById(adEnv)
local seen = {}
for _, run in ipairs(ADFlowView.orderedRuns(ADRunsController.store.runs or {})) do
local status = ADRunsController.getRunStatus(adEnv, run)
if status.canStop then
local runLevel = proxy ~= nil and proxy.flowLevel ~= nil and guarded("flowLevel", proxy.flowLevel, proxy, adEnv, run) or nil
for _, vehicleId in ipairs(run.vehicleIds or {}) do
local vehicle = byId[vehicleId]
if vehicle ~= nil then
local action, level = vehicleAction(adEnv, vehicle)
-- farven følger flowets niveau som Flows-listen (venter/fejl), ellers traktorens egen handling
if runLevel == "error" or runLevel == "waiting" then level = runLevel end
table.insert(entries, {vehicle = tostring(ADRuns.vehicleLabel(vehicle)), action = action, target = vehicle,
fillPercent = guarded("fillPercent", fillPercent, adEnv, vehicle), level = level,
waitingMs = waitingFor(tostring(run.id) .. ":" .. tostring(vehicleId), level, seen)})
end
end
end
end
-- ikke længere gul (kører, stoppet, solgt): uret nulstilles
for key in pairs(ADStatusHud.waitingSince) do
if not seen[key] then ADStatusHud.waitingSince[key] = nil end
end
return entries
end
local FIELDS_TAB = {tab = "fields"}
-- Én linje pr. mark med aktivt markarbejde (samme statustekst og farve som Marker-fanen).
function ADStatusHud.fieldEntries(proxy)
local entries = {}
if ADFields == nil or ADFieldJobs == nil or ADFieldModel == nil or proxy == nil then return entries end
for _, info in ipairs(ADFields.list()) do
local field = ADFieldJobs.getField(info.id)
if field ~= nil and (ADFieldModel.isWorking(field) or ADFieldJobs.awaitingPlayer(info.id) ~= nil) then
local names, target = {}, nil
local reasonKey = type(field.reason) == "table" and field.reason.key or nil
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(info.id)) do
table.insert(names, ADRuns.vehicleLabel(assignment.vehicle))
target = target or assignment.vehicle
end
table.insert(entries, {
fieldId = info.id,
work = proxy:fieldStatusText(field, info, true),
vehicle = #names > 0 and ADFlowView.joinCounted(names, ", ", nil) or nil,
progress = SmartPickupFrame.monthCpProgress ~= nil and guarded("fieldProgress", SmartPickupFrame.monthCpProgress, info.id) or nil,
level = proxy:fieldLevel(info.id),
reason = type(reasonKey) == "string" and reasonKey:match("^spu_field_reason_(%w+)$") or nil,
awaiting = ADFieldJobs.awaitingPlayer(info.id) ~= nil,
target = target or FIELDS_TAB, -- ingen maskine endnu: klik åbner fanen Marker
})
end
end
return entries
end
-- Redskaber der mangler på gården: marker i gang hvis seneste udsendelse fejlede med noRig (rollen findes slet
-- ikke) eller cannotDo (ingen af dem kan opgaven, fx afgrøden). Én rød linje pr. rolle med markerne. Kø (allBusy,
-- venter på traktor, puljeredskab hentet til anden mark) står kun gult på marklinjen, ikke her.
function ADStatusHud.missingEntries(proxy)
local entries = {}
if ADFields == nil or ADFieldJobs == nil or ADFieldModel == nil or ADStatusView == nil or proxy == nil then return entries end
local paused = type(ADFieldJobs.state) == "table" and ADFieldJobs.state.paused == true
local found = {}
for _, info in ipairs(ADFields.list()) do
local field = ADFieldJobs.getField(info.id)
local reason = field ~= nil and type(field.reason) == "table" and field.reason or nil
local resumed = ADFieldJobs.isFieldResumed ~= nil and ADFieldJobs.isFieldResumed(info.id)
if reason ~= nil and reason.key ~= nil and ADFieldModel.isWorking(field) and (not paused or resumed) then
local kind = reason.key:match("^spu_field_reason_(%w+)$")
table.insert(found, {fieldId = info.id, role = reason.role, kind = kind})
end
end
for _, group in ipairs(ADStatusView.groupMissing(found)) do
local roleName = proxy.roleText ~= nil and guarded("roleText", proxy.roleText, proxy, group.role) or tostring(group.role)
local ok, text = pcall(string.format, textOf("spu_status_missing_" .. group.kind), roleName, ADStatusView.fieldList(group.fieldIds))
table.insert(entries, {text = ok and text or textOf("spu_status_missing_" .. group.kind), level = "error", target = FIELDS_TAB})
end
return entries
end
-- Kæder med manglende led + ventende forslag + slukkede nødvendige fabrikker (samme punkter og tekster som
-- "Kræver handling"; de to sidste står under Advarsler).
local CHAINS_TAB = {tab = "chains"}
function ADStatusHud.chainEntries(proxy)
local chains, suggestions = {}, {}
local result = {chains = chains, suggestions = suggestions, dependencies = {}}
if ADChain == nil or ADChain.last == nil or ADStorageStats == nil or ADStorageStats.chainEntries == nil or proxy == nil then
return result
end
for _, entry in ipairs(ADStorageStats.chainEntries(ADChain.last)) do
-- klik på en kædelinje åbner fanen Kæder (8/10)
if entry.kind == "chainProblem" then
table.insert(chains, {text = proxy:alertText(entry), level = "error", target = CHAINS_TAB})
elseif entry.kind == "chainSuggest" then
table.insert(suggestions, {text = proxy:alertText(entry), level = "waiting", target = CHAINS_TAB})
elseif entry.kind == "dependencyOff" then
table.insert(result.dependencies, {text = proxy:alertText(entry), level = "error", target = CHAINS_TAB})
end
end
-- ikke marker nok til kædens/dyrenes behov (8/10)
for _, entry in ipairs(ADChain.last.uncovered or {}) do
table.insert(suggestions, {text = ADChain.uncoveredText(entry, ADChain.last.titles, textOf), level = "waiting", target = CHAINS_TAB})
end
return result
end
-- Solgt/slettet køretøj (ADStuckDiag kan holde det et øjeblik efter salget).
local function isGone(vehicle)
if vehicle == nil or vehicle.isDeleted then return true end
if vehicle.rootNode == nil then return true end
return entityExists ~= nil and not entityExists(vehicle.rootNode)
end
-- Gårdens køretøjer der har stået stille over grænsen, uden at Smart Pickup selv holder dem (Wait/udkørsel).
function ADStatusHud.stuckEntries()
local entries = {}
if ADStuckDiag == nil or ADStuckDiag.stillVehicles == nil then return entries end
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
for _, still in ipairs(ADStuckDiag.stillVehicles(ADStatusHud.STUCK_WARN_MS)) do
local vehicle = still.vehicle
local owned = not isGone(vehicle) and (farmId == nil or (vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId))
local held = owned and ((ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil)
or (ADOutbound ~= nil and ADOutbound.getHoldFor ~= nil and ADOutbound.getHoldFor(vehicle) ~= nil))
if owned and not held then
table.insert(entries, {text = string.format(textOf("spu_status_stuck"), tostring(ADRuns.vehicleLabel(vehicle)),
math.floor(still.ms / 60000)), level = "error", target = vehicle})
end
end
return entries
end
function ADStatusHud.snapshot(adEnv)
local proxy = frameProxy()
local snapshot = {missing = {}, flows = {}, fields = {}, chains = {}, warnings = {}}
snapshot.missing = guarded("missing", ADStatusHud.missingEntries, proxy) or {}
if adEnv ~= nil then
snapshot.flows = guarded("flows", ADStatusHud.flowEntries, adEnv, proxy) or {}
end
snapshot.fields = guarded("fields", ADStatusHud.fieldEntries, proxy) or {}
local chainResult = guarded("chains", ADStatusHud.chainEntries, proxy) or {}
snapshot.chains = chainResult.chains or {}
for _, entry in ipairs(chainResult.dependencies or {}) do table.insert(snapshot.warnings, entry) end
for _, entry in ipairs(guarded("stuck", ADStatusHud.stuckEntries) or {}) do table.insert(snapshot.warnings, entry) end
for _, entry in ipairs(chainResult.suggestions or {}) do table.insert(snapshot.warnings, entry) end
return snapshot
end
-- ---- layout og cache (kun i update) ----
local function gameInfoDisplay()
local hud = g_currentMission ~= nil and g_currentMission.hud or nil
return hud ~= nil and hud.gameInfoDisplay or nil
end
-- Størrelser i skærmkoordinater, skaleret som spillets egen HUD (Simple Inspector-mønster).
local function measureUnits()
local display = gameInfoDisplay()
if display == nil or display.scalePixelToScreenHeight == nil or display.scalePixelToScreenVector == nil then return nil end
local textSize = display:scalePixelToScreenHeight(ADStatusHud.TEXT_SIZE_PX)
local marginX, marginY = display:scalePixelToScreenVector({ADStatusHud.MARGIN_PX, ADStatusHud.MARGIN_PX})
local offsetX = display:scalePixelToScreenVector({ADStatusHud.SCREEN_OFFSET_PX, 0})
return textSize, marginX, marginY, offsetX
end
-- Øverste kant: fast under info-boksen; ligger info-boksens position lavere, rykkes vinduet ned under den.
local function topY(marginY)
local top = ADStatusHud.TOP_Y
local display = gameInfoDisplay()
if display ~= nil and display.getPosition ~= nil then
local ok, _, y = pcall(display.getPosition, display)
if ok and type(y) == "number" and y > 0.5 and y < 1 then top = math.min(top, y - marginY) end
end
return top
end
local function clamp(value, low, high)
if high < low then return low end
return math.max(low, math.min(high, value))
end
-- Vinduets venstre kant og øverste kant: standard øverst til højre, ellers den flyttede position holdt på skærmen.
function ADStatusHud.place(width, height, padding, defaultX, defaultTop)
local pos = ADStatusHud.position
if pos == nil then return defaultX, defaultTop end
local x = pos.anchor == "left" and pos.x or pos.x - width
return clamp(x, padding, 1 - width - padding), clamp(pos.top, height, 1)
end
function ADStatusHud.rebuild(adEnv)
local lines = ADStatusView.lines(ADStatusHud.snapshot(adEnv), textOf, ADStatusView.MAX_LINES, ADStatusHud.mode)
local textSize, marginX, marginY, offsetX = measureUnits()
if textSize == nil then
-- spillets info-boks (skalering) findes ikke: vinduet kan ikke måles og tegnes
logOnce("measure", "gameInfoDisplay mangler eller kan ikke skalere")
ADStatusHud.lines, ADStatusHud.layout = {}, nil
return
end
local maxWidth = 0
for _, line in ipairs(lines) do
setTextBold(line.header == true)
line.width = getTextWidth(textSize, line.text)
line.color = line.header and ADStatusHud.HEADER_COLOR or (ADFlowView.LEVEL_COLORS[line.level] or ADStatusHud.HEADER_COLOR)
if line.width > maxWidth then maxWidth = line.width end
end
setTextBold(false)
local width = maxWidth + 2 * marginX
local height = #lines * textSize + 2 * marginY
local padding = marginX * 0.5
local x, top = ADStatusHud.place(width, height, padding, 1 - offsetX - width, topY(marginY))
ADStatusHud.lines = lines
ADStatusHud.layout = {x = x, y = top - height, top = top, width = width, height = height,
textSize = textSize, marginX = marginX, marginY = marginY, padding = padding}
end
-- ---- overlays ----
local function createOverlays()
if overlays ~= nil then return overlays end
if g_overlayManager == nil or HUD == nil or HUD.COLOR == nil or HUD.COLOR.BACKGROUND == nil then return nil end
local r, g, b, a = unpack(HUD.COLOR.BACKGROUND)
local created = {
middle = g_overlayManager:createOverlay("gui.gameInfo_middle", 0, 0, 0, 0),
left = g_overlayManager:createOverlay("gui.gameInfo_left", 0, 0, 0, 0),
right = g_overlayManager:createOverlay("gui.gameInfo_right", 0, 0, 0, 0),
}
for _, overlay in pairs(created) do overlay:setColor(r, g, b, a) end
overlays = created
return overlays
end
local function deleteOverlays()
if overlays == nil then return end
for _, overlay in pairs(overlays) do
if overlay.delete ~= nil then pcall(overlay.delete, overlay) end
end
overlays = nil
end
-- ---- indstillinger (pr. bruger, ikke i savegamet) ----
local function settingsPath()
if getUserProfileAppPath == nil then return nil end
return getUserProfileAppPath() .. ADStatusHud.SETTINGS_DIR .. ADStatusHud.SETTINGS_FILE
end
function ADStatusHud.loadSettings()
settingsLoaded = true
local path = settingsPath()
if path == nil or fileExists == nil or not fileExists(path) then return end
local xmlFile = XMLFile.load("ADSmartPickupStatus", path)
if xmlFile == nil then return end
local root = ADStatusHud.SETTINGS_ROOT
ADStatusHud.visible = xmlFile:getBool(root .. "#visible", false) == true
ADStatusHud.mode = xmlFile:getString(root .. "#mode") == "all" and "all" or "problems"
local x, top = xmlFile:getFloat(root .. ".position#x"), xmlFile:getFloat(root .. ".position#top")
local anchor = xmlFile:getString(root .. ".position#anchor")
if type(x) == "number" and type(top) == "number" and (anchor == "left" or anchor == "right") then
ADStatusHud.position = {x = clamp(x, 0, 1), top = clamp(top, 0, 1), anchor = anchor}
end
xmlFile:delete()
end
function ADStatusHud.saveSettings()
local path = settingsPath()
if path == nil then return end
if createFolder ~= nil then
createFolder(getUserProfileAppPath() .. "modSettings/")
createFolder(getUserProfileAppPath() .. ADStatusHud.SETTINGS_DIR)
end
local xmlFile = XMLFile.create("ADSmartPickupStatus", path, ADStatusHud.SETTINGS_ROOT)
if xmlFile == nil then
logOnce("saveSettings", "kunne ikke oprette " .. path)
return
end
local root = ADStatusHud.SETTINGS_ROOT
xmlFile:setBool(root .. "#visible", ADStatusHud.visible == true)
xmlFile:setString(root .. "#mode", ADStatusHud.mode)
local pos = ADStatusHud.position
if pos ~= nil then
xmlFile:setFloat(root .. ".position#x", pos.x)
xmlFile:setFloat(root .. ".position#top", pos.top)
xmlFile:setString(root .. ".position#anchor", pos.anchor)
end
xmlFile:save()
xmlFile:delete()
end
-- ---- offentlige kald fra moden ----
-- fra -> kun problemer -> alt -> fra
function ADStatusHud.toggle()
if not ADStatusHud.visible then
ADStatusHud.visible, ADStatusHud.mode = true, "problems"
elseif ADStatusHud.mode == "problems" then
ADStatusHud.mode = "all"
else
ADStatusHud.visible = false
end
timerMs = ADStatusHud.REFRESH_MS -- byg straks ved næste update
if not ADStatusHud.visible then ADStatusHud.lines, ADStatusHud.layout, ADStatusHud.drag = {}, nil, nil end
guarded("saveSettings", ADStatusHud.saveSettings)
end
-- Action-event-callback (target = ADStatusHud).
function ADStatusHud.onToggleAction()
ADStatusHud.toggle()
end
function ADStatusHud.update(dt, adEnv)
if not ADStatusHud.isClient() then return end
if not settingsLoaded then
guarded("loadSettings", ADStatusHud.loadSettings)
timerMs = ADStatusHud.REFRESH_MS
end
if not ADStatusHud.visible then return end
timerMs = timerMs + (dt or 0)
if timerMs < ADStatusHud.REFRESH_MS then return end
timerMs = 0
guarded("rebuild", ADStatusHud.rebuild, adEnv)
end
-- Tegnes ikke ved åben menu/dialog, skjult HUD, søvn eller åben chat.
local function shouldSkipDraw()
if g_gui ~= nil and g_gui:getIsGuiVisible() then return true end
if g_noHudModeEnabled then return true end
local mission = g_currentMission
local hud = mission ~= nil and mission.hud or nil
if hud == nil or hud.isVisible == false then return true end
if g_sleepManager ~= nil and g_sleepManager.getIsSleeping ~= nil and g_sleepManager:getIsSleeping() then return true end
if hud.chatDisplay ~= nil and hud.chatDisplay.getVisible ~= nil and hud.chatDisplay:getVisible() then return true end
return false
end
local function render(layout, bg)
bg.middle:setDimension(layout.width, layout.height)
bg.middle:setPosition(layout.x, layout.y)
bg.middle:render()
bg.left:setDimension(layout.padding, layout.height)
bg.left:setPosition(layout.x - layout.padding, layout.y)
bg.left:render()
bg.right:setDimension(layout.padding, layout.height)
bg.right:setPosition(layout.x + layout.width, layout.y)
bg.right:render()
setTextAlignment(RenderText.ALIGN_LEFT)
setTextVerticalAlignment(RenderText.VERTICAL_ALIGN_TOP)
local textX, textY = layout.x + layout.marginX, layout.top - layout.marginY
for _, line in ipairs(ADStatusHud.lines) do
local color = line.color
setTextBold(line.header == true)
setTextColor(color[1], color[2], color[3], color[4])
renderText(textX, textY, layout.textSize, line.text)
textY = textY - layout.textSize
end
end
function ADStatusHud.draw()
if not ADStatusHud.visible or ADStatusHud.layout == nil or #ADStatusHud.lines == 0 then return end
if shouldSkipDraw() then return end
local ok0, bg = pcall(createOverlays)
if not ok0 or bg == nil then
-- uden baggrund tegnes intet (g_overlayManager/HUD.COLOR mangler eller createOverlay fejlede)
logOnce("overlays", ok0 and "g_overlayManager eller HUD.COLOR.BACKGROUND mangler" or bg)
return
end
local ok, err = pcall(render, ADStatusHud.layout, bg)
-- tekststate nulstilles altid, også efter en fejl (andre mods/spillet tegner videre med den)
setTextColor(1, 1, 1, 1)
setTextAlignment(RenderText.ALIGN_LEFT)
setTextVerticalAlignment(RenderText.VERTICAL_ALIGN_BASELINE)
setTextBold(false)
if not ok then logOnce("draw", err) end
end
-- ---- flytning med musen ----
local function cursorShown()
return g_inputBinding ~= nil and g_inputBinding.getShowMouseCursor ~= nil and g_inputBinding:getShowMouseCursor() == true
end
local function isInside(layout, posX, posY)
return posX >= layout.x - layout.padding and posX <= layout.x + layout.width + layout.padding
and posY >= layout.y and posY <= layout.top
end
-- Ny position fra venstre/øverste kant: holdes på skærmen, og kanten nærmest skærmkanten bliver ankeret.
local function moveTo(layout, left, top)
left = clamp(left, layout.padding, 1 - layout.width - layout.padding)
top = clamp(top, layout.height, 1)
layout.x, layout.top, layout.y = left, top, top - layout.height
if left + layout.width / 2 > 0.5 then
ADStatusHud.position = {x = left + layout.width, top = top, anchor = "right"}
else
ADStatusHud.position = {x = left, top = top, anchor = "left"}
end
end
-- Mod-event (ADSmartPickup:mouseEvent): venstre tast ned i vinduet griber det, bevægelse flytter, slip gemmer.
function ADStatusHud.mouseEvent(posX, posY, isDown, isUp, button)
local layout = ADStatusHud.layout
local drag = ADStatusHud.drag
if drag ~= nil then
if layout == nil or not cursorShown() then
ADStatusHud.drag = nil
guarded("saveSettings", ADStatusHud.saveSettings)
return
end
moveTo(layout, posX - drag.grabX, posY - drag.grabY)
if isUp then
ADStatusHud.drag = nil
guarded("saveSettings", ADStatusHud.saveSettings)
end
return
end
local leftButton = Input ~= nil and Input.MOUSE_BUTTON_LEFT or 1
if not isDown or button ~= leftButton then return end
if not ADStatusHud.visible or layout == nil or #ADStatusHud.lines == 0 then return end
if not cursorShown() or shouldSkipDraw() or not isInside(layout, posX, posY) then return end
-- klik på en linje med et køretøj: ind i køretøjet (brugerønske 8/10); ellers flyttes vinduet
local index = ADStatusView.lineAt(layout.top, layout.marginY, layout.textSize, #ADStatusHud.lines, posY)
local line = index ~= nil and ADStatusHud.lines[index] or nil
if line ~= nil and line.target ~= nil then
if line.target.tab ~= nil then
if ADStatusHud.openTab(line.target.tab) then return end
elseif ADStatusHud.enterVehicle(line.target) then
return
end
end
ADStatusHud.drag = {grabX = posX - layout.x, grabY = posY - layout.top}
end
-- Åbn ESC-menuen på Smart Pickup-fanen med en bestemt underfane ("chains"). -> true hvis forsøgt
function ADStatusHud.openTab(tab)
local frame = ADSmartPickup ~= nil and ADSmartPickup.guiFrame or nil
local tabs = SmartPickupFrame ~= nil and {chains = SmartPickupFrame.TAB_CHAINS, fields = SmartPickupFrame.TAB_FIELDS} or {}
local tabIndex = tabs[tab]
if frame == nil or tabIndex == nil or g_gui == nil then return false end
local ok, err = pcall(function()
frame.pendingTab = tabIndex
g_gui:showGui("InGameMenu")
local menu = g_gui.screenControllers ~= nil and InGameMenu ~= nil and g_gui.screenControllers[InGameMenu] or nil
if menu ~= nil and menu.goToPage ~= nil then menu:goToPage(frame) end
end)
if not ok then logOnce("openTab", err) end
return ok
end
-- Sæt spilleren ind i køretøjet (et redskab: traktoren det sidder på). -> true hvis forsøgt
function ADStatusHud.enterVehicle(vehicle)
if isGone(vehicle) then return false end
local root = vehicle.getRootVehicle ~= nil and vehicle:getRootVehicle() or vehicle
if root == nil or root.spec_enterable == nil then return false end
local player = g_localPlayer
if player == nil or player.requestToEnterVehicle == nil then return false end
local ok, err = pcall(player.requestToEnterVehicle, player, root)
if not ok then logOnce("enter", err) end
return ok
end
function ADStatusHud.delete()
deleteOverlays()
if PlayerInputComponent ~= nil and PlayerInputComponent.spuStatusToggleHandler == registerToggleActionRef then
PlayerInputComponent.spuStatusToggleHandler = nil
end
ADStatusHud.lines, ADStatusHud.layout, ADStatusHud.drag, ADStatusHud.position = {}, nil, nil, nil
settingsLoaded = false
timerMs = 0
end
-- ---- tast: global spiller-handling (til fods og i køretøjer) ----
-- PlayerInputComponent.registerGlobalPlayerActionEvents kaldes ved hvert kontekstskift (til fods / i køretøj);
-- samme mønster som FS25_Courseplay (CP_OPEN_INGAME_MENU) og FS25_EasyDevControls. Hjælpeteksten skjules i F1.
local function registerToggleAction(component)
if not ADStatusHud.isClient() then return end
local player = component ~= nil and component.player or nil
if player ~= nil and player.isOwner == false then return end
if g_inputBinding == nil or InputAction == nil or InputAction.SPU_TOGGLE_STATUS == nil then return end
local _, eventId = g_inputBinding:registerActionEvent(InputAction.SPU_TOGGLE_STATUS, ADStatusHud, ADStatusHud.onToggleAction,
false, true, false, true)
if eventId ~= nil then g_inputBinding:setActionEventTextVisibility(eventId, false) end
end
registerToggleActionRef = function(component) guarded("registerAction", registerToggleAction, component) end
-- Spillets klasse overlever en genindlæsning af savegamet, moden gør ikke: krogen lægges kun én gang (markør på
-- klassen) og kalder den aktuelle indlæsnings handler, så en gammel ADStatusHud aldrig registrerer tasten igen.
function ADStatusHud.installInputHook()
if PlayerInputComponent == nil or PlayerInputComponent.registerGlobalPlayerActionEvents == nil or Utils == nil then return false end
PlayerInputComponent.spuStatusToggleHandler = registerToggleActionRef
if PlayerInputComponent.spuStatusToggleHooked then return true end
PlayerInputComponent.registerGlobalPlayerActionEvents = Utils.appendedFunction(PlayerInputComponent.registerGlobalPlayerActionEvents,
function(component, ...)
local handler = PlayerInputComponent.spuStatusToggleHandler
if handler ~= nil then handler(component) end
end)
PlayerInputComponent.spuStatusToggleHooked = true
return true
end
if PlayerInputComponent ~= nil and Utils ~= nil then
ADStatusHud.installInputHook()
end