feat: læsset flow-vogn parkeres på sin P-plads, traktoren frigives, vognen hentes når et trug har plads (1.62.360)
This commit is contained in:
@@ -226,6 +226,48 @@ function ADFlowWagons.emptyStep(stage, s)
|
||||
return "giveUp"
|
||||
end
|
||||
|
||||
-- Læsset vogn ved Wait, ventetiden er udløbet (ADUnloadWait.parkLoadedDue, brugerønske 19/10): parkeres vognen med
|
||||
-- læsset på sin egen P-plads (flowet sover), eller venter den ved Wait som før? s = {supply, ownBody, wagonIsRunWagon,
|
||||
-- hasOwnPark, othersIdle} -> "park" | "wait", grund (til loggen)
|
||||
function ADFlowWagons.parkLoadedAction(s)
|
||||
if s == nil or not s.supply then return "wait", "notSupply" end
|
||||
-- lastbil med eget lad: intet at sætte af
|
||||
if s.ownBody then return "wait", "ownBody" end
|
||||
if not s.wagonIsRunWagon then return "wait", "notRunWagon" end
|
||||
-- vognen skal have sin egen P-plads med "Connect P …", ellers kan den ikke hentes igen
|
||||
if not s.hasOwnPark then return "wait", "noOwnPark" end
|
||||
-- dvalen stopper hele flowet: de andre traktorer må ikke være midt i en tur
|
||||
if not s.othersIdle then return "wait", "othersBusy" end
|
||||
return "park", nil
|
||||
end
|
||||
|
||||
ADFlowWagons.PARK_WAIT_TEXT = {
|
||||
notSupply = "ikke et forsyningsflow",
|
||||
ownBody = "lastbil med eget lad",
|
||||
notRunWagon = "vognen bagpå er ikke flowets",
|
||||
noOwnPark = "vognen har ingen egen P-plads med Connect",
|
||||
othersBusy = "flowets andre traktorer er i gang",
|
||||
}
|
||||
|
||||
-- Driftsmidler i et køretøjs fyldenheder, som aldrig er last (vognens egne fyldenheder læses uden AD).
|
||||
ADFlowWagons.NON_CARGO_FILLTYPES = {DIESEL = true, DEF = true, AIR = true, ELECTRICCHARGE = true, METHANE = true}
|
||||
function ADFlowWagons.isCargoFillTypeName(name)
|
||||
if name == nil then return true end
|
||||
return not ADFlowWagons.NON_CARGO_FILLTYPES[string.upper(tostring(name))]
|
||||
end
|
||||
|
||||
-- Skal flaget "parkeret med læs" blive stående? s = {exists, isRunWagon, cargo}: vognen findes, er stadig flowets
|
||||
-- (aktiv eller ekstra) og har mindst EMPTY_MIN_LITERS på (review 19/10: forældede flag spærrede lån for altid)
|
||||
function ADFlowWagons.keepParkedFlag(s)
|
||||
return s ~= nil and s.exists == true and s.isRunWagon == true and (s.cargo or 0) >= ADFlowWagons.EMPTY_MIN_LITERS
|
||||
end
|
||||
|
||||
-- Står en anmodning om parkering ved, når den ikke blev udført? Kun når de andre traktorer er i gang; de faste grunde
|
||||
-- (lastbil, ingen egen P, fremmed vogn) droppes — ventetiden anmoder igen efter endnu en periode.
|
||||
function ADFlowWagons.keepParkRequest(reason)
|
||||
return reason == "othersBusy"
|
||||
end
|
||||
|
||||
-- ---- spil ----
|
||||
|
||||
local waiting = setmetatable({}, {__mode = "k"}) -- traktor -> runId (venter på sin vogn)
|
||||
@@ -270,6 +312,8 @@ function ADFlowWagons.tractorFree(s)
|
||||
-- henter/venter på sin vogn (fx vækket af dvalen, mens flowet stadig står som stoppet): optaget (in-game 8/10:
|
||||
-- puljen tog 'Sheep Food'-traktoren på vej til Connect P Tippevogn 5 og sendte den efter en såmaskine)
|
||||
if s.fetchingWagon then return false end
|
||||
-- vognen bagpå er parkeret med læs (på vej til sin P-plads, evt. efter genindlæsning): ikke ledig, før den er sat af
|
||||
if s.carriesParkedLoad then return false end
|
||||
-- sovende flow med vognen på (dvale pga. gødningsreserven): hele sættet er ledigt — markflåden gøder med det
|
||||
-- (17/10: "der er jo allerede en traktor for gyllevognen, så kan den jo bare gøre det")
|
||||
if s.sleeping == true and s.carriesFlowWagon and not s.homeTrip then return true end
|
||||
@@ -308,15 +352,19 @@ end
|
||||
|
||||
function ADFlowWagons.isFreeTractor(vehicle)
|
||||
local run = ADRunsController.getRunForVehicle(vehicle)
|
||||
local carries = false
|
||||
local carries, parkedLoad = false, false
|
||||
if run ~= nil then
|
||||
for _, implement in ipairs(ADHitch.rearImplementsOf(vehicle)) do
|
||||
local wagonId = ADRunsController.getVehicleId(implement.object)
|
||||
if wagonId ~= nil and ADFlowWagons.ownerOf(runs(), wagonId) ~= nil then carries = true end
|
||||
local owner = wagonId ~= nil and ADFlowWagons.ownerOf(runs(), wagonId) or nil
|
||||
if owner ~= nil then
|
||||
carries = true
|
||||
if (owner.parkedLoaded or {})[wagonId] then parkedLoad = true end
|
||||
end
|
||||
end
|
||||
end
|
||||
return ADFlowWagons.tractorFree({hasRun = run ~= nil, stopped = run ~= nil and run.stopped == true, sleeping = run ~= nil and run.sleeping == true,
|
||||
carriesFlowWagon = carries, homeTrip = emptying[vehicle] ~= nil or homing[vehicle] ~= nil,
|
||||
carriesFlowWagon = carries, carriesParkedLoad = parkedLoad, homeTrip = emptying[vehicle] ~= nil or homing[vehicle] ~= nil,
|
||||
fetchingWagon = fetching[vehicle] ~= nil or waiting[vehicle] ~= nil})
|
||||
end
|
||||
|
||||
@@ -348,8 +396,10 @@ end
|
||||
-- flows vogn er flowets. Startes/vågner flowet, mens vognen er lånt ud, venter det (startDecision: wagonAttached).
|
||||
-- Vognen hører stadig til flowet (isHeld): andre flows adopterer den ikke (29/9: marksilo tog Cow Food-vognen).
|
||||
-- isSprayer beholdes for kalderne (indtil 1.62.322 måtte kun et stoppet flows gyllevogn/spreder lånes).
|
||||
-- En vogn parkeret MED læs (parkedLoaded, 19/10) lånes aldrig: læsset skal leveres til flowets mål først.
|
||||
function ADFlowWagons.isLendable(runs, wagonId, isSprayer)
|
||||
local owner = ADFlowWagons.ownerOf(runs, wagonId)
|
||||
if owner ~= nil and (owner.parkedLoaded or {})[wagonId] then return false end
|
||||
return owner == nil or owner.sleeping == true or owner.stopped == true
|
||||
end
|
||||
|
||||
@@ -456,6 +506,21 @@ function ADFlowWagons.beforeStart(adEnv, run, vehicle)
|
||||
if wagonId ~= nil then run.wagons = ADFlowWagons.remember(run.wagons, tractorId, wagonId) end
|
||||
end
|
||||
local wagon = wagonId ~= nil and findAnyVehicle(wagonId) or nil
|
||||
-- vognen står parkeret med læs (19/10): den hentes kun, når et mål kan tage læsset — vækkes flowet for andet arbejde,
|
||||
-- bliver traktoren hjemme (ellers kørte den læsset til et fuldt mål og parkerede det igen)
|
||||
local rearNowId = rearNow ~= nil and ADRunsController.getVehicleId(rearNow.object) or nil
|
||||
if wagonId ~= nil and rearNowId ~= wagonId and (run.parkedLoaded or {})[wagonId] and ADFlowSleep ~= nil and ADFlowSleep.parkedWagonDue ~= nil then
|
||||
local okDue, due = pcall(ADFlowSleep.parkedWagonDue, adEnv, run, wagonId)
|
||||
if okDue and not due then
|
||||
local waitText = "parkedLoad"
|
||||
if lastWaitText[vehicle] ~= waitText then
|
||||
lastWaitText[vehicle] = waitText
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' bliver hjemme — vognen står parkeret med læs, til et mål kan tage det",
|
||||
tostring(run.name), tostring(ADRuns.vehicleLabel(vehicle)))
|
||||
end
|
||||
return true, {vehicle = vehicle, ok = false, reason = "parkedLoadWaiting"}
|
||||
end
|
||||
end
|
||||
local connectId = wagon ~= nil and connectOf(adEnv, wagon) or nil
|
||||
local rear = ADHitch.rearImplementsOf(vehicle)[1]
|
||||
local rearId = rear ~= nil and ADRunsController.getVehicleId(rear.object) or nil
|
||||
@@ -561,7 +626,18 @@ local nowMs = 0
|
||||
local function cargoOf(adEnv, vehicle)
|
||||
local level, fillType = 0, nil
|
||||
local ok, units = pcall(adEnv.AutoDrive.getAllDischargeableUnits, vehicle)
|
||||
for _, unit in ipairs(ok and units or {}) do
|
||||
units = ok and units or {}
|
||||
-- frakoblet vogn (parkeret med læs): AD kender ingen enheder uden traktor -> vognens egne fyldenheder. Kun køretøjer
|
||||
-- UDEN .ad og uden motor (review 19/10: en traktor uden vogn talte ellers sin diesel/AdBlue/luft som last)
|
||||
if #units == 0 and vehicle ~= nil and vehicle.ad == nil and vehicle.spec_motorized == nil and vehicle.spec_fillUnit ~= nil then
|
||||
units = {}
|
||||
for index in ipairs(vehicle.spec_fillUnit.fillUnits or {}) do
|
||||
local unitType = vehicle.getFillUnitFillType ~= nil and vehicle:getFillUnitFillType(index) or nil
|
||||
local typeName = unitType ~= nil and g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(unitType) or nil
|
||||
if ADFlowWagons.isCargoFillTypeName(typeName) then table.insert(units, {object = vehicle, fillUnitIndex = index}) end
|
||||
end
|
||||
end
|
||||
for _, unit in ipairs(units) do
|
||||
local object, index = unit.object, unit.fillUnitIndex
|
||||
if object ~= nil and object.getFillUnitFillLevel ~= nil then
|
||||
local unitLevel = object:getFillUnitFillLevel(index) or 0
|
||||
@@ -573,6 +649,8 @@ local function cargoOf(adEnv, vehicle)
|
||||
end
|
||||
return level, fillType
|
||||
end
|
||||
-- -> liter, fyldtype (ADFlowSleep: vækning af en vogn parkeret med læs)
|
||||
ADFlowWagons.cargoOf = cargoOf
|
||||
|
||||
local function goHome(adEnv, vehicle)
|
||||
emptying[vehicle] = nil
|
||||
@@ -661,6 +739,184 @@ local function rememberWagonOf(vehicle)
|
||||
end
|
||||
end
|
||||
|
||||
-- ---- vogn parkeret med læs (brugerønske 19/10) ----
|
||||
|
||||
local pendingPark = setmetatable({}, {__mode = "k"}) -- traktor -> runId (anmodet fra ADUnloadWait, udføres i tick)
|
||||
local parkWhyLogged = setmetatable({}, {__mode = "k"}) -- traktor -> sidst loggede grund til ikke at parkere
|
||||
|
||||
-- Den bageste vogn og dens id, og flowet der ejer den.
|
||||
local function rearWagonOf(vehicle)
|
||||
local rear = ADHitch.rearImplementsOf(vehicle)[1]
|
||||
local rearId = rear ~= nil and ADRunsController.getVehicleId(rear.object) or nil
|
||||
local owner = rearId ~= nil and ADFlowWagons.ownerOf(runs(), rearId) or nil
|
||||
return rear ~= nil and rear.object or nil, rearId, owner
|
||||
end
|
||||
|
||||
-- Hænger en vogn parkeret med læs bag traktoren?
|
||||
function ADFlowWagons.carriesParkedLoad(vehicle)
|
||||
local _, rearId, owner = rearWagonOf(vehicle)
|
||||
return owner ~= nil and (owner.parkedLoaded or {})[rearId] == true
|
||||
end
|
||||
|
||||
-- Leverer traktoren en parkeret vogns læs (vækket af dvalen)? Så skal pålæsningen springes over (ADSmartPickup).
|
||||
function ADFlowWagons.isDeliveringParkedLoad(adEnv, vehicle)
|
||||
if not ADFlowWagons.carriesParkedLoad(vehicle) then return false end
|
||||
local cargo = cargoOf(adEnv, vehicle)
|
||||
return cargo >= ADFlowWagons.EMPTY_MIN_LITERS
|
||||
end
|
||||
|
||||
-- Er en vogn parkeret med læs tømt (< EMPTY_MIN_LITERS)? Så ryddes flaget — en rest falder tilbage til Wait-logikken.
|
||||
function ADFlowWagons.clearParkedIfEmpty(adEnv, vehicle)
|
||||
local _, rearId, owner = rearWagonOf(vehicle)
|
||||
if owner == nil or not (owner.parkedLoaded or {})[rearId] then return false end
|
||||
if cargoOf(adEnv, vehicle) >= ADFlowWagons.EMPTY_MIN_LITERS then return false end
|
||||
owner.parkedLoaded = ADRuns.clearParked(owner.parkedLoaded, rearId)
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' har leveret det parkerede læs", tostring(owner.name), tostring(ADRuns.vehicleLabel(vehicle)))
|
||||
return true
|
||||
end
|
||||
|
||||
-- Ryd forældede flag: vognen er væk, ikke længere flowets, eller tømt. Kaldes periodisk (alle flows, også sovende)
|
||||
-- og når flowet stoppes (ADRunsController.stopRun) — en læsset vogn beholder flaget.
|
||||
function ADFlowWagons.pruneParked(adEnv, run)
|
||||
if run == nil or next(run.parkedLoaded or {}) == nil then return end
|
||||
local own = {}
|
||||
for _, id in ipairs(ADRuns.wagonIdsOf(run)) do own[id] = true end
|
||||
for wagonId in pairs(ADRuns.copyParked(run.parkedLoaded)) do
|
||||
local wagon = findAnyVehicle(wagonId)
|
||||
local cargo = wagon ~= nil and cargoOf(adEnv, wagon) or 0
|
||||
if not ADFlowWagons.keepParkedFlag({exists = wagon ~= nil, isRunWagon = own[wagonId] == true, cargo = cargo}) then
|
||||
run.parkedLoaded = ADRuns.clearParked(run.parkedLoaded, wagonId)
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "flow '%s': vognen '%s' er ikke længere parkeret med læs (%s)", tostring(run.name),
|
||||
tostring(wagon ~= nil and ADRuns.vehicleLabel(wagon) or wagonId),
|
||||
wagon == nil and "findes ikke" or (not own[wagonId] and "ikke flowets vogn") or "tømt")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- ADUnloadWait (inde i opgavens update): anmod om parkering — AD stoppes først i tick. -> true = anmodet
|
||||
function ADFlowWagons.requestParkLoaded(adEnv, run, vehicle)
|
||||
if run == nil or vehicle == nil then return false end
|
||||
pendingPark[vehicle] = run.id
|
||||
return true
|
||||
end
|
||||
|
||||
local function hasOwnBody(vehicle)
|
||||
return vehicle ~= nil and (vehicle.spec_trailer ~= nil or vehicle.spec_dischargeable ~= nil)
|
||||
end
|
||||
|
||||
-- Vognens egen P-plads (waypoint-id) blandt traktorens puljeredskaber (P med "Connect P …")?
|
||||
local function wagonHasOwnPark(adEnv, tractor, wagon)
|
||||
local index = wagon ~= nil and wagon.advd ~= nil and wagon.advd.parkDestination or nil
|
||||
local park = type(index) == "number" and index >= 1 and adEnv.ADGraphManager:getMapMarkerById(index) or nil
|
||||
if park == nil then return false end
|
||||
for _, parkId in ipairs(ADHitch.poolParkIds(adEnv, tractor)) do
|
||||
if parkId == park.id then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
-- parkLoadedAction's tilstand for én traktor (othersIdle sættes af kalderen).
|
||||
local function parkStateOf(adEnv, run, vehicle, tractorId)
|
||||
local wagon, rearId = rearWagonOf(vehicle)
|
||||
return {supply = (run.kind or "supply") == "supply", ownBody = hasOwnBody(vehicle),
|
||||
wagonIsRunWagon = rearId ~= nil and (run.wagons or {})[tractorId] == rearId,
|
||||
hasOwnPark = wagon ~= nil and wagonHasOwnPark(adEnv, vehicle, wagon), wagonId = rearId}
|
||||
end
|
||||
|
||||
local function isWaitingAtWait(vehicle)
|
||||
return ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil
|
||||
end
|
||||
|
||||
-- Laver traktoren intet (AD slukket, ingen vogn-logik, tom vogn)?
|
||||
local function isIdleMember(adEnv, vehicle)
|
||||
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||||
if module ~= nil and module:isActive() then return false end
|
||||
if ADFlowWagons.statusOf(vehicle) ~= nil then return false end
|
||||
return cargoOf(adEnv, vehicle) < ADFlowWagons.EMPTY_MIN_LITERS
|
||||
end
|
||||
|
||||
local function logParkWhy(vehicle, reason)
|
||||
if parkWhyLogged[vehicle] == reason then return end
|
||||
parkWhyLogged[vehicle] = reason
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "'%s' venter med læs ved Wait — parkeres ikke (%s)", tostring(ADRuns.vehicleLabel(vehicle)),
|
||||
tostring(ADFlowWagons.PARK_WAIT_TEXT[reason] or reason))
|
||||
end
|
||||
|
||||
-- Ét flow: parkér de anmodede, læssede vogne, hvis det kan lade sig gøre, og læg flowet i dvale.
|
||||
-- -> parkeret?, {[traktor] = true} for anmodninger der står ved (keepParkRequest)
|
||||
local function parkRunLoaded(adEnv, run, requested)
|
||||
local members, parkable, retry = {}, {}, {}
|
||||
for _, id in ipairs(run.vehicleIds or {}) do
|
||||
local vehicle = ADRunsController.findVehicleById(adEnv, id)
|
||||
if vehicle ~= nil then
|
||||
local state = parkStateOf(adEnv, run, vehicle, id)
|
||||
local asked = requested[vehicle] == run.id and isWaitingAtWait(vehicle)
|
||||
-- foreløbig (uden othersIdle): kan netop denne parkeres?
|
||||
state.othersIdle = true
|
||||
local prelim = ADFlowWagons.parkLoadedAction(state)
|
||||
table.insert(members, {vehicle = vehicle, id = id, state = state, asked = asked,
|
||||
idle = (asked and prelim == "park") or isIdleMember(adEnv, vehicle)})
|
||||
end
|
||||
end
|
||||
for _, member in ipairs(members) do
|
||||
if member.asked then
|
||||
local othersIdle = true
|
||||
for _, other in ipairs(members) do
|
||||
if other ~= member and not other.idle then othersIdle = false end
|
||||
end
|
||||
member.state.othersIdle = othersIdle
|
||||
local action, reason = ADFlowWagons.parkLoadedAction(member.state)
|
||||
if action == "park" then
|
||||
table.insert(parkable, member)
|
||||
else
|
||||
logParkWhy(member.vehicle, reason)
|
||||
if ADFlowWagons.keepParkRequest(reason) then retry[member.vehicle] = true end
|
||||
end
|
||||
end
|
||||
end
|
||||
if #parkable == 0 then return false, retry end
|
||||
local names = {}
|
||||
for _, member in ipairs(parkable) do
|
||||
parkWhyLogged[member.vehicle] = nil
|
||||
run.parkedLoaded = ADRuns.markParked(run.parkedLoaded, member.state.wagonId)
|
||||
-- det parkerede læs er ikke "på vej" til målet (getPending), så de andre traktorer ikke regner med det
|
||||
if ADSmartPickup ~= nil and ADSmartPickup.clearEnRoute ~= nil then ADSmartPickup.clearEnRoute(member.vehicle) end
|
||||
table.insert(names, tostring(ADRuns.vehicleLabel(member.vehicle)))
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "'%s' venter med læs — vognen parkeres på sin P-plads", tostring(ADRuns.vehicleLabel(member.vehicle)))
|
||||
end
|
||||
if ADFlowSleep ~= nil and ADFlowSleep.sleepRun ~= nil then
|
||||
ADFlowSleep.sleepRun(adEnv, run, string.format("'%s' venter med læs — vognen parkeres med læsset, til et mål kan tage det", table.concat(names, "', '")))
|
||||
else
|
||||
ADRunsController.stopRun(adEnv, run.id)
|
||||
end
|
||||
return true, {}
|
||||
end
|
||||
|
||||
-- Udfør ventende anmodninger (fra ADUnloadWait) uden for AD's opgave-update.
|
||||
local function tickParkLoaded(adEnv)
|
||||
if next(pendingPark) == nil then return end
|
||||
local requested, runIds = {}, {}
|
||||
for vehicle, runId in pairs(pendingPark) do
|
||||
requested[vehicle] = runId
|
||||
runIds[runId] = true
|
||||
end
|
||||
pendingPark = setmetatable({}, {__mode = "k"})
|
||||
for runId in pairs(runIds) do
|
||||
local run = ADRuns.getRun(ADRunsController.store, runId)
|
||||
if run ~= nil and not run.stopped then
|
||||
local ok, parked, retry = pcall(parkRunLoaded, adEnv, run, requested)
|
||||
if not ok then Logging.warning(ADFlowWagons.LOG_PREFIX .. "parkering med læs: %s", tostring(parked)) end
|
||||
-- ikke parkeret, fordi de andre traktorer er i gang: anmodningen står ved, så længe vognen venter ved Wait
|
||||
-- (to læssede vogne i samme flow skal kunne parkeres sammen, selv om deres ure udløber på hver sin tid)
|
||||
if ok and not parked then
|
||||
for vehicle in pairs(retry or {}) do
|
||||
if isWaitingAtWait(vehicle) then pendingPark[vehicle] = runId end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Én traktor hjem (fra et stoppet/slettet flow): tøm først, så parkering.
|
||||
-- reason: "stop" (et kørende flow stoppes: vognen huskes) | "afterLoad" (oprydning: intet huskes)
|
||||
function ADFlowWagons.homeVehicle(adEnv, vehicle, runName, reason)
|
||||
@@ -673,6 +929,12 @@ function ADFlowWagons.homeVehicle(adEnv, vehicle, runName, reason)
|
||||
fetching[vehicle] = nil
|
||||
ADHitch.cancel(vehicle)
|
||||
end
|
||||
-- vognen er parkeret med læs (19/10): ingen tømning — den køres med læsset til sin P-plads og sættes af
|
||||
-- (ADHitch.returnHome), traktoren kører til sin egen P
|
||||
if ADFlowWagons.carriesParkedLoad(vehicle) then
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "'%s' kører vognen med læsset til dens P-plads og kører selv hjem", tostring(ADRuns.vehicleLabel(vehicle)))
|
||||
return goHome(adEnv, vehicle)
|
||||
end
|
||||
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||||
local second = module ~= nil and module.getSecondMarker ~= nil and module:getSecondMarker() or nil
|
||||
local run = ADRunsController.getRunForVehicle(vehicle)
|
||||
@@ -852,6 +1114,11 @@ local function tickEmptying(adEnv)
|
||||
end
|
||||
|
||||
local function rememberAll(adEnv)
|
||||
-- vogne parkeret med læs: forældede flag ryddes i alle flows (også stoppede/sovende)
|
||||
for _, run in ipairs(runs()) do
|
||||
local okPrune, errPrune = pcall(ADFlowWagons.pruneParked, adEnv, run)
|
||||
if not okPrune then Logging.warning(ADFlowWagons.LOG_PREFIX .. "parkeret læs: %s", tostring(errPrune)) end
|
||||
end
|
||||
for _, run in ipairs(runs()) do
|
||||
if not run.stopped then
|
||||
for _, vehicleId in ipairs(run.vehicleIds or {}) do
|
||||
@@ -922,8 +1189,10 @@ local sinceLoad, cleanedUp = 0, false
|
||||
-- s = {sleeping, stopped, carriesOwnWagon, wagonIsSprayer}: sovende flow med egen vogn på, eller stoppet flow hvis
|
||||
-- vognen er en gyllevogn/spreder (sættet er markflåde, 316/318 — in-game 17/10 12:04: oprydningen efter indlæsning
|
||||
-- splittede Supercis-sættene fra det stoppede 'Slurry'-flow)
|
||||
-- s.parkedLoaded: vognen bagpå er parkeret med læs (19/10) — hjemturen blev afbrudt af gem/indlæs og skal gøres færdig
|
||||
function ADFlowWagons.keepsSleepingSet(s)
|
||||
if s == nil or s.carriesOwnWagon ~= true then return false end
|
||||
if s.parkedLoaded then return false end
|
||||
if s.sleeping == true then return true end
|
||||
return s.stopped == true and s.wagonIsSprayer == true
|
||||
end
|
||||
@@ -940,7 +1209,9 @@ end
|
||||
|
||||
local function keepsSet(run, vehicle, vehicleId)
|
||||
local carries, sprayer = carriesOwnWagon(run, vehicle, vehicleId)
|
||||
return ADFlowWagons.keepsSleepingSet({sleeping = run.sleeping == true, stopped = run.stopped == true, carriesOwnWagon = carries, wagonIsSprayer = sprayer})
|
||||
local wagonId = (run.wagons or {})[vehicleId]
|
||||
return ADFlowWagons.keepsSleepingSet({sleeping = run.sleeping == true, stopped = run.stopped == true, carriesOwnWagon = carries, wagonIsSprayer = sprayer,
|
||||
parkedLoaded = carries and wagonId ~= nil and (run.parkedLoaded or {})[wagonId] == true})
|
||||
end
|
||||
|
||||
local function adoptOrphansAfterLoad(adEnv)
|
||||
@@ -986,6 +1257,8 @@ function ADFlowWagons.tick(adEnv, dt)
|
||||
if not okOrphan then Logging.warning(ADFlowWagons.LOG_PREFIX .. "redskaber uden opgave: %s", tostring(errOrphan)) end
|
||||
local okEmpty, errEmpty = pcall(tickEmptying, adEnv)
|
||||
if not okEmpty then Logging.warning(ADFlowWagons.LOG_PREFIX .. "tømning: %s", tostring(errEmpty)) end
|
||||
local okPark, errPark = pcall(tickParkLoaded, adEnv)
|
||||
if not okPark then Logging.warning(ADFlowWagons.LOG_PREFIX .. "parkering med læs: %s", tostring(errPark)) end
|
||||
end
|
||||
if not cleanedUp then
|
||||
sinceLoad = sinceLoad + dt
|
||||
|
||||
Reference in New Issue
Block a user