469 lines
27 KiB
Lua
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, role) 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
|