622 lines
29 KiB
Lua
622 lines
29 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,
|
|
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
|
|
|
|
-- É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 = {}
|
|
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))
|
|
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,
|
|
})
|
|
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"})
|
|
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).
|
|
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
|
|
if entry.kind == "chainProblem" then
|
|
table.insert(chains, {text = proxy:alertText(entry), level = "error"})
|
|
elseif entry.kind == "chainSuggest" then
|
|
table.insert(suggestions, {text = proxy:alertText(entry), level = "waiting"})
|
|
elseif entry.kind == "dependencyOff" then
|
|
table.insert(result.dependencies, {text = proxy:alertText(entry), level = "error"})
|
|
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"})
|
|
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"})
|
|
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
|
|
ADStatusHud.drag = {grabX = posX - layout.x, grabY = posY - layout.top}
|
|
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
|