-- 
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local RequestCommand = ReplicatedStorage:WaitForChild("HDAdminHDClient").Signals.RequestCommandSilent

RequestCommand:InvokeServer(";Time 0")
RequestCommand:InvokeServer(";btools me")
task.wait(0.4)

local player = Players.LocalPlayer
local char = player.Character or player.CharacterAdded:Wait()
local backpack = player.Backpack

local function getf3x_main()
    for _, v in ipairs(backpack:GetChildren()) do
        if v:FindFirstChild("SyncAPI") then
            return v
        end
    end
    for _, v in ipairs(char:GetChildren()) do
        if v:FindFirstChild("SyncAPI") then
            return v
        end
    end
    for _, v in ipairs(ReplicatedStorage:GetDescendants()) do
        if v.Name == "SyncAPI" then
            return v.Parent
        end
    end
    return nil
end

local f3x_main = getf3x_main()
if not f3x_main then
    warn("❌ F3X SyncAPI no encontrado")
    return
end

local serverendpoint = f3x_main.SyncAPI.ServerEndpoint
local function _(args)
    local success, err = pcall(function()
        return serverendpoint:InvokeServer(unpack(args))
    end)
    return success and err or nil
end

RequestCommand:InvokeServer(";unfog")
RequestCommand:InvokeServer(";fogcolor black")
RequestCommand:InvokeServer(";time 0")

local function resize(part, size, cf)
    _({ "SyncResize", { [1] = { ["Part"] = part, ["CFrame"] = cf, ["Size"] = size } } })
end

local function syncmaterial(part, mate)
    _({ "SyncMaterial", { [1] = { ["Part"] = part, ["Material"] = mate } } })
end

local function transparency(part, trans)
    _({ "SyncMaterial", { [1] = { ["Part"] = part, ["Transparency"] = trans } } })
end

local function color(part, col)
    _({ "SyncColor", { [1] = { ["Part"] = part, ["Color"] = col, ["UnionColoring"] = false } } })
end

local function syncmeshid(part, id)
    _({ "SyncMesh", { [1] = { ["Part"] = part, ["MeshId"] = "rbxassetid://"..id } } })
end

local function makemesh(part)
    _({ "CreateMeshes", { [1] = { ["Part"] = part } } })
end

local function syncmeshsize(part, vectora)
    _({ "SyncMesh", { [1] = { ["Part"] = part, ["Scale"] = vectora } } })
end

local function syncmeshtexture(part, id)
    _({ "SyncMesh", { [1] = { ["Part"] = part, ["TextureId"] = "rbxassetid://"..id } } })
end

local function setvertexcolor(part, vertexcolor)
    _({ "SyncMesh", { [1] = { ["Part"] = part, ["VertexColor"] = vertexcolor } } })
end

local function name(part, stringa)
    _({ "SetName", { [1] = part }, stringa })
end

local function lock(part, boolean)
    _({ "SetLocked", { [1] = part }, boolean })
end

local function setcollision(part, booleana)
    _({ "SyncCollision", { [1] = { ["Part"] = part, ["CanCollide"] = booleana } } })
end

local function anchor(part, boolean)
    _({ "SyncAnchor", { [1] = { ["Part"] = part, ["Anchored"] = boolean } } })
end

local function createdecal(part, side)
    _({ "CreateTextures", { [1] = { ["Part"] = part, ["Face"] = side, ["TextureType"] = "Decal" } } })
end

local function setdecal(part, asset, side)
    _({ "SyncTexture", { [1] = { ["Part"] = part, ["Face"] = side, ["TextureType"] = "Decal", ["Texture"] = "rbxassetid://"..asset } } })
end

local function AddFire(part)
    _({ "CreateDecorations", { [1] = { ["Part"] = part, ["DecorationType"] = "Fire" } } })
end

local function SyncFire(part)
    _({ "SyncDecorate", { [1] = {
        ["Part"] = part,
        ["DecorationType"] = "Fire",
        ["Color"] = Color3.fromRGB(255, 0, 0),
        ["SecondaryColor"] = Color3.fromRGB(255, 0, 0),
        ["Size"] = 30,
        ["Heat"] = 30
    } } })
