398 lines
21 KiB
Lua
398 lines
21 KiB
Lua
-- AD Contracts
|
|
-- Kontrakter kører selv (brugerønske 9/10, "byg det hele" 10/10): accepterer spilleren en markkontrakt, sætter moden
|
|
-- kontraktens mark til det tilsvarende trin (pløj, kultivér, så, ukrudt, gødning, slåning, sten), og markarbejdet
|
|
-- sender et sæt — eller beder spilleren køre et, uden parkering/markør (ADPlayerTransport). Kun det ene trin; når
|
|
-- kontrakten er færdig eller annulleret, stoppes sættene og marken glemmes. Høst: tømmevognene kører læssene til
|
|
-- kontraktens salgssted (dets AutoDrive-markører); uden F-markør kører spilleren mejetærskeren derud og tømmer selv.
|
|
-- Hvem kører kontrakten (brugerønske 10/10): indstillingen contracts — 2 = spørg ved hver kontrakt (standard),
|
|
-- 1 = moden altid, 0 = spilleren altid. Kontraktmarken står altid i marklisten: [Til] = moden kører den, [Fra] =
|
|
-- spilleren (svarer man nej, eller "jeg selv altid", står den på Fra og kan slås til senere). Ren logik øverst, spil-adapter nederst.
|
|
|
|
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
|
|
local function logInfo(...) return (ADLog or Logging).info(...) end
|
|
|
|
ADContracts = {}
|
|
|
|
ADContracts.SCAN_MS = 5000
|
|
-- færdige kontrakter indkasseres selv (brugerønske 19/10 00:11: "der hænger en gammel der er taget og lavet færdig for
|
|
-- længe siden" — F15-gødning stod FINISHED/SUCCESS). Ventetid efter færdig, så lånte maskiner når at slippe.
|
|
ADContracts.COLLECT_DELAY_MS = 60000
|
|
|
|
-- kontrakttype (uden "Mission", små bogstaver) -> markens trin
|
|
ADContracts.STAGES = {
|
|
plow = "plowing", cultivate = "cultivating", sow = "sowing", weed = "weeding", hoe = "weeding",
|
|
herbicide = "weeding", fertilize = "fertilizing", mow = "mowing", stonepick = "stonePicking", roll = "rolling",
|
|
harvest = "harvesting",
|
|
}
|
|
|
|
function ADContracts.stageFor(typeName)
|
|
if typeName == nil then return nil end
|
|
local key = string.lower(tostring(typeName)):gsub("mission$", "")
|
|
return ADContracts.STAGES[key]
|
|
end
|
|
|
|
-- indstillingen contracts -> "ask" | "start" | "skip"
|
|
function ADContracts.decision(mode)
|
|
if mode == 1 then return "start" end
|
|
if mode == 0 then return "skip" end
|
|
return "ask"
|
|
end
|
|
|
|
-- entries = {{id, placeable}} (AutoDrive-markører og bygningen deres aflæsning hører til) -> id'er ved placeable
|
|
function ADContracts.markersAt(entries, placeable)
|
|
local ids = {}
|
|
if placeable == nil then return ids end
|
|
for _, entry in ipairs(entries or {}) do
|
|
if entry.placeable == placeable then table.insert(ids, entry.id) end
|
|
end
|
|
return ids
|
|
end
|
|
|
|
-- Kontraktens lånte udstyr først (brugerønske 10/10: lånt gødningsspreder blev overset, gårdens egen var optaget).
|
|
-- candidates = {{vehicle, ...}}, isLeased(vehicle) -> de lånte, hvis der er nogen; ellers alle.
|
|
function ADContracts.preferLeased(candidates, isLeased)
|
|
local leased = {}
|
|
for _, candidate in ipairs(candidates or {}) do
|
|
if isLeased(candidate.vehicle) then table.insert(leased, candidate) end
|
|
end
|
|
return #leased > 0 and leased or candidates
|
|
end
|
|
|
|
-- Skal kontraktmarken køres igen? Courseplay kan melde færdig, før kontrakten er det (spillets markkant fandt kun en
|
|
-- del af marken, in-game 10/10 F40: 67 %). completion = mission:getCompletion() (1 = klar), passes = gentagelser.
|
|
ADContracts.MAX_PASSES = 3
|
|
function ADContracts.needsAnotherPass(completion, passes)
|
|
return type(completion) == "number" and completion < 0.999 and (passes or 0) < ADContracts.MAX_PASSES
|
|
end
|
|
|
|
-- Kan en ny omgang hjælpe? Kun hvis der står afgrøde tilbage (høst/slåning: mindst 5 % af marken står). Andre trin
|
|
-- (pløj, kultivér, så …): målingen kan ikke se forskel på "næsten" og "helt" — en omgang mere er ufarlig.
|
|
ADContracts.STANDING_MIN = 0.05
|
|
function ADContracts.passCanHelp(stage, info)
|
|
if stage ~= "harvesting" and stage ~= "mowing" then return true end
|
|
return info ~= nil and type(info.standingRatio) == "number" and info.standingRatio >= ADContracts.STANDING_MIN
|
|
end
|
|
|
|
-- Kontraktens fremdrift (0-1+, 1 = klar) eller nil.
|
|
function ADContracts.completionOf(field)
|
|
local mission = field ~= nil and field.contractMission or nil
|
|
if mission == nil or mission.getCompletion == nil then return nil end
|
|
local ok, value = pcall(mission.getCompletion, mission)
|
|
return ok and type(value) == "number" and value or nil
|
|
end
|
|
|
|
-- tracked/running = {[nøgle] = {fieldId, ...}} -> startede, afsluttede (lister {key, ...})
|
|
function ADContracts.diff(tracked, running)
|
|
local started, ended = {}, {}
|
|
for key, entry in pairs(running or {}) do
|
|
if (tracked or {})[key] == nil then
|
|
table.insert(started, {key = key, fieldId = entry.fieldId, stage = entry.stage, fruit = entry.fruit, mission = entry.mission})
|
|
end
|
|
end
|
|
for key, entry in pairs(tracked or {}) do
|
|
if (running or {})[key] == nil then table.insert(ended, {key = key, fieldId = entry.fieldId}) end
|
|
end
|
|
table.sort(started, function(a, b) return tostring(a.key) < tostring(b.key) end)
|
|
table.sort(ended, function(a, b) return tostring(a.key) < tostring(b.key) end)
|
|
return started, ended
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
ADContracts.tracked = {} -- nøgle -> {fieldId}
|
|
ADContracts.fieldIds = {} -- markId -> true (kontraktmarker, som ADFields scanner med)
|
|
local lastScanAt = nil
|
|
|
|
function ADContracts.isContractField(fieldId)
|
|
return ADContracts.fieldIds[fieldId] == true
|
|
end
|
|
|
|
local function missionKey(mission)
|
|
return tostring(mission.uniqueId or mission.activeMissionId or mission)
|
|
end
|
|
|
|
local function fieldIdOf(mission)
|
|
local field = mission.field or (mission.getField ~= nil and mission:getField()) or nil
|
|
if field == nil then return nil end
|
|
return field.getId ~= nil and field:getId() or field.fieldId
|
|
end
|
|
|
|
-- Høstkontraktens salgssted (placeable). Feltnavnet er ikke dokumenteret (HarvestMission.lua mangler i spilkilden):
|
|
-- sellingStation, ellers første felt med en aflæsningsstation, ellers savegame-id'et. Returnerer placeable, hvor fundet.
|
|
local function sellPlaceableOf(mission)
|
|
local station = mission.sellingStation
|
|
local where = "sellingStation"
|
|
if station == nil then
|
|
for key, value in pairs(mission) do
|
|
if type(value) == "table" and value.owningPlaceable ~= nil and value.unloadTriggers ~= nil then
|
|
station, where = value, tostring(key)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
local placeable = station ~= nil and station.owningPlaceable or nil
|
|
local uniqueId = mission.sellingStationPlaceableUniqueId
|
|
if placeable == nil and uniqueId ~= nil and g_currentMission.placeableSystem.getPlaceableByUniqueId ~= nil then
|
|
placeable, where = g_currentMission.placeableSystem:getPlaceableByUniqueId(uniqueId), "sellingStationPlaceableUniqueId"
|
|
end
|
|
-- aflæsningsstationen selv (til spillets hjælper / Courseplay "Giants unload")
|
|
if station == nil and placeable ~= nil and placeable.spec_sellingStation ~= nil then
|
|
station = placeable.spec_sellingStation.sellingStation
|
|
end
|
|
return placeable, where, station
|
|
end
|
|
|
|
-- AutoDrive-markører hvis aflæsning hører til salgsstedet.
|
|
local function sellMarkerIds(adEnv, placeable, farmId)
|
|
local entries = {}
|
|
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers() or {}) do
|
|
local okStation, station = pcall(ADSmartPickup.getUnloadStationAtWayPointId, adEnv, marker.id, farmId)
|
|
table.insert(entries, {id = marker.id, placeable = okStation and station ~= nil and station.owningPlaceable or nil})
|
|
end
|
|
return ADContracts.markersAt(entries, placeable)
|
|
end
|
|
|
|
-- Hører køretøjet (eller noget der hænger på det) til kontraktens lånte udstyr?
|
|
function ADContracts.isLeasedFor(field, vehicle)
|
|
local mission = field ~= nil and field.contractMission or nil
|
|
if mission == nil or vehicle == nil then return false end
|
|
local leased = {}
|
|
for _, item in ipairs(mission.vehicles or {}) do leased[item] = true end
|
|
if leased[vehicle] then return true end
|
|
for _, child in ipairs(vehicle.getChildVehicles ~= nil and vehicle:getChildVehicles() or {}) do
|
|
if leased[child] then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Lånt til en kontrakt (spillets ejerstatus MISSION, også på det der hænger på)? Det må kun bruges på sin egen
|
|
-- kontrakt (in-game 10/10: F2-kontraktens lånte T7.230 + K105 blev sendt til gårdens egen F38 først).
|
|
function ADContracts.isMissionVehicle(vehicle)
|
|
if vehicle == nil or VehiclePropertyState == nil or VehiclePropertyState.MISSION == nil then return false end
|
|
if vehicle.propertyState == VehiclePropertyState.MISSION then return true end
|
|
for _, child in ipairs(vehicle.getChildVehicles ~= nil and vehicle:getChildVehicles() or {}) do
|
|
if child.propertyState == VehiclePropertyState.MISSION then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Til loggen: kontraktens lånte udstyr — hvad, koblet eller løst, rolle og fyld.
|
|
local function describeLeased(mission)
|
|
local parts = {}
|
|
for _, vehicle in ipairs(mission.vehicles or {}) do
|
|
local root = vehicle.getRootVehicle ~= nil and vehicle:getRootVehicle() or vehicle
|
|
local okSpecs, specs = pcall(ADCpBridge.getSpecs, vehicle)
|
|
local role = okSpecs and ADFieldFleet.roleFromSpecs(specs) or nil
|
|
local okFill, fill = pcall(ADCpBridge.describeFill, vehicle)
|
|
table.insert(parts, string.format("'%s' (%s, %s, rolle %s, fyld %s)", ADRuns.vehicleLabel(vehicle),
|
|
vehicle.spec_motorized ~= nil and "traktor" or "redskab", root ~= vehicle and ("på '" .. ADRuns.vehicleLabel(root) .. "'") or "løs",
|
|
tostring(role or "-"), okFill and tostring(fill) or "?"))
|
|
end
|
|
return #parts > 0 and table.concat(parts, "; ") or "intet lånt udstyr"
|
|
end
|
|
|
|
local function fruitNameOf(mission)
|
|
local index = mission.fruitTypeIndex or mission.fruitType
|
|
if type(index) ~= "number" or g_fruitTypeManager == nil then return nil end
|
|
local fruit = g_fruitTypeManager:getFruitTypeByIndex(index)
|
|
return fruit ~= nil and fruit.name or nil
|
|
end
|
|
|
|
-- Kørende markkontrakter for gården, som moden kan udføre: {[nøgle] = {fieldId, stage, fruit}}
|
|
local function runningContracts(farmId)
|
|
local running = {}
|
|
if g_missionManager == nil or MissionStatus == nil then return running end
|
|
for _, mission in ipairs(g_missionManager:getMissions() or {}) do
|
|
if mission.farmId == farmId and mission.status == MissionStatus.RUNNING then
|
|
local stage = ADContracts.stageFor(mission.type ~= nil and mission.type.name or nil)
|
|
local fieldId = stage ~= nil and fieldIdOf(mission) or nil
|
|
if fieldId ~= nil then
|
|
running[missionKey(mission)] = {fieldId = fieldId, stage = stage, fruit = fruitNameOf(mission), mission = mission}
|
|
end
|
|
end
|
|
end
|
|
return running
|
|
end
|
|
|
|
-- enabled = false: spilleren kører selv — marken står i listen som [Fra], så moden kan slås til senere
|
|
local function start(adEnv, entry, enabled)
|
|
enabled = enabled ~= false
|
|
ADContracts.tracked[entry.key] = {fieldId = entry.fieldId}
|
|
ADContracts.fieldIds[entry.fieldId] = true
|
|
-- kun kontraktens trin: slået til, intet efterfølgende trin (ADFieldJobs: contract -> done efter trinnet)
|
|
local harvest = entry.stage == "harvesting"
|
|
if entry.mission ~= nil then
|
|
local okLeased, leasedText = pcall(describeLeased, entry.mission)
|
|
ADFieldJobs.log(entry.fieldId, "kontraktens lånte udstyr: %s", okLeased and leasedText or ("fejl: " .. tostring(leasedText)))
|
|
end
|
|
local changes = {stage = entry.stage, kind = harvest and "harvest" or "bare", contract = true, contractMission = entry.mission,
|
|
plan = {mode = enabled and "auto" or "manual", sow = entry.stage == "sowing", sowFruit = entry.fruit or "", straw = "chop"}}
|
|
if harvest and entry.mission ~= nil then
|
|
-- høst: læssene skal til kontraktens salgssted (ADFieldWork.chooseStore)
|
|
local placeable, where, station = sellPlaceableOf(entry.mission)
|
|
local farmId = ADUtil.farmId()
|
|
changes.contractSellIds = placeable ~= nil and sellMarkerIds(adEnv, placeable, farmId) or {}
|
|
-- uden AutoDrive-vej kører spillets hjælper læssene hertil (ADFieldWork beginUnloader)
|
|
changes.contractStation = station
|
|
ADFieldJobs.log(entry.fieldId, "høstkontrakt: salgssted %s (fundet via %s), %d AutoDrive-markør(er) ved det",
|
|
placeable ~= nil and tostring(placeable.getName ~= nil and placeable:getName() or "?") or "ikke fundet",
|
|
tostring(where), #changes.contractSellIds)
|
|
end
|
|
local field = ADFieldModel.with(ADFieldModel.newField(entry.fieldId), changes)
|
|
ADFieldJobs.setField(field)
|
|
ADFields.ownedAt = nil -- scan kontraktmarken med det samme
|
|
local text = string.format("Kontrakt på F%s: moden %s marken", tostring(entry.fieldId),
|
|
({plowing = "pløjer", cultivating = "kultiverer", sowing = "sår", weeding = "renser", fertilizing = "gøder",
|
|
mowing = "slår", stonePicking = "plukker sten på", rolling = "tromler", harvesting = "høster"})[entry.stage] or "bearbejder")
|
|
if not enabled then
|
|
text = string.format("Kontrakt på F%s: du kører den selv — klik [Til] på marken i Marker, hvis moden skal overtage",
|
|
tostring(entry.fieldId))
|
|
end
|
|
ADFieldJobs.log(entry.fieldId, "%s (%s)", text, tostring(entry.key))
|
|
ADFieldJobs.notify(text, false)
|
|
end
|
|
|
|
local function finish(adEnv, entry)
|
|
local tracked = ADContracts.tracked[entry.key]
|
|
ADContracts.tracked[entry.key] = nil
|
|
-- spilleren kører den selv (eller spørgsmålet er ikke besvaret): moden har intet på marken
|
|
if tracked ~= nil and (tracked.declined or tracked.pending) then
|
|
if ADContracts.asking == entry.key then ADContracts.asking = nil end
|
|
return
|
|
end
|
|
ADContracts.fieldIds[entry.fieldId] = nil
|
|
pcall(ADFieldWork.stopAll, adEnv, entry.fieldId)
|
|
ADFieldJobs.state.fields[entry.fieldId] = nil
|
|
ADFieldJobs.forgetFinished(entry.fieldId)
|
|
ADFields.ownedAt = nil
|
|
ADFieldJobs.log(entry.fieldId, "kontrakten er slut — sættene er stoppet, og marken er glemt")
|
|
end
|
|
|
|
-- Svar på "skal moden køre kontrakten?". YesNoDialog kalder callback(target, yes, args) MED et target, men
|
|
-- callback(yes, args) uden — derfor gives ADContracts som target (in-game 10/10: svaret "ja" gik tabt, F2 blev aldrig startet).
|
|
function ADContracts.onAnswer(_, yes, entry)
|
|
ADContracts.asking = nil
|
|
if type(entry) ~= "table" then
|
|
Logging.warning("ADSmartPickup: kontrakt-svar uden data (yes=%s) — spørges igen", tostring(yes))
|
|
-- ryd ventende, så kontrakten spørges igen ved næste aflæsning
|
|
for key, tracked in pairs(ADContracts.tracked) do
|
|
if tracked.pending then ADContracts.tracked[key] = nil end
|
|
end
|
|
return
|
|
end
|
|
local tracked = ADContracts.tracked[entry.key]
|
|
if tracked == nil or not tracked.pending then return end -- kontrakten er slut i mellemtiden
|
|
ADContracts.tracked[entry.key] = nil
|
|
-- nej: marken kommer i listen som [Fra], så moden kan overtage senere ([Til])
|
|
ADFieldJobs.log(entry.fieldId, "spilleren svarede %s", yes == true and "ja — moden kører kontrakten" or "nej — spilleren kører selv")
|
|
start(ADContracts.adEnv, entry, yes == true)
|
|
end
|
|
|
|
local function ask(entry)
|
|
-- dedikeret server (ingen skærm): ingen at spørge -> rør den ikke, som uden dialog (multiplayer etape 1;
|
|
-- spørgsmålet til en spiller kommer i etape 4)
|
|
if YesNoDialog == nil or YesNoDialog.show == nil or (g_client == nil and g_server ~= nil) then
|
|
-- kan ikke spørge: rør den ikke (spilleren kan vælge "moden altid" under Indstillinger)
|
|
start(ADContracts.adEnv, entry, false)
|
|
return
|
|
end
|
|
ADContracts.tracked[entry.key] = {fieldId = entry.fieldId, pending = true}
|
|
ADContracts.asking = entry.key
|
|
local text = string.format("Ny kontrakt: F%s skal %s. Skal Smart Pickup køre den?", tostring(entry.fieldId),
|
|
ADManualTransport.stageVerb(entry.stage))
|
|
ADFieldJobs.log(entry.fieldId, "spørger spilleren: %s", text)
|
|
local ok = pcall(YesNoDialog.show, ADContracts.onAnswer, ADContracts, text, "Smart Pickup", "Ja, kør den", "Nej, jeg kører selv",
|
|
nil, nil, nil, entry)
|
|
if not ok then ADContracts.onAnswer(ADContracts, false, entry) end
|
|
end
|
|
|
|
-- Ren: hvilke færdige kontrakter skal indkasseres nu? missions = {{key, farmId, finished (status FINISHED), success}};
|
|
-- firstSeen = {[key] = ms} (opdateres: ny færdig noteres, forsvundne glemmes). -> liste af nøgler
|
|
function ADContracts.toCollect(missions, farmId, firstSeen, now)
|
|
local present, due = {}, {}
|
|
for _, m in ipairs(missions or {}) do
|
|
if m.farmId == farmId and m.finished and m.success then
|
|
present[m.key] = true
|
|
firstSeen[m.key] = firstSeen[m.key] or now
|
|
if now - firstSeen[m.key] >= ADContracts.COLLECT_DELAY_MS then table.insert(due, m.key) end
|
|
end
|
|
end
|
|
for key in pairs(firstSeen) do if not present[key] then firstSeen[key] = nil end end
|
|
table.sort(due, function(a, b) return tostring(a) < tostring(b) end)
|
|
return due
|
|
end
|
|
|
|
local finishedSeen = {}
|
|
|
|
-- Er et af kontraktens lånte køretøjer i brug (spilleren sidder i det, AutoDrive eller en hjælper kører)? Så venter
|
|
-- indkasseringen — spillet sletter de lånte køretøjer, når kontrakten afsluttes (review 19/10)
|
|
local function leasedInUse(mission)
|
|
for _, vehicle in ipairs(mission.vehicles or {}) do
|
|
local root = vehicle.getRootVehicle ~= nil and vehicle:getRootVehicle() or vehicle
|
|
for _, v in ipairs({vehicle, root}) do
|
|
if v.getIsControlled ~= nil and v:getIsControlled() then return true end
|
|
if v.ad ~= nil and v.ad.stateModule ~= nil and v.ad.stateModule:isActive() then return true end
|
|
if v.getIsAIActive ~= nil and v:getIsAIActive() then return true end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function collectFinished(farmId, nowMs)
|
|
if g_missionManager == nil or MissionStatus == nil or MissionFinishState == nil or g_missionManager.dismissMission == nil then return end
|
|
if g_currentMission.getIsServer ~= nil and not g_currentMission:getIsServer() then return end
|
|
local list, byKey = {}, {}
|
|
for _, mission in ipairs(g_missionManager:getMissions() or {}) do
|
|
local key = missionKey(mission)
|
|
byKey[key] = mission
|
|
table.insert(list, {key = key, farmId = mission.farmId, finished = mission.status == MissionStatus.FINISHED,
|
|
success = mission.finishState == MissionFinishState.SUCCESS})
|
|
end
|
|
for _, key in ipairs(ADContracts.toCollect(list, farmId, finishedSeen, nowMs)) do
|
|
local mission = byKey[key]
|
|
local okUse, inUse = pcall(leasedInUse, mission)
|
|
if okUse and not inUse then
|
|
local okReward, reward = pcall(function() return mission.getTotalReward ~= nil and mission:getTotalReward() or nil end)
|
|
local fieldId = fieldIdOf(mission)
|
|
local ok, err = pcall(g_missionManager.dismissMission, g_missionManager, mission)
|
|
finishedSeen[key] = nil
|
|
if ok then
|
|
local text = string.format("Kontrakt%s er færdig og indkasseret%s", fieldId ~= nil and (" på F" .. tostring(fieldId)) or "",
|
|
okReward and type(reward) == "number" and string.format(" (%.0f kr)", reward) or "")
|
|
logInfo("ADSmartPickup: %s (%s)", text, tostring(key))
|
|
ADFieldJobs.notify(text, false)
|
|
else
|
|
Logging.warning("ADSmartPickup: kontrakt %s kunne ikke indkasseres: %s", tostring(key), tostring(err))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Kaldes fra markarbejdets tick.
|
|
function ADContracts.tick(adEnv, nowMs)
|
|
ADContracts.adEnv = adEnv
|
|
local decision = ADContracts.decision(ADSettings ~= nil and ADSettings.get("contracts") or nil)
|
|
if lastScanAt ~= nil and nowMs - lastScanAt < ADContracts.SCAN_MS then return end
|
|
lastScanAt = nowMs
|
|
local farmId = ADUtil.farmId()
|
|
if farmId == nil then return end
|
|
local okCollect, errCollect = pcall(collectFinished, farmId, nowMs)
|
|
if not okCollect then Logging.warning("ADSmartPickup: indkassering af kontrakter: %s", tostring(errCollect)) end
|
|
local started, ended = ADContracts.diff(ADContracts.tracked, runningContracts(farmId))
|
|
for _, entry in ipairs(ended) do finish(adEnv, entry) end
|
|
-- "Stop alt"-pause: nye kontrakter startes først, når markarbejdet kører igen
|
|
if ADFieldJobs.state.paused then started = {} end
|
|
for _, entry in ipairs(started) do
|
|
-- egen mark (kontrakt på egen jord findes ikke i FS25, men for en sikkerheds skyld): rør ikke spillerens plan
|
|
local own = ADFieldJobs.state.fields[entry.fieldId]
|
|
if own == nil or own.contract then
|
|
if decision ~= "ask" then
|
|
-- "Moden altid" -> [Til]; "Jeg selv altid" -> [Fra] (kan slås til senere)
|
|
start(adEnv, entry, decision == "start")
|
|
elseif ADContracts.asking == nil then
|
|
ask(entry) -- én dialog ad gangen; de næste spørges ved de følgende aflæsninger
|
|
end
|
|
end
|
|
end
|
|
end
|