api.lua

-- ============================================================
--  CONFIGURATION  (edit these values before running)
-- ============================================================
local ASSET_ID          = 0          -- Replace with your rbxassetid number
local API_CALL_DELAY    = 0.01       -- Seconds between SyncAPI calls (tune to avoid kick)
local DRY_RUN           = false      -- If true, counts parts and prints a preview without building
local PLACEMENT_OFFSET  = CFrame.new(0, 0, 0)  -- World-space offset for the entire build
-- ============================================================

local Players = game:GetService("Players")
local StarterGui = game:GetService("StarterGui")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer

-- Safety: wait for character
local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()

local BuildingTools = character:WaitForChild("Building Tools", 5)
if not BuildingTools then return end

local SyncAPI = BuildingTools:WaitForChild("SyncAPI", 5)
if not SyncAPI then return end

local ServerEndpoint = SyncAPI:WaitForChild("ServerEndpoint", 5)
if not ServerEndpoint then return end

-- Tracks every created part so undoBuild() can remove them all
local createdParts = {}

-- ============================================================
--  RATE-LIMITED INVOKE
--  Wraps all SyncAPI calls with a configurable delay and pcall
-- ============================================================
local function invoke(method: string, ...): any
    task.wait(API_CALL_DELAY)
    local ok, result = pcall(ServerEndpoint.InvokeServer, ServerEndpoint, method, ...)
    return ok and result or nil
end

-- ============================================================
--  CORE BUILDING FUNCTIONS
-- ============================================================

local function createPart(partType: string, cf: CFrame): BasePart?
    local part = invoke("CreatePart", partType, cf, workspace)
    if not part then return nil end

    local t = 0
    while not workspace:FindFirstChild(part.Name) and t < 5 do
        t += task.wait(0.05)
    end
    table.insert(createdParts, part)
    return part
end

local function determinePartType(part: BasePart): string
    if part:IsA("TrussPart") then return "Truss" end
    if part:IsA("WedgePart") then return "Wedge" end
    if part:IsA("CornerWedgePart") then return "Corner" end
    if part:IsA("Seat") then return "Seat" end
    if part:IsA("VehicleSeat") then return "VehicleSeat" end
    if part:IsA("SpawnLocation") then return "Spawn" end
    return "Normal"
end

local function copyTextures(newPart: BasePart, sourcePart: BasePart)
    for _, child in sourcePart:GetChildren() do
        if child:IsA("Texture") or child:IsA("Decal") then
            invoke("CreateTextures", {{ Part = newPart, Face = child.Face, TextureType = child.ClassName }})
        end
    end
end

local function copyLights(newPart: BasePart, sourcePart: BasePart)
    for _, child in sourcePart:GetChildren() do
        local lightType = child:IsA("PointLight") and "PointLight" or
                          child:IsA("SpotLight") and "SpotLight" or
                          child:IsA("SurfaceLight") and "SurfaceLight"

        if lightType then
            invoke("CreateLights", {{ Part = newPart, LightType = lightType }})
        end
    end
end

-- ============================================================
--  MAIN BUILD FUNCTION  (called per BasePart)
-- ============================================================
local function buildPart(sourcePart: BasePart, targetCF: CFrame)
    if not sourcePart:IsA("BasePart") then return end

    local newPart = createPart(determinePartType(sourcePart), targetCF)
    if not newPart then return end

    invoke("SyncColor", {{ Part = newPart, UnionColoring = true, Color = sourcePart.Color }})
    invoke("SyncResize", {{ Part = newPart, CFrame = targetCF, Size = sourcePart.Size }})
    invoke("SyncMaterial", {{ 
        Part = newPart, 
        Material = sourcePart.Material,
        Transparency = sourcePart.Transparency,
        Reflectance = sourcePart.Reflectance
    }})
    invoke("SyncCollision", {{ Part = newPart, CanCollide = sourcePart.CanCollide }})

    if sourcePart.Anchored then
        invoke("SyncAnchor", {{ Part = newPart, Anchored = true }})
    end

    if sourcePart:IsA("MeshPart") and sourcePart.MeshId ~= "" then
        invoke("CreateMeshes", {{ Part = newPart }})
        invoke("SyncMesh", {{
            Part = newPart,
            MeshType = Enum.MeshType.FileMesh,
            MeshId = sourcePart.MeshId,
            TextureId = sourcePart.TextureID or ""
        }})
    end

    local specialMesh = sourcePart:FindFirstChildOfClass("SpecialMesh")
    if specialMesh then
        invoke("CreateMeshes", {{ Part = newPart }})
        invoke("SyncMesh", {{
            Part = newPart,
            MeshType = specialMesh.MeshType,
            MeshId = specialMesh.MeshId,
            TextureId = specialMesh.TextureId,
            Scale = specialMesh.Scale,
            Offset = specialMesh.Offset
        }})
    end

    copyTextures(newPart, sourcePart)
    copyLights(newPart, sourcePart)
end

