F3X Van Kidnap script

 Players = :()
 TeleportService = :()
 TweenService = :()
 RunService = :()
 CoreGui = :()
 LocalPlayer = Players.LocalPlayer

 DEFAULT_MODEL_ID = 




  ()
     char = LocalPlayer.Character
     backpack = LocalPlayer:()
     tool = (char  (char:()  char:())) 
         (backpack  (backpack:()  backpack:()))
    
     tool 
         syncAPI = tool:()  tool:()
         syncAPI 
             endpoint = syncAPI:()  syncAPI:()
             endpoint   endpoint 
        
         _, desc  (tool:()) 
             desc:()  desc:() 
                 desc
            
        
    
     


  (part)
     part:()    
     part:()    
     part:()    
     part:() 
         part.Shape == .PartType.Ball    
         part.Shape == .PartType.Cylinder    
    
     


  (id)
     loaded = 
     result = 
    
    .(()
         success, raw = (()  :( .. (id)) )
         success  raw  #raw >  
            result = raw[]
        
        loaded = 
    )
    
     timeWaited = 
      loaded  timeWaited <  
        .()
        timeWaited += 
    
    
     result


  (object)
     object:() 
         success, cf, size = (()  object:() )
         success  cf  size 
             cf, size
        
     object:() 
         object.CFrame, object.Size
    
    
     parts = {}
     _, desc  (object:()) 
         desc:() 
            .(parts, desc)
        
    
    
     #parts ==  
         .(), .(, , )
    
    
     minX, minY, minZ = .huge, .huge, .huge
     maxX, maxY, maxZ = -.huge, -.huge, -.huge
    
     _, part  (parts) 
         cf = part.CFrame
         size = part.Size
         pmin = cf.Position - size/
         pmax = cf.Position + size/
        minX = .(minX, pmin.X); minY = .(minY, pmin.Y); minZ = .(minZ, pmin.Z)
        maxX = .(maxX, pmax.X); maxY = .(maxY, pmax.Y); maxZ = .(maxZ, pmax.Z)
    
    
     center = .((minX + maxX)/, (minY + maxY)/, (minZ + maxZ)/)
     size = .(maxX - minX, maxY - minY, maxZ - minZ)
     .(center), size





  (endpoint, modelId, spawnCFrame)
     rootObject = (modelId)
      rootObject   , {}, {}, {} 

     boundingCFrame = (rootObject)
     partsToImport = {}

     rootObject:()  .(partsToImport, rootObject) 
     _, child  (rootObject:()) 
         child:()  .(partsToImport, child) 
    

     #partsToImport ==  
        rootObject:()
         , {}, {}, {}
    

     createdF3XParts = {}
     primaryPart = 
     doorParts = {}
     createdMap = {}

     pending = #partsToImport
     bindable = .()

     idx, part  (partsToImport) 
        .(()
             targetCFrame = spawnCFrame * boundingCFrame:(part.CFrame)
             partType = (part)
            
             ok, createdPart = (()
                 endpoint:() 
                     endpoint:(, partType, targetCFrame, )
                
                    endpoint:(, partType, targetCFrame, )
                
            )
            
             ok  createdPart 
                createdMap[idx] = {  = createdPart, Original = part, TargetCFrame = targetCFrame }
            

            pending -= 
             pending <=  
                bindable:()
            
        )
    

     pending >  
        bindable.Event:()
    
    bindable:()

     resizeBatch, colorBatch, matBatch, anchorBatch, collisionBatch = {}, {}, {}, {}, {}
     createMeshesBatch, syncMeshBatch = {}, {}

     idx = , #partsToImport 
         createdMap[idx] 
             c = createdMap[idx].Instance
             p = createdMap[idx].Original
             t = createdMap[idx].TargetCFrame

            .(createdF3XParts, c)
              primaryPart  p.Name ==   p.Name ==   p.Name ==  
                primaryPart = c
            

             .(.(p.Name), ) 
                .(doorParts, c)
            

            .(resizeBatch, { Part = c,  = t, Size = p.Size })
            .(colorBatch, { Part = c, Color = p.Color })
            .(matBatch, { Part = c, Material = p.Material, Transparency = p.Transparency })
            .(anchorBatch, { Part = c, Anchored =  })
            .(collisionBatch, { Part = c, CanCollide =  })

             p:() 
                .(createMeshesBatch, { Part = c })
                .(syncMeshBatch, {
                    Part = c,
                    MeshType = .MeshType.FileMesh,
                    MeshId = p.MeshId,
                    TextureId = p.TextureID  ,
                    Scale = .(, , )
                })
            

             _, descendant  (p:()) 
                 descendant:() 
                    .(createMeshesBatch, { Part = c })
                    .(syncMeshBatch, {
                        Part = c,
                        MeshType = descendant.MeshType,
                        MeshId = descendant.MeshId,
                        TextureId = descendant.TextureId,
                        Scale = descendant.Scale,
                        Offset = descendant.Offset,
                        VertexColor = descendant.VertexColor
                    })
                 descendant:()  descendant:()  descendant:() 
                    (()
                         clone = descendant:()
                        clone.Parent = c
                    )
                
            
        
    

      (method, batch)
         #batch ==    
         chunkSize = 
         i = , #batch, chunkSize 
             chunk = {}
             j = i, .(i + chunkSize - , #batch) 
                .(chunk, batch[j])
            
            (()
                 endpoint:() 
                    endpoint:(method, chunk)
                
                    endpoint:(method, chunk)
                
            )
        
    

    (, resizeBatch)
    (, colorBatch)
    (, matBatch)
    (, anchorBatch)
    (, collisionBatch)
     #createMeshesBatch >   (, createMeshesBatch) 
     #syncMeshBatch >   (, syncMeshBatch) 

    primaryPart = primaryPart  createdF3XParts[]

     partOffsets = {}
     primaryPart 
         primaryStartCF = primaryPart.CFrame
         _, part  (createdF3XParts) 
            partOffsets[part] = primaryStartCF:(part.CFrame)
        
    

    rootObject:()
     primaryPart, createdF3XParts, partOffsets, doorParts





  (arg)
      arg  arg ==    {LocalPlayer} 
    arg = .(arg)

     arg ==  
         {LocalPlayer}
     arg ==  
         Players:()
     arg ==  
         matched = {}
         _, p  (Players:()) 
             p ~= LocalPlayer  .(matched, p) 
        
         matched
    

     matched = {}
     _, p  (Players:()) 
         name = .(p.Name)
         disp = .(p.DisplayName)
        
         .(name, , #arg) == arg  .(disp, , #arg) == arg  .(name, arg, , )  .(disp, arg, , ) 
            .(matched, p)
        
    
     matched





  (targetPlayer, modelId, driveDistance, moveSpeed)
    .(()
         endpoint = ()
          endpoint 
            ()
            
        

         char = targetPlayer.Character
          char   

         torso = char:()  char:()
         humanoid = char:()
         isLocal = (targetPlayer == LocalPlayer)

         torso  humanoid 
            humanoid.WalkSpeed = 
            humanoid.JumpPower = 
            humanoid.AutoRotate = 

             tPos = torso.CFrame
             approachDist = .(driveDistance * , , )
             spawnPos = tPos * (.(-approachDist, , -) * .(, .(), ))

             primary, allParts, offsets, doorParts = (endpoint, modelId, spawnPos)
              primary  #allParts ==  
                humanoid.WalkSpeed = 
                humanoid.JumpPower = 
                humanoid.AutoRotate = 
                
            

              ()
                 targetPlayer  targetPlayer.Parent == Players  torso  humanoid  torso.Parent  humanoid.Parent  char  char.Parent
            

             sound, chuckle
             isLocal 
                sound = .(, primary)
                sound.SoundId = 
                sound.Looped = 
                sound:()

                chuckle = .(, primary)
                chuckle.SoundId = 
                chuckle.Looped = 
                chuckle.Volume = 
                chuckle:()
            

              (transparencyValue)
                 #doorParts >  
                     matBatch = {}
                     _, dPart  (doorParts) 
                        .(matBatch, { Part = dPart, Material = dPart.Material, Transparency = transparencyValue })
                    
                    (()
                         endpoint:() 
                            endpoint:(, matBatch)
                        
                            endpoint:(, matBatch)
                        
                    )
                
            

            
              (startCF, targetCF, speed)
                 dist = (targetCF.Position - startCF.Position).Magnitude
                 duration = .(, dist / speed)
                 startTime = .()
                 lastNetworkSend = 
                 sendInterval =  
                 thread = .()
                 conn

                conn = RunService.PreRender:(()
                      () 
                        conn:()
                        .(thread)
                        
                    

                     now = .()
                     elapsed = now - startTime
                     alpha = .(elapsed / duration, , )
                     currentCF = startCF:(targetCF, alpha)

                    
                     (now - lastNetworkSend) >= sendInterval  alpha >=  
                        lastNetworkSend = now
                         batchMove = {}
                         part, offsetCF  (offsets) 
                            .(batchMove, { Part = part,  = currentCF * offsetCF })
                        

                        .(()
                            (()
                                 endpoint:() 
                                    endpoint:(, batchMove)
                                
                                    endpoint:(, batchMove)
                                
                            )
                        )
                    

                     alpha >=  
                        conn:()
                        .(thread)
                    
                )

                .()
            

            
             approachStartCF = spawnPos
             approachTargetCF = tPos * (.(, , -) * .(, .(), ))

            (approachStartCF, approachTargetCF, moveSpeed)

             sound  sound.PlaybackSpeed =  
            .()
             ()  () 
            .()

            
             activeWeld = 
             lockConnection = 

             () 
                 vehicleInsideCF = primary.CFrame * (.(, , ) * .(, .(), ))
                
                 isLocal 
                    torso.Anchored = 
                    torso.CFrame = vehicleInsideCF

                    lockConnection = RunService.PreRender:(()
                         ()  primary  primary.Parent 
                            torso.CFrame = primary.CFrame * (.(, , ) * .(, .(), ))
                        
                    )
                
                    .(()
                        (()
                             endpoint:() 
                                endpoint:(, {{ Part = torso, Anchored =  }})
                                endpoint:(, { primary }, torso)
                            
                                endpoint:(, {{ Part = torso, Anchored =  }})
                                endpoint:(, { primary }, torso)
                            
                        )
                    )
                    torso.CFrame = vehicleInsideCF
                    activeWeld = .()
                    activeWeld.Part0 = primary
                    activeWeld.Part1 = torso
                    activeWeld.Parent = primary
                
            

            .()
             ()  () 
            .()

             sound  sound.PlaybackSpeed =  

            
             driveAwayStartCF = approachTargetCF
             driveAwayTargetCF = tPos * (.(driveDistance, , -) * .(, .(), ))

            (driveAwayStartCF, driveAwayTargetCF, moveSpeed)

             isLocal  targetPlayer  targetPlayer.Parent == Players 
                (()
                    TeleportService:(, targetPlayer)
                )
            

            .()

             lockConnection  lockConnection:() 
             isLocal  torso  torso.Anchored =  
             activeWeld  (() activeWeld:() ) 

            .(()
                (()
                     endpoint:() 
                        endpoint:(, allParts)
                    
                        endpoint:(, allParts)
                    
                )
            )

            (()
                 targetPlayer  targetPlayer.Parent == Players 
                     humanoid 
                        humanoid.WalkSpeed = 
                        humanoid.JumpPower = 
                        humanoid.AutoRotate = 
                    
                
            )
        
    )





 existingGui = CoreGui:()  LocalPlayer:():()
 existingGui  existingGui:() 

 KidnapGui = .()
KidnapGui.Name = 
KidnapGui.ResetOnSpawn = 
KidnapGui.Parent = CoreGui:()  LocalPlayer:()

 MainFrame = .()
MainFrame.Name = 
MainFrame.Size = .(, , , )
MainFrame.Position = .(, -, , -)
MainFrame.BackgroundColor3 = .(, , )
MainFrame.BorderSizePixel = 
MainFrame.Active = 
MainFrame.Draggable = 
MainFrame.Parent = KidnapGui

 UICorner = .()
UICorner.CornerRadius = .(, )
UICorner.Parent = MainFrame

 Title = .()
Title.Size = .(, , , )
Title.BackgroundColor3 = .(, , )
Title.Text = 
Title.TextColor3 = .(, , )
Title.Font = .Font.SourceSansBold
Title.TextSize = 
Title.Parent = MainFrame

 TitleCorner = .()
TitleCorner.CornerRadius = .(, )
TitleCorner.Parent = Title


 TargetBox = .()
TargetBox.Size = .(, , , )
TargetBox.Position = .(, , , )
TargetBox.BackgroundColor3 = .(, , )
TargetBox.PlaceholderText = 
TargetBox.Text = 
TargetBox.TextColor3 = .(, , )
TargetBox.Font = .Font.SourceSans
TargetBox.TextSize = 
TargetBox.Parent = MainFrame


 ModelBox = .()
ModelBox.Size = .(, , , )
ModelBox.Position = .(, , , )
ModelBox.BackgroundColor3 = .(, , )
ModelBox.PlaceholderText = 
ModelBox.Text = 
ModelBox.TextColor3 = .(, , )
ModelBox.Font = .Font.SourceSans
ModelBox.TextSize = 
ModelBox.Parent = MainFrame


 SpeedBox = .()
SpeedBox.Size = .(, , , )
SpeedBox.Position = .(, , , )
SpeedBox.BackgroundColor3 = .(, , )
SpeedBox.PlaceholderText = 
SpeedBox.Text = 
SpeedBox.TextColor3 = .(, , )
SpeedBox.Font = .Font.SourceSans
SpeedBox.TextSize = 
SpeedBox.Parent = MainFrame


 DistLabel = .()
DistLabel.Size = .(, , , )
DistLabel.Position = .(, , , )
DistLabel.BackgroundTransparency = 
DistLabel.Text = 
DistLabel.TextColor3 = .(, , )
DistLabel.Font = .Font.SourceSans
DistLabel.TextSize = 
DistLabel.TextXAlignment = .TextXAlignment.Left
DistLabel.Parent = MainFrame

 DistBtn = .()
DistBtn.Size = .(, , , )
DistBtn.Position = .(, , , )
DistBtn.BackgroundColor3 = .(, , )
DistBtn.Text = 
DistBtn.TextColor3 = .(, , )
DistBtn.Font = .Font.SourceSansBold
DistBtn.TextSize = 
DistBtn.Parent = MainFrame


 ExecuteBtn = .()
ExecuteBtn.Size = .(, , , )
ExecuteBtn.Position = .(, , , )
ExecuteBtn.BackgroundColor3 = .(, , )
ExecuteBtn.Text = 
ExecuteBtn.TextColor3 = .(, , )
ExecuteBtn.Font = .Font.SourceSansBold
ExecuteBtn.TextSize = 
ExecuteBtn.Parent = MainFrame

 ExecCorner = .()
ExecCorner.CornerRadius = .(, )
ExecCorner.Parent = ExecuteBtn




 currentDistance = 

 distanceModes = {
    { Label = , Dist =  },
    { Label = , Dist =  },
    { Label = , Dist =  },
    { Label = , Dist =  },
    { Label = , Dist =  },
}
 currentDistIdx = 

DistBtn.MouseButton1Click:(()
    currentDistIdx = (currentDistIdx % #distanceModes) + 
     mode = distanceModes[currentDistIdx]
    currentDistance = mode.Dist
    DistBtn.Text = mode.Label
    DistLabel.Text =  .. (mode.Dist) .. 
)

ExecuteBtn.MouseButton1Click:(()
     targetInput = TargetBox.Text
     targetInput ==   targetInput =  

     modelId = (ModelBox.Text)  DEFAULT_MODEL_ID
     speedInput = (SpeedBox.Text)  
    
     targets = (targetInput)
     _, target  (targets) 
        (target, modelId, currentDistance, speedInput)
    
)