GE Lua Documentation

    end
    sortedCategories = tableKeys(allCategories)
    local orderSort = function(a, b)

  sortedTags = tableKeys(tags)
  table.sort(sortedTags, sortFunc)

  local sortFunc = function(a,b) return string.lower(a) < string.lower(b) end
  groundModels = tableKeys(core_environment.groundModels) ---
  table.sort(groundModels, sortFunc)

          configs = {},
          paints = tableKeys(tableValuesAsLookupDict(v.model.paints or {}))
        }

    local selectedConfig = eligibleVehicles[math.random(eligibleCount)]
    local paints = tableKeys(tableValuesAsLookupDict(core_vehicles.getModel(selectedConfig.model_key).model.paints or {}))
    local paintCount = #paints

  local spots = sites.parkingSpots
  local names = tableKeys(spots.byName)
  if not names[2] then -- needs at least two parking spots

  if im.CollapsingHeader1("Lighting", im.TreeNodeFlags_DefaultOpen) then
    local sortedHDRsettings = tableKeys(HDRsettings)
    table.sort(sortedHDRsettings, sortFunc)

local function renderHDRLightingTab()
  local sortedHDRsettings = tableKeys(HDRsettings)
  table.sort(sortedHDRsettings, sortFunc)

          else
            allPaints = tableKeys(tableValuesAsLookupDict(modelData.model.paints or {})) -- if random paint is true
            if configData and configData.aggregates and configData.aggregates["Config Type"] then

  local groundModelName = terrainMtlCopyProxy.groundmodelName
  local groundModelNamesSorted = tableKeys(core_environment.groundModels)
  table.sort(groundModelNamesSorted)

  local groundModelName = terrainMtlCopyProxy.groundmodelName
  local groundModelNamesSorted = tableKeys(core_environment.groundModels)
  table.sort(groundModelNamesSorted)

    if #zone.vertices > 2 then
      local type = tableKeys(zone.customFields.tags or {})[1] or "mixed"
      pointsByType[type] = pointsByType[type] or {}

    self:setSortingValue(self.mgr.garbageData.graphSum)
    local graphIdsSortedByTotalGarbage = tableKeys(self.mgr.garbageData.graphs or {})
    table.sort(graphIdsSortedByTotalGarbage, function(a,b) return self.mgr.garbageData.graphs[a].value > self.mgr.garbageData.graphs[b].value end)

    local nodeIdsSortedByTotalGarbage = tableKeys(self.mgr.garbageData.nodes or {})
    table.sort(nodeIdsSortedByTotalGarbage, function(a,b) return self.mgr.garbageData.nodes[a].value > self.mgr.garbageData.nodes[b].value end)

function tableKeysSorted(tbl, target)
  local res = tableKeys(tbl, target)
  table.sort(res, tableSortCompareMultiType)

  if freeroam_bigMapMode then
    freeroam_bigMapMode.setOnlyIdsVisible(tableKeys(visibleIds))
  end

  if not arrayFindValueIndex(tableKeys(vdata.cameras), "onboard.driver") then
    vdata.cameras.driver = nil -- there's no driver data to feed the driver cam, so remove it

local function tableKeysWeightSorted(tbl, tableWeights)
  return sortTableKeysByWeight(tableKeys(tbl), tableWeights)
end

          configs = {},
          paints = tableKeys(tableValuesAsLookupDict(v.model.paints or {}))
        }

  end
  vehicles = tableKeys(vehicles)

  local keys = tableKeys(couldBe)
  if tableSize(keys) == 1 then

    end
    for i = 1, #tableKeys(self.mission.careerSetup.starsActive) do
      if im.Selectable1("Default Star " .. i, currentSlot == "Default Star " .. i) then

  --table.clear(visibleIdsSorted)
  --tableKeys(visibleIds, visibleIdsSorted)
  --table.sort(visibleIdsSorted)