end

local function makerealmbase()
    local position = CFrame.new(0, 5, 0)
    local base = serverendpoint:InvokeServer("CreatePart", "Normal", position, workspace)
    if not base then return end
    resize(base, Vector3.new(500, 16, 500), position)
    syncmaterial(base, Enum.Material.Concrete)
    color(base, Color3.new(0.513725, 0.513725, 0.513725))
    name(base, "loltroll")
    lock(base, true)
    anchor(base, true)

    local spawnpos = CFrame.new(34.5, 8.1, -60)
    local spawna = serverendpoint:InvokeServer("CreatePart", "Spawn", spawnpos, workspace)
    if spawna then
        resize(spawna, Vector3.new(40, 10, 40), spawnpos)
        name(spawna, "SpawnLocation")
        lock(spawna, true)
        anchor(spawna, true)
        createdecal(spawna, Enum.NormalId.Top)
        setdecal(spawna, "89691580348045", Enum.NormalId.Top)
        transparency(spawna, 1)
    end

    local posRules = CFrame.new(74.143, 24, -25.232)
    local rules = serverendpoint:InvokeServer("CreatePart", "Normal", posRules, workspace)
    if rules then
        transparency(rules, 0)
        setcollision(rules, false)
        color(rules, Color3.fromRGB(90, 50, 20))
        resize(rules, Vector3.new(3, 35, 3), posRules)
        syncmaterial(rules, Enum.Material.Wood)
        name(rules, "rules block")
        anchor(rules, true)
        AddFire(rules)
        task.wait(0.05)
        SyncFire(rules)
        lock(rules, true)
    end

    local posBad = CFrame.new(1.143, 24, -25.232)
    local bad = serverendpoint:InvokeServer("CreatePart", "Normal", posBad, workspace)
    if bad then
        transparency(bad, 0)
        setcollision(bad, false)
        color(bad, Color3.fromRGB(90, 50, 20))
        resize(bad, Vector3.new(3, 35, 3), posBad)
        syncmaterial(bad, Enum.Material.Wood)
        name(bad, "l")
        anchor(bad, true)
        AddFire(bad)
        task.wait(0.05)
        SyncFire(bad)
        lock(bad, true)
    end
end

local function sky(id)
    local root = char:WaitForChild("HumanoidRootPart")
    local spawnPos = CFrame.new(
        math.floor(root.Position.X),
        math.floor(root.Position.Y),
        math.floor(root.Position.Z)
    ) + Vector3.new(0, 6, 0)

    serverendpoint:InvokeServer("CreatePart", "Normal", spawnPos, workspace)
    task.wait(0.2)

    local skyPart
    for _, v in ipairs(workspace:GetDescendants()) do
        if v:IsA("BasePart") and (v.Position - spawnPos.Position).Magnitude < 1 then
            skyPart = v
            name(v, "HdSkyboxTrippy")
            makemesh(v)
            syncmeshid(v, "111891702759441")
            syncmeshtexture(v, id)
            setvertexcolor(v, Vector3.new(4,4,4))
            syncmeshsize(v, Vector3.new(2100,2100,2100))
            lock(v, true)
            anchor(v, true)
            setcollision(v, false)
            break
        end
    end

    if skyPart then
        local t = 0
        local baseSpeed = 0
        local randomness = 0

        RunService.Heartbeat:Connect(function(dt)
            t = t + dt
            local rotX = math.sin(t * 1.5) * randomness
            local rotY = t * baseSpeed
            local rotZ = math.cos(t * 2.1) * randomness
            local newCf = spawnPos * CFrame.Angles(
                math.rad(rotX),
                math.rad(rotY),
                math.rad(rotZ)
            )
            _({ "SyncMove", { [1] = { ["Part"] = skyPart, ["CFrame"] = newCf } } })
        end)
    end
end

sky("94669991514377")
makerealmbase()

