Simple Camlock Script

().NemesisPreBeta = {
    [] = {
        Disabling = {Toggle = , Keybind = },
        UpdateTickDelay = 
    },
    [] = {
        Toggling = {
            Enable = , 
            Keybind = 
        },
        Settings = {
            Prediction = { 
                , 
                , 
                , 
                
            },
            Smoothing = {
                smoothness = , 
                x = , 
                y = 
            },
            OffSets = {
                Jump = {
                    Enable = , 
                    [] = .(, , )
                }
            }
        },
        Conditions = {
            Player = {
                WallCheck = , 
                Grabbed = , 
                Knocked = , 
                CrewID = 
            },
            BodyParts = {, }
        }
    },
    [] = {
        Toggling = { Enable =  },
        Settings = {
            Prediction = {  ,  , ,  },
            HitChance = ,
            Resolver = ,
            OffSets = {
                Jump = {
                    Enable = , 
                    [] = .(, , )
                }
            }
        },
        Conditions = {
            Player = { WallCheck = , Grabbed = , Knocked = , CrewID =  },
            BodyParts = {, , }
        }
    },
    [] = {
        Enable = , 
        Size = , 
        Color = .(, , ), 
    },
    [] = {
        [] = {
            Toggled = ,
            Key = ,
            alphabetically = ,
            Ammo = ,
            Custom = {
                Enable = ,
                List = {[] = , [] = } 
            }
        },
        [] = {
            Enable = ,
            Animations = {[] = {[] = , [] = }}
        }
    }
}





 DUpvalue, Round, V3, V2, CF, Rservice, UserInput, Ping, Mouse, backpack  = debug.getupvalue, .round, .new, .new, .new, :(), :(), :().PerformanceStats.Ping, :().LocalPlayer:(), :().LocalPlayer.Backpack
 Players, Self, Character, Camera = :(), :().LocalPlayer, :().LocalPlayer.Character   :().LocalPlayer.CharacterAdded:(), :().CurrentCamera
 idx, endp


 Storage = {
    Drawings = {},
    Connections = {},
    targets = {
        [] = ,
        [] = 
    },
    ValuePosition = ,
    bodyparts = {
        [] = ,
        [] = 
    },
    update_tick = (),
    etc = {
        Ctoggled = ,
        Mtoggled = 
    },
    items = {}
}



 (, callback)
     connection = :(callback)
    Storage.Connections[#Storage.Connections+] = connection
     connection


 (chance, maxchance)
     .(maxchance) <= chance



 (Function, ...)
     co
     success, result

     Function ~=  
        co = .(Function)
        success, result = .(co, ...)
    
     success ~=   co ~=   Function ~=  
         result
    



 (origin)
     parts = Camera:({origin.Position,  Character.HumanoidRootPart.Position}, {Camera, Character, origin.Parent})
     #parts ==  
         
    
     


 (player)
     player.Character ~=   
          player.Character:()
    


 (player)
     player.Character ~=   
         player.Character.BodyEffects[].Value ~= 
    



 pingHistory = {}
 lastPingUpdateTime = ()



 ()
     currentPing = Ping:() * 
     ().NemesisPreBeta.Camlock.Settings.Prediction[]  ().NemesisPreBeta.Silent.Settings.Prediction[] 
         currentPing
    
         ().NemesisPreBeta.Camlock.Settings.Prediction[]  ().NemesisPreBeta.Silent.Settings.Prediction[]
    


 (player)
     .Players.LocalPlayer:():():() 
         SelfCrewValue =  .Players.LocalPlayer:():():()
         SelfCrewValue.Value ~=  
             player:():():()  
                 Enimy = player:():():()
                 Enimy.Value == SelfCrewValue.Value 
                     
                
            
        
    
     




 (player, hitboxes)
     closestPart
     closestDistanc = .huge
     _, hitbox  (hitboxes) 
         part = player.Character:(hitbox)
         part 
             pos = Camera:(part.Position)
             distance = (UserInput:() - (pos.X, pos.Y)).Magnitude
             distance < closestDistanc 
                closestPart = part
                closestDistanc = distance
            
        
    
     closestPart




 (toolName)
     _, customName  (().NemesisPreBeta.Miscs.Sorting.Custom.List) 
         toolName == customName 
             
        
    
     



 ()
     MaxDistance = ().NemesisPreBeta[].Enable  ().NemesisPreBeta[].Size  .huge
     Target

     i,v  (Players:()) 
         v ~= Self  v.Character ~=   v.Character:()  v.Character:() 
             ViewPort, Visible = Camera:(v.Character.HumanoidRootPart.Position)
             Mag = (UserInput:() - .(ViewPort.X, ViewPort.Y)).Magnitude
             MaxDistance > Mag  Visible  (
                (.WallCheck  (v.Character.HumanoidRootPart))   
                (.Grabbed  (v))   
                (.Knocked  (v))   
                (.CrewID  (v))   
            ) 
                MaxDistance = Mag
                Target = v
            
        
    
     Target


 (Target, method)
     method ==  
         pos = Target.Character.HumanoidRootPart.Position
         lastTime = ()
         currentPos, currentTime
         connection
        connection =
            :().Heartbeat:(
            ()
                currentPos = Target.Character.HumanoidRootPart.Position
                currentTime = ()
                connection:()
            
        )
        ()
         velocity = (currentPos - pos) / (currentTime - lastTime)
         .(.(velocity.X), .(velocity.Y), .(velocity.Z))
    
         Target.character:().AssemblyLinearVelocity
    


 (animationName)
     args = {
        [] = ,
        [] = animationName,
    }
    :().MainEvent:((args))





 ()
     SilentTable = ().NemesisPreBeta.Silent
     SilentTable.Toggling.Enable 
        Storage.targets[] = (SilentTable.Conditions.Player)
         Storage.targets[] ~=   Storage.targets[].Character ~=   Storage.targets[].Character:() 
            Storage.bodyparts[] =  ((Storage.targets[], SilentTable.Conditions.BodyParts))
             position = Storage.targets[].Character[Storage.bodyparts[]].Position
             SilentTable.Settings.OffSets.Jump.Enable  Storage.targets[].Character:():() == .HumanoidStateType.Freefall 
                position = position + SilentTable.Settings.OffSets.Jump[]
            
            Storage.CFposition = position + (SilentTable.Settings.Prediction  (Storage.targets[], SilentTable.Settings.Resolver) * ()  )
        
    



 ()
     CamLockTable = ().NemesisPreBeta.Camlock
     Storage.etc.Ctoggled  CamLockTable.Toggling.Enable  Storage.targets[] ~=   Storage.targets[].Character ~=  
         position = Storage.targets[].Character[Storage.bodyparts[]].Position

         CamLockTable.Settings.OffSets.Jump.Enable  Storage.targets[].Character:():() == .HumanoidStateType.Freefall 
            position = position + CamLockTable.Settings.OffSets.Jump[]
        

         CamLockTable.Settings.Smoothing.enable 
             goal = .(Camera.CFrame.Position, position + (CamLockTable.Settings.Prediction[] * ()  .()))
            Camera.CFrame = Camera.CFrame:(goal, CamLockTable.Settings.Smoothing.x, CamLockTable.Settings.Smoothing.y)
        
             prediction = CamLockTable.Settings.Prediction[]  Storage.targets[].Character.HumanoidRootPart.AssemblyLinearVelocity * ()  .()
            Camera.CFrame = .(Camera.CFrame.Position, position + prediction)
        
    


 

    (UserInput.InputBegan, (key, wtv)
         key.KeyCode == .KeyCode[().NemesisPreBeta.Camlock.Toggling.Keybind:()]   wtv 
             ().NemesisPreBeta.Camlock.Toggling.Enable 
                Storage.etc.Ctoggled =  Storage.etc.Ctoggled
                Storage.targets[] = (().NemesisPreBeta.Camlock.Conditions.Player)

                  Storage.targets[]   Storage.targets[].Character 
                    Storage.bodyparts[] = ((Storage.targets[], ().NemesisPreBeta.Camlock.Conditions.BodyParts))

                
            
                  Storage.targets[] ~=  
                    Storage.targets[] = 
                
            
        
    )

    (UserInput.InputBegan, (key, wtv)
         ().NemesisPreBeta.Settings.Disabling.Toggle  key.KeyCode == .KeyCode[().NemesisPreBeta.Settings.Disabling.Keybind:()]    wtv 
             i,v  (Storage.Connections) 
                 v 
                    v:()
                
            
             i,v  (Storage.Drawings) 
                 v  v.__OBJECT_EXISTS 
                    ()
                
            
        
    )

    (UserInput.InputBegan, (key, wtv)
         ().NemesisPreBeta.Miscs.Sorting.Toggled  key.KeyCode == .KeyCode[().NemesisPreBeta.Miscs.Sorting.Key:()]   wtv 
             items = {}

             ().NemesisPreBeta.Miscs.Sorting.Custom.Enable 
                 _, customName  (().NemesisPreBeta.Miscs.Sorting.Custom.List) 
                     _, item  (backpack:()) 
                         item:()  item.Name == customName 
                            .(items, , item)
                            
                        
                    
                
            
            
             _, item  (backpack:()) 
                 item:()  ( ().NemesisPreBeta.Miscs.Sorting.Custom.Enable   (item.Name)) 
                    .(items, item)
                
            
            
             ().NemesisPreBeta.Miscs.Sorting.alphabetically   ().NemesisPreBeta.Miscs.Sorting.Custom.Enable 
                .(items, (a, b)
                     a.Name < b.Name
                )
            
            
             ().NemesisPreBeta.Miscs.Sorting.Ammo   ().NemesisPreBeta.Miscs.Sorting.Custom.Enable 
                .(items, (a, b)
                     a.Value > b.Value
                )
            

             _, item  (items) 
                item.Parent = 
                ()
                item.Parent = backpack
            

        
    )

    (UserInput.InputBegan, (key, wtv)
         ().NemesisPreBeta.Miscs.Animation.Enable   wtv 
             animationName, animationData  (().NemesisPreBeta.Miscs.Animation.Animations) 
                 animationData[]  key.KeyCode == .KeyCode[animationData[]] 
                    (animationName)
                    
                
            
        
    )




    (Rservice.Heartbeat, ()

            
            (())

            
            (())

    )



     connection, index  , (.CurrentCamera.Changed) 
        index:()
    
     connection, index  , (.CurrentCamera:()) 
        index:()
    


 oldIndex
oldIndex = (, , (t, k)
	 t:()  k ==   k ==  
		  ().NemesisPreBeta.Silent.Toggling.Enable  (().NemesisPreBeta.Silent.Settings.HitChance, )  Storage.targets[] ~=  
			 Hit = .(Storage.CFposition)
			 (k ==   Hit)
		
	
	 (t, k)
)