local function setupGroundmodels()
  local gMNames = tableKeys(core_environment.groundModels)
  table.sort(gMNames, sortFunc)

  menuItemsSorted = tableKeys(menuItems)
  table.sort(menuItemsSorted)

  table.sort(menuItemsSorted)
  additionalMenuItemsSorted = tableKeys(additionalMenuItems)
  table.sort(additionalMenuItemsSorted)

        configs = {},
        paints = tableKeys(tableValuesAsLookupDict(v.model.paints or {}))
      }

  -- pairs is non deterministic, so sort this ourselfs
  local graphKeys = tableKeys(self.graphs)
  table.sort(graphKeys)

  local macroKeys = tableKeys(self.macros)
  table.sort(macroKeys)

      local graphKeys = tableKeys(data.graphs)
      table.sort(graphKeys)

      local graphKeys = tableKeys(self.graphs)
      table.sort(graphKeys)

      if childCount >= 2 then
        table.insert(branches, {node = node, links = tableKeys(graph[node]), sqDist = posNodeDist})
      end

  local orderIndex = 1
  local skillIds = tableKeys(leaguesBySkill)
  table.sort(skillIds, function(a, b)

M.refreshDependencies = function()
  local deps = tableKeys(M.runningProxies)
  M.dependencies = deps

function C:_drawDataTable(path, cdata, v, savePath, saveCallback, keysEditable)
  local orderedKeys = tableKeys(v or {})
  table.sort(orderedKeys)

  -- get all the endsSpots and shuffle them
  local possibleEndSpots = tableKeys(self.spots.byName)
  for i = #possibleEndSpots, 2, -1 do

      self.spots = self.pinIn.sitesData.value.parkingSpots
      self.names = tableKeys(self.spots.byName)

      self.spots = self.pinIn.sitesData.value.parkingSpots
      self.names = tableKeys(self.spots.byName)
      --SPLIT THE SPOTS USING TAGS

  if im.BeginCombo("##loadNode", "Load from library...") then
    local sortedNames = tableKeys(customNodes)
    table.sort(sortedNames)

      local changeText = ""
      for _, key in ipairs(career_branches.orderAttributeKeysByBranchOrder(tableKeys(change.attributeChange))) do
        changeText = changeText .. string.format('%s: %s%0.2f
', key, change.attributeChange[key] > 0 and "+" or "", change.attributeChange[key])

    table.insert(allClusters, {type='coordinates', level=cluster[1].level, pos=newCenter, rot=cluster[1].rot, radius=radius, check=defaultLocationCheck, displayMarker=defaultLocationDisplayMarker, missionIds = tableKeys(missionIds), clusterId = clusterId})
  end

  if not lookup[nodeType] then
    log('E', 'flowgraph_graph.createNode', 'unable to find node type: "' .. tostring(nodeType) .. '". Available types: ' .. dumps(tableKeys(lookup)))
    return

  local nodeKeys = tableKeys(data.nodes)
  table.sort(nodeKeys)

  end
  local sources = tableKeys(sourcesByIconCount)
  table.sort(sources, function(a, b)

  end
  local sources = tableKeys(sourcesByIconCount)
  table.sort(sources, function(a, b)

    local customFnCount = 0
    local sortedKeys = tableKeys(elem)
    table.sort(sortedKeys)

      entryFeeAsList = {}
      local attributesSorted = tableKeys(entryFee)
      table.sort(attributesSorted, career_branches.sortAttributes)

        local parkingSpots = gameplay_parking.getParkingSpots().byName
        local parkingSpotNames = tableKeys(parkingSpots)

      if var.typeColors then
        local sortedTbl = tableKeys(var.typeColors)
        table.sort(sortedTbl)

    local entryFeeAsList = {}
    local attributesSorted = tableKeys(entryFee)
    table.sort(attributesSorted, career_branches.sortAttributes)

  if not conditionsSortedCache then
    conditionsSortedCache = tableKeys(missionConditions)
    table.sort(conditionsSortedCache)

  local match = string.lower(ffi.string(self.searchText))
  for _, t in ipairs(tableKeys(typeOrder)) do
    if match:find(t..": ") ~= nil then

  -- Deterministic node ordering
  local sortedNodeKeys = tableKeys(nodes)
  table.sort(sortedNodeKeys)

-- Helper function to get table keys
local function tableKeys(t)
  local keys = {}

    end
    log("I","",string.format("Loaded %d item templates from %d files.", #tableKeys(parcelItemTemplates), #files))
  end

      end
      --print(string.format("Facility: %s provides systems: %s", fac.name, table.concat(tableKeys(fac.providedSystemsLookup),", " )))
      --print(string.format("Facility: %s receives systems: %s", fac.name, table.concat(tableKeys(fac.receivedSystemsLookup),", " )))

      --print(string.format("Facility: %s provides systems: %s", fac.name, table.concat(tableKeys(fac.providedSystemsLookup),", " )))
      --print(string.format("Facility: %s receives systems: %s", fac.name, table.concat(tableKeys(fac.receivedSystemsLookup),", " )))
    end

    log("I","",string.format("Setup Logistics Facilities: %d Facilities (%d only provide, %d mixed, %d only receive), %d Parking spots", #tableKeys(facilitiesById), countProviders, countMixed, countReceivers, #tableKeys(parkingSpotsByPath)))
    facilitiesSetup = true

    log("I","",string.format("Setup Logistics Facilities: %d Facilities (%d only provide, %d mixed, %d only receive), %d Parking spots", #tableKeys(facilitiesById), countProviders, countMixed, countReceivers, #tableKeys(parkingSpotsByPath)))
    facilitiesSetup = true

    end
    --log("I","","Loaded " .. #tableKeys(spotsById) .. " drift spots and " .. loaded .. " drift score files.")
  end

  if logEnabled and players > 1 then log("D", "multiseat", "Settled for "..players.." players:  supported="..maxPlayers..", vehicles="..nVehicles..", devices="..nControllers.." (& mouse)") end
  local devnames = tableKeys(devices)
  table.sort(devnames)

    M.description = {}
    M.photoSafarimissions = tableKeys(M.photoSafariData)
   for _,k in ipairs(M.photoSafarimissions) do

    log("I", logTag, "Loaded " .. #tableKeys(playerTrailsById) .. " player crawl trails and " .. loaded .. " crawl score files.")
  end

  end
  local keys = tableKeys(ret)
  career_branches.orderAttributeKeysByBranchOrder(keys)

    if count > 1 then
      if #tableKeys(iconExistence) > 1 then
        icon = ("poi_no-0") .. math.min(count, 9)

  -- temp fix for having force feedback: wheel0 is before xinput0
  local sortedNodeKeys = tableKeys(devices)
  table.sort(sortedNodeKeys)

      editor.createIconAtlas()
      icons = tableKeys(editor.icons)
      table.sort(icons)

local function onEditorInitialized()
  icons = tableKeys(editor.icons)
  table.sort(icons)

local function onSerialize()
  local data = {active = active, debugLevel = M.debugLevel, parkedVehIds = deepcopy(parkedVehIds), trackedVehIds = tableKeys(trackedVehData), vars = deepcopy(vars)}
  resetAll()

  end
  log("I","",string.format("Found %d paints, %d paint collections, %d multiPaintSetups in %d paint libraries, %d same-name paint names", #tableKeys(paintsByIdCache), #tableKeys(paintCollectionsByIdCache), #tableKeys(multiPaintSetupsByIdCache), #tableKeys(core_vehicles.getPaintFiles()), multiNames))
end

  end
  log("I","",string.format("Found %d paints, %d paint collections, %d multiPaintSetups in %d paint libraries, %d same-name paint names", #tableKeys(paintsByIdCache), #tableKeys(paintCollectionsByIdCache), #tableKeys(multiPaintSetupsByIdCache), #tableKeys(core_vehicles.getPaintFiles()), multiNames))
end

  end
  log("I","",string.format("Found %d paints, %d paint collections, %d multiPaintSetups in %d paint libraries, %d same-name paint names", #tableKeys(paintsByIdCache), #tableKeys(paintCollectionsByIdCache), #tableKeys(multiPaintSetupsByIdCache), #tableKeys(core_vehicles.getPaintFiles()), multiNames))
end

  end
  log("I","",string.format("Found %d paints, %d paint collections, %d multiPaintSetups in %d paint libraries, %d same-name paint names", #tableKeys(paintsByIdCache), #tableKeys(paintCollectionsByIdCache), #tableKeys(multiPaintSetupsByIdCache), #tableKeys(core_vehicles.getPaintFiles()), multiNames))
end

  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), ", "))

    local customFnCount = 0
    local sortedKeys = tableKeys(elem)
    table.sort(sortedKeys)

    if not types[log.type] then
      types[log.type] = #tableKeys(types) + 1
    end

  if not policeIds then
    policeIds = tableKeys(policeVehs) -- use all police vehicles
  elseif type(policeIds) == 'number' then -- backwards compatibility

local function customLuaNodesManagerUi()
  local sortedNames = tableKeys(editor.getPreference('flowgraph.general.customLuaNodes'))
  table.sort(sortedNames)

  local match = string.lower(ffi.string(self.searchText))
  for _, t in ipairs(tableKeys(typeOrder)) do
    if match:find(t..": ") ~= nil then

  local newGraph = self.mgr.graph
  local groupNode = newGraph.nodes[tableKeys(self.mgr.selectedNodes)[1]]
  local groupedGraph = groupNode:representsGraph()

    sortedBranches = {}
    local keysSorted = tableKeys(branchesByPath)
    table.sort(keysSorted, sortBranchNames)

local function orderBranchNamesKeysByBranchOrder(list)
  list = list or tableKeys(branchesById)
  table.sort(list, sortBranchNames)

      entryFeeAsList = {}
      local attributesSorted = tableKeys(entryFee)
      table.sort(attributesSorted, career_branches.sortAttributes)

      local key = next(fuelTranslations)
      if #tableKeys(fuelTranslations) > 1 then
        key = "refuelMixed"

      local key = next(fuelTranslations)
      if #tableKeys(fuelTranslations) > 1 then
        key = "refuelMixed"

  gms = tableKeys(core_environment.groundModels)
  table.sort(gms)

      vgmk = tableKeys(visibleGroundModels)
      table.sort(vgmk, function(a, b) return visibleGroundModels[a] > visibleGroundModels[b] end)

      local rewards = {}
      for _, key in ipairs(career_branches.orderAttributeKeysByBranchOrder(tableKeys(change.attributeChange))) do
        if key:endswith("Reputation") then

  if not modelInfo then return end
  local paints = tableKeys(tableValuesAsLookupDict(modelInfo.model.paints or {}))
  local paint1, paint2, paint3 = paints[math.random(1, #paints)], paints[math.random(1, #paints)], paints[math.random(1, #paints)]

          configs = {},
          paints = tableKeys(tableValuesAsLookupDict(v.model.paints or {}))
        }

  local bestDistance = 0
  local targets = tableKeys(map.getMap().nodes)
  for i = 1, 10 do

  if modelData and modelData.model and modelData.model.paints then
    return tableKeys(tableValuesAsLookupDict(modelData.model.paints))
  end

  local modelDataPaints = modelData and modelData.paints or {}
  local paintNames = tableKeys(modelDataPaints)

  local sortedKeys = tableKeys(layer.properties)
  table.sort(sortedKeys)

        configs = {},
        paints = model and model.model and tableKeys(tableValuesAsLookupDict(model.model.paints or {})) or {}
      }