GE Lua Documentation

  sectionNamesSorted = {}
  local sortedTbl = tableKeysSorted(sectionsPartsMods)
  for k,v in pairs(sortedTbl) do

  for sectionName, mods in pairs(outSectionsAllModNames) do
    sortedTbl = tableKeysSorted(mods)
    sectionsModNamesSorted[sectionName] = {}

}
local paramKeys = tableKeysSorted(params)
local routeTracking = false

  vehicleIds = tableKeysSorted(vehicles)
end

  vehicles[id] = nil
  vehicleIds = tableKeysSorted(vehicles)
end

  local ekeys = {}
  local vkeys = tableKeysSorted(vehicle)
  for _, keyEntry in ipairs(vkeys) do

        table.clear(ekeys)
        tableKeysSorted(entry, ekeys)
        for _, rowKey in ipairs(ekeys) do

      local sorted = tableKeysSorted(namesToID)

    trafficIdsSorted = tableKeysSorted(traffic)
    auxiliaryData.activeChanged = true

    traffic[id] = nil
    trafficIdsSorted = tableKeysSorted(traffic)
    auxiliaryData.activeChanged = true

local function deactivate(stopAi) -- deactivates traffic mode for all vehicles
  for _, id in ipairs(tableKeysSorted(traffic)) do
    removeTraffic(id, stopAi)

        -- sort keys first
        local tableKeys = tableKeysSorted(v)
        for _, kk in pairs(tableKeys) do

  elseif pKeys == 'any' then
    pKeys = tableKeysSorted(missions.saveData.progress)
  else

    if im.BeginCombo("Signal Action##ctrlDefinitionState", currData.action or "(None)") then
      for _, action in ipairs(tableKeysSorted(signalCtrlDefinitions.signalActions)) do
        if im.Selectable1(action.."##ctrlDefinitionState", currData.action == action) then

      if im.BeginCombo("Light Color #"..i.."##ctrlDefinitionStateLight"..i, currData.flashingLights[selected.flashingLight][i] or "(None)") then
        for _, color in ipairs(tableKeysSorted(signalCtrlDefinitions.signalColors)) do
          if im.Selectable1(color.."##ctrlDefinitionStateLight"..i, currData.flashingLights[selected.flashingLight][i] == color) then

    if signalCtrlDefinitions._update then
      signalCtrlDefinitions.statesSorted = tableKeysSorted(signalCtrlDefinitions.states)
      signalCtrlDefinitions.typesSorted = tableKeysSorted(signalCtrlDefinitions.types)

      signalCtrlDefinitions.statesSorted = tableKeysSorted(signalCtrlDefinitions.states)
      signalCtrlDefinitions.typesSorted = tableKeysSorted(signalCtrlDefinitions.types)

      local tempStates = tableMerge(signalCtrlDefinitions.origStates, signalCtrlDefinitions.states)
      signalCtrlDefinitions.tempStatesSorted = tableKeysSorted(tempStates)

    if im.BeginCombo("Signal Type##controller", typeName) then
      for _, k in ipairs(tableKeysSorted(signalTypes)) do
        if im.Selectable1(signalTypes[k].name, k == currController.type) then

      quickTravelUnlocked = qtEnabled and gameplay_missions_progress.missionHasQuickTravelUnlocked(elemData.missionId),
      branchTagsSorted = tableKeysSorted(mission.unlocks.branchTags),
      -- these two will show below the mission and will be a context translation.

  }
  for _, groupKey in ipairs(tableKeysSorted(groupData)) do
    if string.startswith(groupKey,'missionType_') then

  model.paints = model.paints or {}
  debugLog("Model has " .. #tableKeys(model.paints) .. " explicit paints: " .. table.concat(tableKeysSorted(model.paints), ", "))

  debugLog("Finished: Model has " .. #tableKeys(model.paints) .. " paints: " .. table.concat(tableKeysSorted(model.paints), ", "))

  end
  return tableKeysSorted(fieldNameFiles)
end

  for _, field in ipairs(tableKeysSorted(mtd)) do
    if not fieldsChecked[field] then

    if f.id ~= fac.id and f.logisticTypesReceivedLookup[materialType] and f.materialStorages[materialType] then
      for _, apName in ipairs(tableKeysSorted(f.accessPointsByName)) do
        local ap = f.accessPointsByName[apName]

      if missing then
        log("E","",string.format("Fix Facility %s provided types: [\"%s\"]", fac.id, table.concat(tableKeysSorted(fac.logisticTypesProvidedLookup),'", "') )
          )

          )
        log("E","",string.format("Fix Facility %s received types: [\"%s\"]", fac.id, table.concat(tableKeysSorted(fac.logisticTypesReceivedLookup),'", "') )
          )

    end
    for _, key in ipairs(tableKeysSorted(allTypes)) do
      --print(string.format("%s -> %s", key, dumps(logisticTypeToSystem(key))))

    end
    for _, key in ipairs(tableKeysSorted(materialRatesProvided)) do
      print(key)

      print(string.format("Total IN: %0.2f/min", materialRatesProvided[key].total*60))
      for _, facId in ipairs(tableKeysSorted(materialRatesProvided[key])) do
        if facId ~= "total" then

      print(string.format("Total OUT: %0.2f/min", materialRatesReceived[key].total*60))
      for _, facId in ipairs(tableKeysSorted(materialRatesReceived[key])) do
        if facId ~= "total" then

    end
    for _, orgId in ipairs(tableKeysSorted(orgToFacs)) do
      local org = freeroam_organizations.getOrganization(orgId)

    parkedVehData[id] = nil
    parkedVehIds = tableKeysSorted(parkedVehData)
  end

    im.Text("App Controls:")
    for _, appId in ipairs(tableKeysSorted(container.apps)) do
      local app = container.apps[appId]

      self.paints = modelData.model.paints
      self.paintKeys = self.paints and tableKeysSorted(self.paints) or {}
    end

  local data = { }
  for _, materialType in ipairs(tableKeysSorted(fac.materialStorages)) do
    local storage = fac.materialStorages[materialType]

    list = list,
    filters = tableKeysSorted(filters)
  }

  -- Sort the table
  local keys = tableKeysSorted(resTable)

      local keysSorted = tableKeysSorted(json) -- material name alphabetical order; may not be needed

  end
  self.starKeysSorted = self.missionInstance.sortedStarKeys or tableKeysSorted(self.missionInstance.starLabels or {})
  inputBuffers = {}

  local r = math.random()
  --for _, modKey in ipairs(tableKeysSorted(modifiers)) do
  for _, modKey in ipairs(tableKeysSorted(parcelTemplate.modChance)) do

  --for _, modKey in ipairs(tableKeysSorted(modifiers)) do
  for _, modKey in ipairs(tableKeysSorted(parcelTemplate.modChance)) do
    if r <= parcelTemplate.modChance[modKey] then

  end
  forestItemTypes = tableKeysSorted(forestItemDict)
