268 lines
14 KiB
Lua
268 lines
14 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 = {}
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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)
|
|
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 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
|
|
|
|
-- 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)
|
|
if not ADManualTransport.PLAYER_ROLES[role] 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
|
|
-- kun når INTET kan køre selv: et optaget sæt eller puljeredskab med parkering betyder kø, ikke spillerkørsel
|
|
if 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 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 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 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 = rig ~= nil and rig.width or ADCpBridge.getWorkWidth(implement),
|
|
groupSize = 1, leader = true, manual = true, playerTransport = true, implementOnly = rig == nil,
|
|
startX = x, startZ = z,
|
|
}
|
|
ADFieldJobs.state.assignments[id] = assignment
|
|
ADPlayerTransport.ask(field, info, assignment, true)
|
|
return true
|
|
end
|
|
|
|
function ADPlayerTransport.ask(field, info, assignment, withDialog)
|
|
local where = tostring(info.markerName or ("F" .. tostring(field.id)))
|
|
local text
|
|
if 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
|
|
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)
|
|
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)
|
|
local forced = ADFieldJobs.takeoverRequested[field.id] == true
|
|
ADFieldJobs.takeoverRequested[field.id] = nil
|
|
local ok, why = ADManualTransport.playerReadiness({attached = attached, atField = isOnField(adEnv, info, x, z),
|
|
controlled = ADFieldWork.isControlledByPlayer(vehicle), empty = empty, forced = forced})
|
|
if ok then
|
|
if assignment.implementOnly then
|
|
table.insert(ADPlayerTransport.pendingTakeovers, {assignment = assignment, vehicle = vehicle, forced = forced})
|
|
return
|
|
end
|
|
log(field.id, "overtager '%s'%s", label(vehicle), forced and " ([Overtag])" or "")
|
|
return ADFieldWork.beginWork(adEnv, field, info, assignment)
|
|
end
|
|
local reason = REASON_TEXT[why] or tostring(why)
|
|
if 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
|
|
ADPlayerTransport.ask(field, info, assignment, false)
|
|
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)
|
|
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
|
|
state[assignment.vehicleId] = nil
|
|
assignment.vehicleId, assignment.vehicle, assignment.implementOnly = tractorId, vehicle, false
|
|
assignment.width = ADCpBridge.getWorkWidth(vehicle) or assignment.width
|
|
state[tractorId] = assignment
|
|
log(assignment.fieldId, "overtager '%s'%s", label(vehicle), entry.forced and " ([Overtag])" 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.
|
|
function ADPlayerTransport.finished(assignment)
|
|
local vehicle = assignment.vehicle
|
|
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
|