-- ============================================================
--  UNDO  — removes every part created during this session
-- ============================================================
_G.undoBuild = function()
    for _, part in createdParts do
        if part and part.Parent then invoke("DeleteParts", {{ Part = part }}) end
    end
    table.clear(createdParts)
end

-- ============================================================
--  LOAD & BUILD
-- ============================================================

if ASSET_ID == 0 then return end

local ok, objects = pcall(game.GetObjects, game, "rbxassetid://" .. ASSET_ID)
if not ok or type(objects) ~= "table" or not objects[1] then return end

local model = objects[1]
model.Parent = workspace

local parts = {}
for _, descendant in model:GetDescendants() do
    if descendant:IsA("BasePart") then table.insert(parts, descendant) end
end

local totalParts = #parts

if DRY_RUN then
    model:Destroy()
    return
end

local modelOriginCF = CFrame.identity
if model:IsA("Model") then
    local cf = model:GetBoundingBox()
    modelOriginCF = cf
elseif #parts > 0 then
    modelOriginCF = parts[1].CFrame
end

-- Assemble the Ghost Hologram
local ghostModel = model:Clone()
for _, desc in ghostModel:GetDescendants() do
    if desc:IsA("BasePart") then
        desc.CanCollide = false
        desc.Anchored = true
        desc.CastShadow = false
        desc.Transparency = 0.6
        desc.Material = Enum.Material.SmoothPlastic
        desc.Color = Color3.new(0, 1, 1)
    elseif desc:IsA("Script") or desc:IsA("LocalScript") then
        desc:Destroy()
    end
end
ghostModel.Parent = workspace

local isLocked = false
local currentCF = modelOriginCF
local camera = workspace.CurrentCamera
local lastGhostPos = Vector3.zero

-- Zero-lag placement logic
local function updateGhost()
    if isLocked then return end
    
    local ray = camera:ViewportPointToRay(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {LocalPlayer.Character, ghostModel}

    local result = workspace:Raycast(ray.Origin, ray.Direction * 300, params)
    local pos = result and result.Position or (ray.Origin + ray.Direction * 40)
    
    -- Optimize rendering: only pivot if magnitude delta > 0.2 studs
    if (lastGhostPos - pos).Magnitude < 0.2 then return end
    lastGhostPos = pos

    currentCF = CFrame.new(pos)
    ghostModel:PivotTo(currentCF)
end

RunService:BindToRenderStep("BuilderGhost", Enum.RenderPriority.Camera.Value + 1, updateGhost)

local tapCount = 0
local tapStartTime = 0
local inputConnection

local function startBuildProcess()
    local finalCF = currentCF
    ghostModel:Destroy()
    
    StarterGui:SetCore("SendNotification", {
        Title = "Building started...",
        Text = string.format("Placing %d parts.", totalParts),
        Duration = 3
    })

    task.spawn(function()
        local built = 0
        local failed = 0
        
        for i, sourcePart in ipairs(parts) do
            local relativeCF = modelOriginCF:ToObjectSpace(sourcePart.CFrame)
            -- Anchor onto our screen-raycasted target location + optional offsets
            local targetCF = (finalCF * PLACEMENT_OFFSET) * relativeCF
            
            local success = pcall(buildPart, sourcePart, targetCF)
            if success then
                built += 1
            else
                failed += 1
            end

            if i % 15 == 0 or i == totalParts then
                StarterGui:SetCore("SendNotification", {
                    Title = "Building...",
                    Text = string.format("Part %d of %d", i, totalParts),
                    Duration = 2
                })
            end
        end

        model:Destroy()

        StarterGui:SetCore("SendNotification", {
            Title = "Build complete!",
            Text = string.format("Built %d / %d parts. Failed: %d", built, totalParts, failed),
            Icon = "rbxthumb://type=AvatarHeadShot&id=" .. LocalPlayer.UserId .. "&w=180&h=180",
            Duration = 7
        })
    end)
end

-- Custom tap recognition engine
inputConnection = UserInputService.InputBegan:Connect(function(input, gpe)
    if gpe then return end
    if input.UserInputType == Enum.UserInputType.Touch or input.UserInputType == Enum.UserInputType.MouseButton1 then
        local now = tick()
        -- Prevent infinite accumulation by limiting maximum tap time window
        if tapCount == 0 or (now - tapStartTime) > 0.67 then
            tapCount = 1
            tapStartTime = now
        else
            tapCount += 1
        end

        if tapCount == 2 then
            isLocked = not isLocked
            StarterGui:SetCore("SendNotification", {
                Title = "Builder Mode",
                Text = isLocked and "🔒 Position Locked! Triple tap to build." or "🔓 Position Unlocked!",
                Duration = 2
            })
        elseif tapCount == 3 then
            isLocked = true
            RunService:UnbindFromRenderStep("BuilderGhost")
            inputConnection:Disconnect()
            startBuildProcess()
        end
    end
end)

StarterGui:SetCore("SendNotification", {
    Title = "Builder Mode Activated",
    Text = "Double tap to lock position.\nTriple tap to build.",
    Duration = 5
})