end

  for _, partASTIdx in ipairs(tableKeysSorted(astIdxToPart)) do
    local partName = astIdxToPart[partASTIdx]

    for _, sectionASTIdx in ipairs(tableKeysSorted(astIdxToSection)) do
      local sectionName = astIdxToSection[sectionASTIdx]

    end
      --dump(tableKeysSorted(spotsById))
    if career_career.isActive() then

  local sortedEntries = tableKeysSorted(entries)

  sortedEntries = tableKeysSorted(entries)

  if not mission.sortedStarKeys or mission.sortedStarKeys == {} then
    for i, key in ipairs(tableKeysSorted(mission.starLabels or {})) do
      starOrder[key] = i

  get()
  return tableKeysSorted(missionsById)
end

        -- sort keys first
        local tableKeys = tableKeysSorted(v)
        for _, kk in pairs(tableKeys) do

local function _flattenTable_rec(tbl, tableRegister, path)
  local keys = tableKeysSorted(tbl)

        else
          for _, key in ipairs(tableKeysSorted(filterByProp[propName])) do
            table.insert(filterData.options, key)

  end
  self.starKeysSorted = self.missionInstance.sortedStarKeys or tableKeysSorted(self.missionInstance.starLabels or {})
  inputBuffers = {}

  im.NextColumn()
  for _, key in ipairs(tableKeysSorted(sums.all)) do
    im.Text(key .." -> ".. sums.all[key])

  im.NextColumn()
  for _, key in ipairs(tableKeysSorted(sums.defaultOnly)) do
    im.Text(key .." -> ".. sums.defaultOnly[key])

  im.NextColumn()
  for _, key in ipairs(tableKeysSorted(sums.bonusOnly)) do
    im.Text(key .." -> ".. sums.bonusOnly[key])

  if data then
    ret = tableKeysSorted(data.originalVehicleTransforms or {})
  end

  self.prefabs[id] = nil
  self.sortedIds = tableKeysSorted(self.prefabs)
