Files
fs25-adsmartpickup/FS25_ADSmartPickup/adPlayerTransport.lua
T

469 lines
27 KiB
Lua

-- AD Player Transport
-- Spillerkørsel for alle markredskaber (brugerønske 10/10: ny gård uden plads til parkeringer). Et sæt uden
-- AutoDrive-parkering kører ikke selv: moden beder spilleren køre det (eller koble et frakoblet redskab på en
-- traktor) til marken og stige ud; så kører Courseplay marken. Når det er færdigt, beder moden spilleren køre det
-- væk, indtil det har forladt marken. Én opgave ad gangen. Reglerne ligger i ADManualTransport (testbare);
-- dette er spil-delen. Pop-up eller kun statusvinduet: indstillingen playerPopup (ADFieldWork.tellPlayer).
ADPlayerTransport = {}
-- maskiner der er færdige og skal køres væk: vehicleId -> {vehicle, fieldId, label}
ADPlayerTransport.pickups = {}
-- overtagelser hvor spilleren har koblet et frakoblet redskab på en traktor: opgaven flyttes til traktorens id
-- EFTER opfølgningsløkken (en ny nøgle i state.assignments under pairs-gennemløbet er udefineret i Lua)
ADPlayerTransport.pendingTakeovers = {}
-- "kør videre": færdige sæt der skal direkte til næste mark med samme rolle (oprettes efter opfølgningsløkken)
ADPlayerTransport.pendingContinues = {}
local function log(...) ADFieldJobs.log(...) end
local function note(...) ADFieldJobs.note(...) end
local function now() return ADFieldJobs.now end
local function label(vehicle) return ADRuns.vehicleLabel(vehicle) end
-- Parkeringsrådgiver: tæl hver gang spilleren har kørt maskinen ud (gemmes med markerne).
local function countTrip(id, vehicle)
if id == nil then return end
local trips = ADFieldJobs.state.playerTrips or {}
ADFieldJobs.state.playerTrips = trips
local trip = trips[id] or {count = 0}
trips[id] = {count = (trip.count or 0) + 1, label = label(vehicle)}
ADFieldJobs.save()
end
local function rootOf(vehicle)
if vehicle ~= nil and vehicle.getRootVehicle ~= nil then
local ok, root = pcall(vehicle.getRootVehicle, vehicle)
if ok and root ~= nil then return root end
end
return vehicle
end
-- Har køretøjet (med det der hænger på) rollen? (traktor + plov = plov; plov + kultivator-rolle via EXTRA_ROLES)
local function hasRole(vehicle, role)
local specs = ADCpBridge.getSpecs(vehicle)
local own = ADFieldFleet.roleFromSpecs(specs)
if own == role then return true end
local roles = ADPool.rolesOf(own, specs.sprayRoles)
return roles ~= nil and roles[role] == true
end
-- Kører spillets hjælper sættet ud (i stedet for spilleren)? Indstillingen playerDrive, og altid på kontraktmarker
-- uden AutoDrive-markør.
local function useHelper(field, info)
local setting = ADSettings ~= nil and ADSettings.get("playerDrive") or 2
return ADManualTransport.useHelper(setting, field.contract == true and info.markerId == nil)
end
local function isOnField(adEnv, info, x, z)
if #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(x, z, info.verts) then return true end
if info.markerId == nil then return false end
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
return wayPoint ~= nil and math.sqrt((wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2) <= ADFieldWork.ARRIVE_DISTANCE
end
-- Skal sættet køres af spilleren? Kun markredskaber (ADManualTransport.PLAYER_ROLES), uden parkering eller langt
-- fra vejnettet.
function ADPlayerTransport.needsPlayer(adEnv, candidate, role, decision)
if not ADManualTransport.PLAYER_ROLES[role] or (decision ~= nil and decision.helper) then return false end
local d = candidate.x ~= nil and ADFieldWork.distanceToNetwork(adEnv, candidate.x, candidate.z) or nil
return ADManualTransport.needsPlayer({role = role, hasPark = candidate.hasPark == true,
nearNetwork = d == nil or d <= ADFieldWork.MAX_OFF_NETWORK})
end
local function waitingList()
local list = {}
for _, assignment in pairs(ADFieldJobs.state.assignments) do
if assignment.phase == "awaitingPlayer" then table.insert(list, {fieldId = assignment.fieldId}) end
end
return list
end
-- Frakoblede redskaber med rollen. Returnerer det nærmeste uden AutoDrive-parkering (spilleren kobler det på) og
-- om der findes et MED parkering — det henter puljen selv (også når det er i brug), så spilleren spørges ikke.
local function looseImplement(adEnv, role, x, z, required, roleAccept, only)
local farmId = g_currentMission:getFarmId()
local best, bestD, parkedExists = nil, nil, false
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
local owned = vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId
local free = owned and vehicle.spec_motorized == nil and vehicle.spec_attachable ~= nil
and not (vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() ~= nil)
local id = free and (only == nil or only(vehicle)) and ADRunsController.getVehicleId(vehicle) or nil
local specs = id ~= nil and ADCpBridge.getSpecs(vehicle) or nil
local own = specs ~= nil and ADPool.roleOf(specs) or nil
local roles = own ~= nil and ADPool.rolesOf(own, specs.sprayRoles) or nil
if own ~= nil and (own == role or (roles ~= nil and roles[role])) then
if ADFieldWork.parkMarkerId(adEnv, vehicle) ~= nil then
parkedExists = true
elseif ADFieldJobs.state.assignments[id] == nil and not ADPool.isReserved(id)
and (roleAccept == nil or roleAccept({role = own, roles = roles, vehicle = vehicle}))
and ADFieldModel.checkWidth(role, ADCpBridge.getWorkWidth(vehicle) or 0, required) then
local vx, _, vz = getWorldTranslation(vehicle.rootNode)
local d = (vx - x) ^ 2 + (vz - z) ^ 2
if bestD == nil or d < bestD then best, bestD = vehicle, d end
end
end
end
return best, parkedExists
end
-- Kontraktmark: et løst lånt redskab (kontraktens udstyr) med rollen, og intet lånt sæt er samlet -> bed spilleren
-- koble det på (hjælperen kører det ud bagefter). true = håndteret.
function ADPlayerTransport.dispatchLeasedImplement(adEnv, field, info, role, required, roleAccept)
if not field.contract or ADContracts == nil then return false end
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(field.id)) do
if assignment.phase == "awaitingPlayer" then return true end
end
local implement = looseImplement(adEnv, role, info.x, info.z, required, roleAccept,
function(vehicle) return ADContracts.isLeasedFor(field, vehicle) end)
if implement == nil then return false end
if not ADManualTransport.mayAskPlayer(waitingList(), field.id) then
note(field.id, {reason = {text = "venter på dig — kør først den maskine, du allerede er bedt om"},
retryAt = now() + ADFieldWork.NO_RIG_RETRY_MS})
return true
end
local assignment = ADPlayerTransport.newAssignment(field, role, implement, ADRunsController.getVehicleId(implement), true)
if not useHelper(field, info) then ADPlayerTransport.ask(field, info, assignment, true) end
log(field.id, "kontraktens lånte '%s' står løst — spilleren bedes koble den på", label(implement))
return true
end
-- Kan et sæt med rollen køre selv (parkering, ved vejnettet)? Også når det er optaget: så venter marken i kø.
local function selfDrivingExists(adEnv, candidates, role, decision, roleAccept)
for _, candidate in ipairs(candidates) do
local hasRole = candidate.role == role or (candidate.roles ~= nil and candidate.roles[role] == true)
if hasRole and candidate.enabled and (roleAccept == nil or roleAccept(candidate))
and not ADPlayerTransport.needsPlayer(adEnv, candidate, role, decision) then
return true
end
end
return false
end
-- Intet sæt kan køre selv: bed spilleren køre et (eller koble et frakoblet redskab på). true = håndteret
-- (spurgt, eller venter på at en anden opgave til spilleren er klaret).
function ADPlayerTransport.dispatch(adEnv, field, info, role, decision, candidates, required, roleAccept)
-- mejetærsker kun på en kontraktmark uden F-markør (ellers kører den selv eller følger sit eget flueben)
local contractHarvester = role == "harvester" and info.markerId == nil and field.contract == true
if (not ADManualTransport.PLAYER_ROLES[role] and not contractHarvester) or (decision ~= nil and decision.helper) then return false end
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(field.id)) do
if assignment.phase == "awaitingPlayer" then return true end
end
-- uden F-markør (kontraktmark) kører spillets hjælper sættene derud (ADFieldWork.dispatch); spilleren spørges kun,
-- når gården slet intet har med rollen, som hjælperen kan køre (fx kun en mejetærsker uden skærebord)
local forcePlayer = info.markerId == nil
if forcePlayer and field.contract then
for _, candidate in ipairs(candidates) do
local hasRole = candidate.role == role or (candidate.roles ~= nil and candidate.roles[role] == true)
if hasRole and candidate.enabled and (roleAccept == nil or roleAccept(candidate)) and candidate.headerOptions == nil then
return false
end
end
end
-- kun når INTET kan køre selv: et optaget sæt eller puljeredskab med parkering betyder kø, ikke spillerkørsel
if not forcePlayer and selfDrivingExists(adEnv, candidates, role, decision, roleAccept) then return false end
-- sidder spilleren allerede i sættet, er det netop det, spilleren skal køre (pick springer ellers førersædet over)
local playerCandidates = {}
for index, candidate in ipairs(candidates) do
local copy = {}
for key, value in pairs(candidate) do copy[key] = value end
copy.controlled = false
playerCandidates[index] = copy
end
local rig = ADFieldFleet.pick(playerCandidates, role, info.x, info.z, required, function(candidate)
return (roleAccept == nil or roleAccept(candidate)) and (forcePlayer or ADPlayerTransport.needsPlayer(adEnv, candidate, role, decision))
end)
local implement, parkedExists = nil, false
if rig == nil then implement, parkedExists = looseImplement(adEnv, role, info.x, info.z, required, roleAccept) end
if (parkedExists and not forcePlayer) or (rig == nil and implement == nil) then return false end
if not ADManualTransport.mayAskPlayer(waitingList(), field.id) then
note(field.id, {reason = {text = "venter på dig — kør først den maskine, du allerede er bedt om"},
retryAt = now() + ADFieldWork.NO_RIG_RETRY_MS})
return true
end
local vehicle = rig ~= nil and rig.vehicle or implement
local id = rig ~= nil and rig.id or ADRunsController.getVehicleId(implement)
local assignment = ADPlayerTransport.newAssignment(field, role, vehicle, id, rig == nil)
-- hjælper-tilstand: er sættet allerede samlet og fyldt, kører hjælperen det ud uden at spørge (ADPlayerTransport.follow)
if not useHelper(field, info) then ADPlayerTransport.ask(field, info, assignment, true) end
return true
end
-- Opgave der venter på spilleren (registreres i state.assignments).
function ADPlayerTransport.newAssignment(field, role, vehicle, id, implementOnly)
local x, z = ADFieldWork.vehiclePosition(vehicle)
local assignment = {
vehicleId = id, vehicle = vehicle, fieldId = field.id, role = role, stage = field.stage, helper = false,
phase = "awaitingPlayer", since = now(), width = ADCpBridge.getWorkWidth(vehicle),
groupSize = 1, leader = true, manual = true, playerTransport = true, implementOnly = implementOnly == true,
startX = x, startZ = z,
}
ADFieldJobs.state.assignments[id] = assignment
return assignment
end
-- Marker der lige nu venter på et sæt med rollen (seneste beslutning "dispatch"), til "kør videre".
local function fieldsWaitingFor(role)
local list = {}
for _, info in ipairs(ADFields.list()) do
local decision = ADFieldJobs.lastDecision[info.id]
if decision ~= nil and decision.action == "dispatch" and decision.role == role and not decision.helper then
table.insert(list, {fieldId = info.id, role = role, x = info.x, z = info.z, busy = #ADFieldJobs.assignmentsFor(info.id) > 0})
end
end
return list
end
function ADPlayerTransport.ask(field, info, assignment, withDialog, missing)
local where = tostring(info.markerName or ("F" .. tostring(field.id)))
local text
if useHelper(field, info) and not assignment.giantsFailed then
-- spillets hjælper kører: spilleren skal kun gøre sættet klar
text = string.format("F%s skal %s med '%s': %s — så kører spillets hjælper den ud, og Smart Pickup overtager",
tostring(field.id), ADManualTransport.stageVerb(assignment.stage), label(assignment.vehicle), tostring(missing or "gør den klar"))
elseif assignment.implementOnly then
text = string.format("F%s skal %s: kobl '%s' på en traktor, kør den til %s og stig ud — så overtager Smart Pickup",
tostring(field.id), ADManualTransport.stageVerb(assignment.stage), label(assignment.vehicle), where)
else
text = string.format("F%s skal %s: kør '%s' til %s og stig ud — så overtager Smart Pickup",
tostring(field.id), ADManualTransport.stageVerb(assignment.stage), label(assignment.vehicle), where)
end
-- næsten tom tank eller stort slid: sig det med det samme (AutoDrive tanker ikke en maskine, spilleren kører)
local maintenance = ADMaintenance ~= nil and ADMaintenance.playerNote(assignment.vehicle) or nil
if maintenance ~= nil then text = text .. maintenance end
assignment.remindedAt = now()
log(field.id, "venter på spilleren: %s", text)
ADFieldWork.tellPlayer(text, withDialog)
end
local REASON_TEXT = {
noTractor = "kobl redskabet på en traktor",
empty = "fyld den op",
notThere = "kør den til marken",
playerInside = "stig ud, så overtager Smart Pickup",
}
-- Venter på spilleren: overtag, når sættet står på marken med redskabet på, er fyldt, og spilleren er steget ud
-- (eller [Overtag] i marklisten). Påmindelse hvert 5. minut.
function ADPlayerTransport.follow(adEnv, field, info, assignment)
local vehicle = assignment.implementOnly and rootOf(assignment.vehicle) or assignment.vehicle
local attached = vehicle ~= nil and vehicle.spec_motorized ~= nil and hasRole(vehicle, assignment.role)
-- mejetærsker: skærebordet skal sidde på og kunne høste afgrøden
local needsHeader = assignment.role == "harvester"
if attached and needsHeader then
attached = (ADCpBridge.getHarvestFruits(vehicle) or {})[info.fruitIndex] == true
end
local empty = false
if attached and ADFieldWork.REFILL_ROLES[assignment.role] then
local fillType = ADCpBridge.getRefillFillType(vehicle, assignment.role)
empty = fillType ~= nil and ADCpBridge.getRefillLevel(vehicle, fillType) <= 0
end
local x, z = ADFieldWork.vehiclePosition(vehicle)
-- spilleren kørte til en ANDEN mark, der også venter på et sæt med rollen: opgaven flyttes dertil (rækkefølgen er
-- spillerens valg, brugerønske 10/10)
if not isOnField(adEnv, info, x, z) then
for _, other in ipairs(fieldsWaitingFor(assignment.role)) do
local otherInfo = ADFields.getInfo(other.fieldId)
if other.fieldId ~= field.id and not other.busy and otherInfo ~= nil and isOnField(adEnv, otherInfo, x, z) then
log(field.id, "'%s' står på F%s, der også venter — opgaven flyttes dertil", label(vehicle), tostring(other.fieldId))
note(field.id, {reason = false})
local otherField = ADFieldJobs.getField(other.fieldId)
assignment.fieldId, assignment.stage = other.fieldId, otherField.stage
field, info = otherField, otherInfo
break
end
end
end
local forced = ADFieldJobs.takeoverRequested[field.id] == true
ADFieldJobs.takeoverRequested[field.id] = nil
-- hjælperen fandt ingen vej før (giantsFailed): spilleren kører denne opgave
local helper = useHelper(field, info) and not assignment.giantsFailed
local controlled = ADFieldWork.isControlledByPlayer(vehicle)
local ok, why
if helper then
-- spillets hjælper: samlet, fyldt og spilleren ude i HELPER_SETTLE_MS -> den kører ud selv (stedet er
-- ligegyldigt). Ventetiden: spilleren står måske af for at koble mere på eller fylde op (review 10/10)
ok, why = ADManualTransport.helperReadiness({attached = attached, empty = empty, controlled = controlled and not forced})
if ok then
assignment.readySince = assignment.readySince or now()
if not forced and not ADManualTransport.helperSettled(assignment.readySince, now()) then
note(field.id, {reason = {text = string.format("'%s' er klar — spillets hjælper kører den ud om lidt", label(assignment.vehicle))}})
return
end
else
assignment.readySince = nil
end
else
ok, why = ADManualTransport.playerReadiness({attached = attached, atField = isOnField(adEnv, info, x, z),
controlled = controlled, empty = empty, forced = forced})
end
if ok then
-- uden for marken med hjælperen: Courseplay-jobbets kørsel (spillets vejfinding) tager den derud. Kun med en
-- markkant — ellers kan "fremme" (ADFieldWork.follow) aldrig måles, og tømmevognene ville vente for evigt
local giants = helper and #(info.verts or {}) >= 3 and not isOnField(adEnv, info, x, z)
if assignment.implementOnly then
table.insert(ADPlayerTransport.pendingTakeovers, {assignment = assignment, vehicle = vehicle, forced = forced, giants = giants,
helper = helper})
return
end
assignment.giants = giants or nil
log(field.id, "overtager '%s'%s%s", label(vehicle), forced and " ([Overtag])" or "", giants and " — spillets hjælper kører den ud" or "")
-- parkeringsrådgiveren tæller kun ture, spilleren selv har kørt
if not helper then countTrip(assignment.vehicleId, vehicle) end
return ADFieldWork.beginWork(adEnv, field, info, assignment)
end
local reason = REASON_TEXT[why] or tostring(why)
if helper and why == "playerInside" then reason = "stig ud" end
if why == "noTractor" and needsHeader then
reason = "montér et skærebord, der kan høste afgrøden"
elseif why == "noTractor" and not assignment.implementOnly then
reason = "kobl redskabet på igen"
end
note(field.id, {reason = {text = string.format("venter på dig: '%s' — %s", label(assignment.vehicle), reason)}})
if forced then
ADFieldJobs.notify(string.format("F%s: kan ikke starte '%s' endnu — %s", tostring(field.id), label(assignment.vehicle), reason), true)
elseif ADManualTransport.shouldRemind(assignment.remindedAt, now()) then
-- første gang som pop-up (hjælper-tilstand spørger først her, når noget mangler), derefter i hjørnet
ADPlayerTransport.ask(field, info, assignment, assignment.remindedAt == nil, reason)
end
end
-- Efter opfølgningsløkken: færdige sæt sendes videre til næste mark ("kør videre"); kan det ikke længere, bedes
-- spilleren køre det væk som ellers.
local function applyContinues()
local list = ADPlayerTransport.pendingContinues
if #list == 0 then return end
ADPlayerTransport.pendingContinues = {}
for _, entry in ipairs(list) do
local field, info = ADFieldJobs.getField(entry.fieldId), ADFields.getInfo(entry.fieldId)
local free = ADFieldJobs.state.assignments[entry.vehicleId] == nil and #ADFieldJobs.assignmentsFor(entry.fieldId) == 0
if free and info ~= nil and ADFieldModel.isWorking(field) and ADFieldModel.ROLES[field.stage] == entry.role then
local assignment = ADPlayerTransport.newAssignment(field, entry.role, entry.vehicle, entry.vehicleId, false)
if useHelper(field, info) then
-- hjælperen kører den videre (follow overtager, så snart den er klar) — ingen pop-up
-- (mangler noget, spørger follow straks med pop-up — remindedAt forbliver nil)
log(entry.fieldId, "kør videre fra F%s: '%s' — spillets hjælper kører den", tostring(entry.fromFieldId), label(entry.vehicle))
else
local text = string.format("F%s er færdig — kør '%s' videre til %s og stig ud, så overtager Smart Pickup",
tostring(entry.fromFieldId), label(entry.vehicle), tostring(info.markerName or ("F" .. tostring(entry.fieldId))))
assignment.remindedAt = now()
log(entry.fieldId, "kør videre fra F%s: %s", tostring(entry.fromFieldId), text)
ADFieldWork.tellPlayer(text, true)
end
else
ADPlayerTransport.finished({vehicle = entry.vehicle, vehicleId = entry.vehicleId, fieldId = entry.fromFieldId, role = entry.role}, true)
end
end
end
-- Efter opfølgningsløkken: opgaven på et frakoblet redskab flyttes til traktoren, det nu hænger på, og startes.
function ADPlayerTransport.applyTakeovers(adEnv)
applyContinues()
local list = ADPlayerTransport.pendingTakeovers
if #list == 0 then return end
ADPlayerTransport.pendingTakeovers = {}
for _, entry in ipairs(list) do
local assignment, vehicle = entry.assignment, entry.vehicle
local state = ADFieldJobs.state.assignments
local tractorId = ADRunsController.getVehicleId(vehicle)
local field, info = ADFieldJobs.getField(assignment.fieldId), ADFields.getInfo(assignment.fieldId)
local tractorBusy = tractorId ~= nil and state[tractorId] ~= nil and state[tractorId] ~= assignment
if tractorBusy then
note(assignment.fieldId, {reason = {text = string.format("venter: '%s' har en anden opgave — kobl redskabet på en anden traktor", label(vehicle))}})
elseif state[assignment.vehicleId] == assignment and tractorId ~= nil and info ~= nil then
-- det frakoblede redskab er det, der mangler en parkering (og en Connect-markør); kun spillerens egne ture
if not entry.giants and not entry.helper then countTrip(assignment.vehicleId, assignment.vehicle) end
state[assignment.vehicleId] = nil
assignment.vehicleId, assignment.vehicle, assignment.implementOnly = tractorId, vehicle, false
assignment.giants = entry.giants or nil
assignment.width = ADCpBridge.getWorkWidth(vehicle) or assignment.width
state[tractorId] = assignment
log(assignment.fieldId, "overtager '%s'%s%s", label(vehicle), entry.forced and " ([Overtag])" or "",
entry.giants and " — spillets hjælper kører den ud" or "")
ADFieldWork.beginWork(adEnv, field, info, assignment)
end
end
end
-- Færdig uden parkering: bed spilleren køre den væk; den står i statusvinduet, til den har forladt marken.
-- noContinue: spring "kør videre" over (bruges når næste mark ikke længere kunne tage den).
function ADPlayerTransport.finished(assignment, noContinue)
local vehicle = assignment.vehicle
-- kør videre: venter en anden mark på samme slags sæt, køres der direkte derhen i stedet for væk (brugerønske 10/10)
if assignment.role ~= "harvester" and not noContinue then
local x, z = ADFieldWork.vehiclePosition(vehicle)
local nextId = ADManualTransport.nextField(fieldsWaitingFor(assignment.role), assignment.role, x, z, assignment.fieldId)
if nextId ~= nil then
table.insert(ADPlayerTransport.pendingContinues, {vehicle = vehicle, vehicleId = assignment.vehicleId,
role = assignment.role, fromFieldId = assignment.fieldId, fieldId = nextId})
return
end
end
local text = string.format("F%s: '%s' er færdig — kør den væk fra marken", tostring(assignment.fieldId), label(vehicle))
if assignment.role == "harvester" then
text = string.format("F%s er høstet — afmontér skærebordet og kør '%s' væk fra marken", tostring(assignment.fieldId), label(vehicle))
end
log(assignment.fieldId, "%s", text)
ADPlayerTransport.pickups[assignment.vehicleId] = {vehicle = vehicle, fieldId = assignment.fieldId, label = label(vehicle)}
ADFieldWork.tellPlayer(text, true)
end
-- Ryd op: en maskine er hentet, når den har forladt marken, er væk, eller har fået en ny opgave.
function ADPlayerTransport.tickPickups(adEnv)
for vehicleId, pickup in pairs(ADPlayerTransport.pickups) do
local vehicle = pickup.vehicle
local gone = vehicle == nil or vehicle.isDeleted or vehicle.rootNode == nil
or (entityExists ~= nil and not entityExists(vehicle.rootNode))
local info = not gone and ADFields.getInfo(pickup.fieldId) or nil
local away = gone or info == nil or ADFieldJobs.state.assignments[vehicleId] ~= nil
if not away then
local x, z = ADFieldWork.vehiclePosition(vehicle)
away = not isOnField(adEnv, info, x, z)
end
if away then ADPlayerTransport.pickups[vehicleId] = nil end
end
end
-- Til statusvinduet: én gul linje pr. maskine, der skal køres væk.
function ADPlayerTransport.pickupEntries()
local entries = {}
for _, pickup in pairs(ADPlayerTransport.pickups) do
table.insert(entries, {fieldId = pickup.fieldId, label = pickup.label, vehicle = pickup.vehicle})
end
table.sort(entries, function(a, b) return (a.fieldId or 0) < (b.fieldId or 0) end)
return entries
end
function ADPlayerTransport.isPickup(vehicle)
for _, pickup in pairs(ADPlayerTransport.pickups) do
if pickup.vehicle == vehicle then return true end
end
return false
end
-- Til statusvinduet: den maskine uden parkering, spilleren har kørt flest gange (mindst 3). Slås op højst hvert
-- 10. sekund (gennemløber gårdens køretøjer).
local hintCache = {at = nil, entry = nil}
ADPlayerTransport.HINT_CACHE_MS = 10000
function ADPlayerTransport.parkingHintEntry(adEnv)
local trips = ADFieldJobs.state.playerTrips
if adEnv == nil or trips == nil or next(trips) == nil then return nil end
local t = now() or 0
if hintCache.at ~= nil and t - hintCache.at < ADPlayerTransport.HINT_CACHE_MS then return hintCache.entry end
local vehicles = {}
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
local id = ADRunsController.getVehicleId(vehicle)
if id ~= nil and trips[id] ~= nil then vehicles[id] = vehicle end
end
local parked = {}
for id in pairs(trips) do
-- solgt/væk tæller som "har parkering" (intet at foreslå)
parked[id] = vehicles[id] == nil or ADFieldWork.parkMarkerId(adEnv, vehicles[id]) ~= nil
end
local id = ADManualTransport.parkingHint(trips, parked)
hintCache.at = t
hintCache.entry = id ~= nil and {label = trips[id].label or label(vehicles[id]), count = trips[id].count, vehicle = vehicles[id]} or nil
return hintCache.entry
end