GE Lua Documentation

loadCompleteDragRaceData

Definition

-- @/lua/ge/extensions/gameplay/drag/saveSystem.lua:36

M.loadCompleteDragRaceData = function(stripId)

  local stripData = jsonReadFile(stripId)
  if not stripData then
    log('E', logTag, 'Strip file not found: ' .. stripId)
    return nil
  end


  local completeData = {
    strip = {
      id = stripData.id,
      name = stripData.name,
      description = stripData.description,
      endCamera = stripData.endCamera,
      lanes = {}
    },
    racers = {}, -- Initialize racers array
    phases = {
      {
        name = "stage",
        dependency = true,
        startedOffset = 0
      },
      {
        name = "countdown",
        dependency = true,
        startedOffset = 0
      },
      {
        name = "race",
        dependency = false,
        startedOffset = 0
      },
      {
        name = "stop",
        dependency = false,
        startedOffset = 0
      }
    }, -- Initialize phases array
    prefabs = {
      christmasTree = {
        isUsed = false,
        treeType = ".400"
      },
      displaySign = {
        isUsed = false
      },
      paths = {
        isUsed = false
      },
      decorations = {
        isUsed = false
      }
    },
    dragType = "dragPracticeRace", -- Default drag type
    context = "freeroam", -- Default context
    canBeReseted = true,
    canBeTeleported = true,
    isStarted = false,
    isCompleted = false
  }

  if stripData.lanes then
    for _, lane in ipairs(stripData.lanes) do

      local completeLane = {
        id = lane.id,
        shortName = lane.shortName,
        longName = lane.longName,
        color = lane.color,
        laneOrder = lane.laneOrder,
        waypoints = {},
        boundary = {}
      }

      if lane.waypoints then
        for _, waypoint in ipairs(lane.waypoints) do
          local rot = quat(waypoint.transform.rotation.x, waypoint.transform.rotation.y, waypoint.transform.rotation.z, waypoint.transform.rotation.w)
          local scl = vec3(waypoint.transform.scale.x, waypoint.transform.scale.y, waypoint.transform.scale.z)

          completeLane.waypoints[waypoint.type] = {
            id = waypoint.id,
            name = waypoint.name,
            transform = {
              position = vec3(waypoint.transform.position.x, waypoint.transform.position.y, waypoint.transform.position.z),
              rotation = rot,
              scale = scl,
              -- Legacy compatibility fields
              pos = vec3(waypoint.transform.position.x, waypoint.transform.position.y, waypoint.transform.position.z),
              rot = rot,
              scl = scl,
              -- Add coordinate system axes for compatibility with areFrontWheelsParallelToLine
              x = rot * vec3(scl.x, 0, 0),
              y = rot * vec3(0, scl.y, 0),
              z = rot * vec3(0, 0, scl.z)
            },
            waypoint = waypoint.waypoint
          }
        end
      end

      -- Calculate stageToEndNormalized vector from waypoints
      if completeLane.waypoints.stage and completeLane.waypoints.endLine then
        local stagePos = completeLane.waypoints.stage.transform.position
        local endPos = completeLane.waypoints.endLine.transform.position
        local stageToEnd = endPos - stagePos
        completeLane.stageToEndNormalized = stageToEnd:normalized()
      else
        -- Fallback: use default forward direction if waypoints are missing
        completeLane.stageToEndNormalized = vec3(1, 0, 0)
      end

      if lane.boundary then
        completeLane.boundary = {
          transform = {
            position = vec3(lane.boundary.transform.position.x, lane.boundary.transform.position.y, lane.boundary.transform.position.z),
            rotation = quat(lane.boundary.transform.rotation.x, lane.boundary.transform.rotation.y, lane.boundary.transform.rotation.z, lane.boundary.transform.rotation.w),
            scale = vec3(lane.boundary.transform.scale.x, lane.boundary.transform.scale.y, lane.boundary.transform.scale.z),
          }
        }
      end

      table.insert(completeData.strip.lanes, completeLane)
    end
  end

  return completeData
end

Callers

  if data.stripId then
    local stripData = M.loadCompleteDragRaceData(data.stripId)
    if stripData then

  -- Try new modular system first
  local dragStrip = gameplay_drag_saveSystem.loadCompleteDragRaceData(dragStripId)
  if dragStrip then

  if dragStripId then
    dragStrip = gameplay_drag_saveSystem.loadCompleteDragRaceData(dragStripId)
  else