end

  self.pinInLocal.appContainerContext.hardTemplates = {}
  for _, appId in ipairs(tableKeysSorted(apps)) do
    table.insert(self.pinInLocal.appContainerContext.hardTemplates, {value = appId})

    recGetPart(vehData.config.partsTree or {}, partsHighlighted, partsHighlightedIdxs, partNameToIdx)
    local partsSorted = tableKeysSorted(partsHighlighted)

  local partsSorted = tableKeysSorted(partsFlattened)
  partsData.partsHighlighted = newHighlightedParts

  session.signalElements[signal.id] = signal
  session.lightsSorted = tableKeysSorted(session.lights)
end

      if im.BeginCombo("AI Mode##trafficManager", label or "(None)") then
        for _, t in ipairs(tableKeysSorted(aiModes)) do
          for _, mode in ipairs(tableKeysSorted(aiModes[t])) do

        for _, t in ipairs(tableKeysSorted(aiModes)) do
          for _, mode in ipairs(tableKeysSorted(aiModes[t])) do
            if im.Selectable1(aiModes[t][mode].."##trafficManagerAiMode", sessionData.aiMode == mode) then

          session.lights[currSelection.light] = nil
          session.lightsSorted = tableKeysSorted(session.lights)
        end

      signSelector = {model = "roadsigns", config = "stop", models = {}}
      local modelKeys = tableKeysSorted(core_vehicles.getModelList().models)
      for _, model in ipairs(modelKeys) do

      for _, m in ipairs(signSelector.models) do
        for _, c in ipairs(tableKeysSorted(core_vehicles.getModel(signSelector.model).configs)) do
          label = core_vehicles.getModel(m).configs[c].Configuration.." ["..c.."]"

      session.lightsSorted = tableKeysSorted(session.lights)
    else

  end
  return tableKeysSorted(ret)