local spawnPosPart = CFrame.new(37.6, 34, -91)
local floatingPart = serverendpoint:InvokeServer("CreatePart", "Normal", spawnPosPart, workspace)

if floatingPart then
    _({ "SyncResize", {{ Part = floatingPart, CFrame = floatingPart.CFrame, Size = Vector3.new(8,8,8) }} })
    _({ "SyncAnchor", {{ Part = floatingPart, Anchored = true }} })
    _({ "SyncCollision", {{ Part = floatingPart, CanCollide = false }} })
    _({ "SyncColor", {{ Part = floatingPart, Color = Color3.new(1,1,1), UnionColoring = false }} })
    _({ "SyncMaterial", {{ Part = floatingPart, Material = Enum.Material.SmoothPlastic, Transparency = 0 }} })

    makemesh(floatingPart)
    syncmeshid(floatingPart, "1347582902")
    syncmeshsize(floatingPart, Vector3.new(0.2,0.2,0.2))

    createdecal(floatingPart, Enum.NormalId.Top)
    setdecal(floatingPart, "134175460123817", Enum.NormalId.Top)

    RunService.RenderStepped:Connect(function()
        if floatingPart and floatingPart.Parent then
            _({ "SyncMove", {{ Part = floatingPart, CFrame = floatingPart.CFrame }}})
        end
    end)
end

-- 
local customPartPos1 = CFrame.new(37.6, 57, -91)
local customPart1 = serverendpoint:InvokeServer("CreatePart", "Normal", customPartPos1, workspace)
if customPart1 then
    resize(customPart1, Vector3.new(8.55, 9.12, 8.55), customPartPos1)
    anchor(customPart1, true)
    transparency(customPart1, 0)
    setcollision(customPart1, true)
    syncmaterial(customPart1, Enum.Material.SmoothPlastic)
    name(customPart1, "CustomMeshPart1")
    lock(customPart1, true)

    makemesh(customPart1)
    task.wait(0.1)
    syncmeshid(customPart1, "11369038")
    task.wait(0.1)
    syncmeshtexture(customPart1, "11369036")
    syncmeshsize(customPart1, Vector3.new(8.55, 8.55, 9.12))
end

-- 
local glassesPos = CFrame.new(37.6, 51.4, -91.2) * CFrame.Angles(0, math.rad(-177), 0)
local customPart2 = serverendpoint:InvokeServer("CreatePart", "Normal", glassesPos, workspace)
if customPart2 then
    resize(customPart2, Vector3.new(8.55, 9.12, 8.55), glassesPos)
    anchor(customPart2, true)
    transparency(customPart2, 0)
    setcollision(customPart2, true)
    syncmaterial(customPart2, Enum.Material.SmoothPlastic)
    name(customPart2, "CustomMeshPart2")
    lock(customPart2, true)

    makemesh(customPart2)
    task.wait(0.1)
    syncmeshid(customPart2, "26340426")
    task.wait(0.1)
    syncmeshtexture(customPart2, "26340417")
    syncmeshsize(customPart2, Vector3.new(9, 9, 9))
end

-- 
local blockPos = CFrame.new(10,10,10)
local imageBlock = serverendpoint:InvokeServer("CreatePart", "Normal", blockPos, workspace)
if imageBlock then
    resize(imageBlock, Vector3.new(9,9,9), blockPos)
    anchor(imageBlock, true)
    transparency(imageBlock, 1)
    setcollision(imageBlock, false)
    syncmaterial(imageBlock, Enum.Material.SmoothPlastic)
    color(imageBlock, Color3.new(1, 1, 1))
    name(imageBlock, "CustomImageBlockBack")
    lock(imageBlock, true)
    
    createdecal(imageBlock, Enum.NormalId.Back)
    setdecal(imageBlock, "", Enum.NormalId.Back)
end

RequestCommand:InvokeServer(";res all")
task.wait(0.7)
RequestCommand:InvokeServer(";music 1839246711 ;volume inf ;pitch 1.0")