end

  local keys = tableKeysSorted(t)

  local keys = tableKeysSorted(t)
  for _, k in ipairs(keys) do

      --table.sort(vehicleInfo.containers, function(a,b) return a.name < b.name end)
      for _, id in ipairs(tableKeysSorted(vehicleInfo.containersById)) do
        vehicleInfo.containersById[id].cargo = dParcelManager.addParcelRewardsSummary(deepcopy(vehicleInfo.containersById[id].cargo))

  dropOffDataStatus.customAmountPerMaterialType = {}
  for _, materialType in pairs(tableKeysSorted(unloadingMaterialInfoByKey)) do
    local info = unloadingMaterialInfoByKey[materialType]

    self.timelineTimes = tableKeysSorted(self.timeline) -- sequence timings table is used to order the sequence (by timestamp)

      end
      for _, key in ipairs(tableKeysSorted(stats)) do
        im.Text(string.format("%s: %d", key, stats[key]))

      im.Separator()
      for _, key in ipairs(tableKeysSorted(debugSettings)) do
        if debugSettingsData[key] then

    if configDetails.Region then
      local regions = tableKeysSorted(configDetails.Region)
      table.insert(devSpecs.specifications, {

    end
    for _, gId in ipairs(tableKeysSorted(cargoGrouped)) do
      local tasklistElement = {

    end
    for _, dId in ipairs(tableKeysSorted(transientPickupLocationGrouped)) do
      local tasklistElement = {

  table.clear(elementsToClearById)
  for _, tasklistId in ipairs(tableKeysSorted(tasklistElements)) do
    -- clearing of no longer used tasks.

  -- Sort by name and folders come first
  local keysSorted = tableKeysSorted(inTbl)
  table.sort(keysSorted,

    if data and data.attributes then
      local sortedKeys = tableKeysSorted(data.attributes)
      im.Columns(4)

  local listName = facilityTypeToListName[type] or "none"
  if listName == "none" then log("E","","Tried to get facility of type " .. dumps(type)..", which is not a valid type! ("..dumps(tableKeysSorted(facilityTypeToListName))) end

  local listName = facilityTypeToListName[type] or "none"
  if listName == "none" then log("E","","Tried to get facilities of type " .. dumps(type)..", which is not a valid type! ("..dumps(tableKeysSorted(facilityTypeToListName))) end

    }
    log("W","",string.format("Changed attributes '%s' without giving a reason!", table.concat( tableKeysSorted(change), ", ")))
  end

      im.Text("App Controls:")
      for _, appId in ipairs(tableKeysSorted(container.apps)) do
        local app = container.apps[appId]

  M.makeAllMissionStarMilestones(careerMissions, milestonesList)
  for _, branchKey in ipairs(tableKeysSorted(missionsByBranch)) do
    M.makeBranchMissionStarMilestones(missionsByBranch[branchKey], branchKey , milestonesList)

    end
    front = tableKeysSorted(nxt)
    c = c+1

  -- propagate the max lvl of a mission forward, so each mission knows the minimum branch level needed through predecessors
  local missionIdsWithBranchCondition = tableKeysSorted(highestLevelForMission)
  for _, mId in ipairs(missionIdsWithBranchCondition) do

    end
    front = tableKeysSorted(nxt)
    depth = depth+1

          if helper then
            local sortedFunctions = tableKeysSorted(helper)
            for _, funName in ipairs(sortedFunctions) do

    local html = "
"
    local keysSorted = tableKeysSorted(aggregate)
    for _, k in ipairs(keysSorted) do

  for _, field in ipairs(tableKeysSorted(ctd)) do
    if not fieldsChecked[field] then

    })
    local sortedGroupIds = tableKeysSorted(groupsById)
    for _, groupId in ipairs(sortedGroupIds) do

  local ordered = tableKeysSorted(starRewards.sums)
  career_branches.orderAttributeKeysByBranchOrder(ordered)

  -- Convert to ordered list
  local ordered = tableKeysSorted(rewardsByAttribute)
  career_branches.orderAttributeKeysByBranchOrder(ordered)

  end
  local allProgressKeys = tableKeysSorted(mission.saveData.progress)
  local formattedProgressByKey = {}

  end
  local allProgressKeys = tableKeysSorted(mission.saveData.progress)
  for _, progressKey in ipairs(allProgressKeys) do

        filterData.type = 'set'
        for _, key in ipairs(tableKeysSorted(filterByProp[propName])) do
          table.insert(filterData.options, key)

      end
      im.BulletText("flags: "..table.concat(tableKeysSorted(role.flags), ", "))

      if not allSuccess then
        for _, fuelType in ipairs(tableKeysSorted(invalidTanks)) do
          guihooks.trigger('Message',{msg = {txt = "ui.freeroam.refuel.notFilled", context = {fuelType = translateLanguage("ui.general.fuelType."..fuelType, fuelType, true)}}, category = "refueling-"..fuelType, icon = "warning", ttl=8})

    self.actionTemplates = core_input_actionFilter.getActionTemplates()
    self.sortedTemplateKeys = tableKeysSorted(self.actionTemplates)
  end

  end
  local list = core_input_actionFilter.createActionTemplate(tableKeysSorted(listByKey))

  if t.children then
    local keys = tableKeysSorted(t.children)
    for _, k in ipairs(keys) do

    --dump(deviceFactories)
    local devicesSorted = tableKeysSorted(deviceLookup)

      local deviceJbeamDataKeysSorted = tableKeysSorted(deviceJbeamData[device.name] or {})
      for _, k in ipairs(deviceJbeamDataKeysSorted) do

  local keysSorted = tableKeysSorted(unsortedList)

        local keys = tableKeysSorted(deviceNamesUnsorted)
        for _,name in ipairs(keys) do

  local clusterSettingsIdsSorted = tableKeysSorted(clusterSettingsById)
  --print("Begin Update")

}
local shapeKeys = tableKeysSorted(shapes)
shapes.mixed = {}

          if not mission then return false end
          local pKeys = tableKeysSorted(mission.saveData.progress)
          local met = false