best ecco remake for hood game

.Accuracy = {
    [] = {
        [] = ,
        [] = ,
        [] = ,
    },
    [] = {
        [] = {
            [] = ,
            [] = ,
        },
        [] = {
            [] = ,
            [] = ,
        },
        [] = ,
        [] = ,
        [] = ,  
    },
    [] = {
        [] = ,
        [] = ,
        [] = .(, ),
        [] = ,
        [] = .(, , ),
    },
    [] = {
        [] = ,
        [] = ,
        [] = ,
        [] = {
            [] = ,
            [] = ,
            [] = ,
        },
    },
    [] = {
        [] = ,
        [] = ,
        [] = ,
        [] = ,
        [] = ,
    },
    [] = {
        [] = ,
        [] = ,
        [] = {
            [] = ,
            [] = {
                ,
                ,
                ,
            },
        },
    },
    [] = {
        [] = ,
        [] = ,
        [] = {
            [] = ,
            [] = {
                ,
                ,
            },
        },
    },
    [] = {
        [] = ,
        [] = ,
        [] = ,
    },
    [] = {
        [] = ,
        [] = ,
    },
    [] = {
        [] = ,
    },
    [] = {
        [] = ,
        [] = .(, , ),
        [] = .(, , ),
    },
    [] = {
        [] = ,
        [] = ,   
        [] = ,
    },
	    [] = {
        [] = ,
        [] = ,          
        [] = ,   
    },
	    [] = {
        [] = ,
        [] = ,  
        [] = {
            [] = ,
            [] = {
                ,
                ,
            },
        },
    },
}

 Config = .Accuracy
 Players = :()
 UserInputService = :()
 RunService = :()
 Workspace = :()
 Camera = Workspace.CurrentCamera
 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

 currentTarget = 
 isLocking = 
 triggerEnabled = 
 fovBox = 
 espLabels = {}
 SpeedEnabled = 
 BaseSpeed = 
 lastVisibleTarget = 
 lastTriggerClick = 
 superJumpActive = 


  (t)
     p = 
     .(, - * t) * .((t - p / ) * ( * .pi) / p) + 


  (t)
     -(.(.pi * t) - ) / 



  (player)
      Config[][]    
    
     player.Character 
         bodyEffects = player.Character:()
         bodyEffects 
             ko = bodyEffects:()
             ko  ko.Value ==     
            
             knocked = bodyEffects:()
             knocked  knocked.Value ==     
        
    
    
     


  ()
     LocalPlayer.Character 
         bodyEffects = LocalPlayer.Character:()
         bodyEffects 
             ko = bodyEffects:()
             ko  ko.Value ==     
            
             knocked = bodyEffects:()
             knocked  knocked.Value ==     
        
    
     






  (part)
      Config[][]    
    
      part   part.Parent    
    
     character = part.Parent
     humanoid = character:()
      humanoid    
    
    
     state = humanoid:()
     isAirborne = (state == .HumanoidStateType.Jumping  
                        state == .HumanoidStateType.Freefall  
                        state == .HumanoidStateType.FallingDown)
    
     root = character:()
     velY = root  .((root.AssemblyLinearVelocity  root.Velocity  .()).Y)  
    
     (isAirborne  velY > )  isLocking   
         
    
    
    
     origin = Camera.CFrame.Position
     direction = (part.Position - origin).Unit * (part.Position - origin).Magnitude
    
     raycastParams = RaycastParams.()
    raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, character}
    raycastParams.FilterType = .RaycastFilterType.Exclude
    raycastParams.IgnoreWater = 
    
     rayResult = Workspace:(origin, direction, raycastParams)
     rayResult ==   rayResult.Instance:(character)



  (character)
     closestPart = 
     shortestDist = .huge
    
     bodyParts = {
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
        character:(),
    }
    
     _, part  (bodyParts) 
         part 
             pos, onScreen = Camera:(part.Position)
            
             screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
             dist = (.(pos.X, pos.Y) - screenCenter).Magnitude
            
             dist < shortestDist 
                shortestDist = dist
                closestPart = part
            
        
    
    
     closestPart



  (character)
      Config[][]    
      character    
    
     rootPart = character:()
     head = character:()
      rootPart   head    
    
     headPos, headOnScreen = Camera:(head.Position + .(, , ))
     legPos, legOnScreen = Camera:(rootPart.Position - .(, , ))
    
      headOnScreen   legOnScreen    
    
     height = .(headPos.Y - legPos.Y)
     width = height / 
    
     rootPos = Camera:(rootPart.Position)
    
     padding = 
     topLeftX = rootPos.X - width/ - padding
     topLeftY = headPos.Y - padding
     bottomRightX = rootPos.X + width/ + padding
     bottomRightY = legPos.Y + padding
    
     mousePos = .(Mouse.X, Mouse.Y)
    
     mousePos.X >= topLeftX  mousePos.X <= bottomRightX  mousePos.Y >= topLeftY  mousePos.Y <= bottomRightY



  ()
     closestTarget = 
     shortestDistance = .huge
    
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character  player.Character:() 
              (player) 
                 targetPart = 
                
                 Config[][] ==  
                    targetPart = (player.Character)
                
                    targetPart = player.Character:(Config[][])
                
                
                 targetPart  (targetPart) 
                     pos, onScreen = Camera:(targetPart.Position)
                    
                     (player.Character) 
                         screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
                         dist = (.(pos.X, pos.Y) - screenCenter).Magnitude
                        
                         dist < shortestDistance 
                            shortestDistance = dist
                            closestTarget = targetPart
                        
                    
                
            
        
    
    
     closestTarget



  (part, config)
      config[]   part.Position 
    
     velocity = part.AssemblyLinearVelocity  part.Velocity  .(, , )
     prediction = config[]
    
     (prediction) ==  
         predX = prediction[]  
         predY = prediction[]  
         predZ = prediction[]  
        
         part.Position + .(velocity.X * predX, velocity.Y * predY, velocity.Z * predZ)
    
         prediction ==  
            prediction = 
        
        
         part.Position + (velocity * prediction)
    



  ()
     Config[][]  currentTarget 
         player = Players:(currentTarget.Parent)
         player   (player) 
             targetPart = 
            
             Config[][] ==  
                targetPart = (currentTarget.Parent)
            
                targetPart = currentTarget.Parent:(Config[][])
            
            
             targetPart 
                 (targetPart) 
                    lastVisibleTarget = currentTarget
                     targetPart
                
                     
                
            
        
        
        currentTarget = 
        isLocking = 
        lastVisibleTarget = 
         
    
         ()
    



  ()
      isLocking   
    
     () 
        currentTarget = 
        isLocking = 
        lastVisibleTarget = 
        
    
    
     target = ()
    
     target 
         targetPos = (target, Config[])
        
         cameraCFrame = Camera.CFrame
         targetCFrame = .(cameraCFrame.Position, targetPos)
        
         smoothValue = Config[][]
         baseAlpha =  / smoothValue
        
         elasticAlpha = (.(baseAlpha, ))
         smoothCFrame = cameraCFrame:(targetCFrame, elasticAlpha * baseAlpha)
        
         sineAlpha = (.(baseAlpha, ))
        Camera.CFrame = smoothCFrame:(targetCFrame, sineAlpha * baseAlpha)
    
         lastVisibleTarget 
             player = Players:(lastVisibleTarget.Parent)
             player   (player) 
                 targetPart = lastVisibleTarget
                 targetPart  (targetPart) 
                    currentTarget = lastVisibleTarget
                
            
        
    



  fovBox 
    fovBox = .()
    fovBox.Visible = 
    fovBox.Thickness = Config[][]
    fovBox.Color = Config[][]
    fovBox.Filled = 
    fovBox.Size = .(, )


  ()
      Config[][]   Config[][] 
        fovBox.Visible = 
        
    
    
     currentTarget 
         character = currentTarget.Parent
         character 
             rootPart = character:()
             head = character:()
            
             rootPart  head 
                 headPos, headOnScreen = Camera:(head.Position + .(, , ))
                 legPos, legOnScreen = Camera:(rootPart.Position - .(, , ))
                
                 headOnScreen  legOnScreen 
                     height = .(headPos.Y - legPos.Y)
                     width = height / 
                    
                     rootPos = Camera:(rootPart.Position)
                    
                     padding = 
                     topLeft = .(rootPos.X - width/ - padding, headPos.Y - padding)
                    
                    fovBox.Size = .(width + padding * , height + padding * )
                    fovBox.Position = topLeft
                    fovBox.Visible = 
                    
                
            
        
    
    
    fovBox.Visible = 



  ()
      Config[][]   
      triggerEnabled   
    
     () - lastTriggerClick < Config[][]   
    
      currentTarget   
    
     character = currentTarget.Parent
      character   
    
     player = Players:(character)
      player   
    
     (player)   
    
      (currentTarget)   
    
     Config[][]   (character)   
    
     tool = LocalPlayer.Character  LocalPlayer.Character:()
      tool   
    
     Config[][][] 
         weaponValid = 
         _, weaponName  (Config[][][]) 
             cleanName = weaponName:(, ):(, )
             tool.Name == weaponName  tool.Name:(cleanName) 
                weaponValid = 
                
            
        
          weaponValid   
    
    
    tool:()
    lastTriggerClick = ()



 grm = ()
 oldIndex = grm.__index
(grm, )
grm.__index = (self, key)
      ()  self == Mouse  Config[][] 
         key ==  
              currentTarget   (self, key) 
            
             character = currentTarget.Parent
              character   (self, key) 
            
             player = Players:(character)
              player   (self, key) 
            
             (player)   (self, key) 
              (currentTarget)   (self, key) 
            
             Config[][]   (character) 
                 (self, key)
            
            
             targetPart = currentTarget
             targetPart 
                 predictedPos = (targetPart, Config[])
                 .(predictedPos)
            
        
    
     (self, key)



 oldRandom
oldRandom = (.random, (...)
     args = {...}
     () 
         (...)
    
    
     (#args == )  (args[] == -  args[] == )  (args[] == -)  (args[] == -) 
         Config[][] 
             Config[][][] 
                 tool = LocalPlayer.Character  LocalPlayer.Character:()
                 tool 
                     weaponName = tool.Name
                     foundWeapon = 
                    
                     _, weapon  (Config[][][]) 
                         weaponName == weapon 
                            foundWeapon = 
                            
                        
                    
                    
                     foundWeapon 
                         (...) * (Config[][] / )
                    
                
            
                 (...) * (Config[][] / )
            
        
    
    
     (...)
)


  (player)
     player == LocalPlayer   
    
     esp = {
        player = player,
        nameTag = .(),
    }
    
    esp.nameTag.Size = 
    esp.nameTag.Center = 
    esp.nameTag.Outline = 
    esp.nameTag.OutlineColor = .(, , )
    esp.nameTag.Color = Config[][]
    esp.nameTag.Visible = 
    esp.nameTag.ZIndex = 
    
    espLabels[player.UserId] = esp


  (player)
     esp = espLabels[player.UserId]
     esp 
        esp.nameTag:()
        espLabels[player.UserId] = 
    


  ()
      Config[][] 
         _, esp  (espLabels) 
            esp.nameTag.Visible = 
        
        
    
    
     userId, esp  (espLabels) 
         player = esp.player
          player   player.Parent 
            esp.nameTag.Visible = 
            esp.nameTag:()
            espLabels[userId] = 
            
        
        
         player.Character  player.Character.Parent  player.Character:()  player.Character:() 
             humanoid = player.Character:()
              humanoid  humanoid.Health <=  
                esp.nameTag.Visible = 
                
            
            
             head = player.Character.Head
             rootPart = player.Character.HumanoidRootPart
             legPos, onScreen = Camera:(rootPart.Position - .(, , ))
            
             onScreen  legPos.Z >  
                esp.nameTag.Position = .(legPos.X, legPos.Y + )
                
                
                 player.DisplayName  player.DisplayName ~=  
                    esp.nameTag.Text = player.DisplayName
                
                    esp.nameTag.Text = player.Name
                
                
                 currentTarget  currentTarget.Parent == player.Character 
                    esp.nameTag.Color = Config[][]
                
                    esp.nameTag.Color = Config[][]
                
                
                esp.nameTag.Visible = 
            
                esp.nameTag.Visible = 
            
        
            esp.nameTag.Visible = 
        
    



 _, player  (Players:()) 
     player ~= LocalPlayer  player.Character  player.Character:() 
        (player)
    
    
    player.CharacterAdded:((char)
        (player)
        char:()
        .()
        (player)
    )
    
    player.CharacterRemoving:(()
        (player)
    )


Players.PlayerAdded:((player)
     player ~= LocalPlayer 
        player.CharacterAdded:((char)
            (player)
            char:()
            .()
            (player)
        )
        
        player.CharacterRemoving:(()
            (player)
        )
    
)

Players.PlayerRemoving:((player)
    (player)
)


RunService.Heartbeat:(()
      Config[][]   
    
     character = LocalPlayer.Character
      character   
    
     humanoid = character:()
     rootPart = character:()
    
      humanoid   rootPart   
    
    
     holdingB = UserInputService:(.KeyCode[Config[][]])
    
    
     holdingB  (humanoid:() == .HumanoidStateType.Landed  humanoid.FloorMaterial ~= .Material.Air) 
        
        rootPart.Velocity = .(
            rootPart.Velocity.X,
            Config[][],
            rootPart.Velocity.Z
        )
        .(Config[][])  
    
)


RunService.RenderStepped:(()
     ()  isLocking 
        currentTarget = 
        isLocking = 
        lastVisibleTarget = 
    
    
    ()
    
     SpeedEnabled  Config[][] 
         humanoid = LocalPlayer.Character  LocalPlayer.Character:()
         humanoid 
             targetSpeed = BaseSpeed * Config[][]
            
             humanoid.WalkSpeed ~= targetSpeed 
                humanoid.WalkSpeed = targetSpeed
            
        
        
         Config[][] 
             hrp = LocalPlayer.Character  LocalPlayer.Character:()
             hrp 
                 vel = hrp.Velocity
                 vel.Y >   vel.Y < - 
                    hrp.Velocity = .(vel.X, , vel.Z)
                
            
        
    
    
     Config[][] 
         _, player  (Players:()) 
             player ~= LocalPlayer  player.Character 
                 hrp = player.Character:()
                 hrp 
                    hrp.Size = .(Config[][], Config[][], Config[][])
                    
                     Config[][] 
                        hrp.Transparency = 
                        hrp.BrickColor = BrickColor.()
                        hrp.Material = 
                        hrp.CanCollide = 
                    
                        hrp.Transparency = 
                    
                
            
        
    
    
     Config[][] 
         humanoid = LocalPlayer.Character  LocalPlayer.Character:()
         hrp = LocalPlayer.Character  LocalPlayer.Character:()
        
         humanoid  hrp 
             raycastParams = RaycastParams.()
            raycastParams.FilterDescendantsInstances = {LocalPlayer.Character}
            raycastParams.FilterType = .RaycastFilterType.Exclude
            
             directions = {
                hrp.CFrame.LookVector * ,
                hrp.CFrame.RightVector * ,
                -hrp.CFrame.RightVector * ,
            }
            
             foundWall = 
             _, direction  (directions) 
                 result = Workspace:(hrp.Position, direction, raycastParams)
                 result  result.Instance 
                    foundWall = 
                    
                
            
            
             foundWall 
                 humanoid:() ~= .HumanoidStateType.Climbing 
                    humanoid:(.HumanoidStateType.Climbing, )
                    humanoid:(.HumanoidStateType.Climbing)
                
                
                 bodyVelocity = hrp:()
                  bodyVelocity 
                    bodyVelocity = .()
                    bodyVelocity.Name = 
                    bodyVelocity.MaxForce = .(, , )
                    bodyVelocity.Velocity = .(, , )
                    bodyVelocity.Parent = hrp
                
            
                 bodyVelocity = hrp:()
                 bodyVelocity 
                    bodyVelocity:()
                
            
        
    
         hrp = LocalPlayer.Character  LocalPlayer.Character:()
         hrp 
             bodyVelocity = hrp:()
             bodyVelocity 
                bodyVelocity:()
            
        
    
    
    ()
    ()
    
     Config[][] 
        ()
    
)


UserInputService.InputBegan:((input, processed)
     processed   
    
     input.KeyCode == .KeyCode[Config[][][]] 
         mode = Config[][][]
        
         mode ==  
             Config[][] 
                 isLocking 
                    isLocking = 
                    currentTarget = 
                    lastVisibleTarget = 
                
                     target = ()
                     target 
                        currentTarget = target
                        lastVisibleTarget = target
                        isLocking = 
                    
                
            
                isLocking =  isLocking
            
         mode ==  
             Config[][] 
                 target = ()
                 target 
                    currentTarget = target
                    lastVisibleTarget = target
                    isLocking = 
                
            
                isLocking = 
            
        
    
    
     input.KeyCode == .KeyCode[Config[][][]] 
         mode = Config[][][]
        
         mode ==  
            triggerEnabled =  triggerEnabled
         mode ==  
            triggerEnabled = 
        
    
    
     input.KeyCode == .KeyCode[Config[][]] 
         humanoid = LocalPlayer.Character  LocalPlayer.Character:()
         humanoid 
              SpeedEnabled 
                BaseSpeed = 
                SpeedEnabled = 
            
                humanoid.WalkSpeed = BaseSpeed
                SpeedEnabled = 
            
        
    
    
     input.KeyCode == .KeyCode[Config[][]] 
        Config[][] =  Config[][]
    
    
    
     input.KeyCode == .KeyCode[Config[][]] 
        superJumpActive =  superJumpActive
        ( .. (superJumpActive    ))
    
)

UserInputService.InputEnded:((input, processed)
     processed   
    
     input.KeyCode == .KeyCode[Config[][][]] 
         mode = Config[][][]
        
         mode ==  
            isLocking = 
            currentTarget = 
            lastVisibleTarget = 
        
    
    
     input.KeyCode == .KeyCode[Config[][][]] 
         mode = Config[][][]
        
         mode ==  
            triggerEnabled = 
        
    
)

LocalPlayer.CharacterAdded:(()
    .()
)

 rapidFireActive = 

UserInputService.InputBegan:((input, gameProcessed)
     gameProcessed   
    
     input.UserInputType == .UserInputType.MouseButton1 
        rapidFireActive = 
    
    
    
)

UserInputService.InputEnded:((input, gameProcessed)
     input.UserInputType == .UserInputType.MouseButton1 
        rapidFireActive = 
    
    
    
)


RunService.Heartbeat:(()
      Config[][]   rapidFireActive   
    
     character = LocalPlayer.Character
      character   
    
     tool = character:()
      tool   
    
    
     Config[][][] 
         valid = 
         _, wName  (Config[][][]) 
             tool.Name == wName 
                valid = 
                
            
        
          valid   
    
    
    
    tool:()
    
    
    .(Config[][])
)

 infRangeActive = 


UserInputService.InputBegan:((input, processed)
     processed   
    
     input.KeyCode == .KeyCode[Config[][]] 
        infRangeActive =  infRangeActive
        ( .. (infRangeActive    ))
    
)


RunService.RenderStepped:(()
      Config[][]   infRangeActive   
    
     character = LocalPlayer.Character
      character   
    
     tool = character:()
      tool   
    
    
     rangeProps = {, , , , }
    
     _, propName  (rangeProps) 
         rangeValue = tool:(propName)
         rangeValue  rangeValue:() 
            rangeValue.Value = Config[][]
        
        
        
         config = tool:()  tool:()
         config 
             r = config:(propName)
             r  r:() 
                r.Value = Config[][]
            
        
    
)


 gui = .()
gui.Parent = .CoreGui

 text = .()
text.Parent = gui

text.AnchorPoint = .(, )
text.Position = .(, , , -)
text.Size = .(, , , )

text.BackgroundTransparency = 
text.TextXAlignment = .TextXAlignment.Center
text.TextYAlignment = .TextYAlignment.Bottom

text.Font = .Font.GothamBlack
text.TextSize = 
text.RichText = 


text.TextStrokeTransparency = 
text.TextStrokeColor3 = .(, , )

:().RenderStepped:(()
     lines = {}

    
    .(lines, )

    
     SpeedEnabled 
        .(lines, )
    
        .(lines, )
    

    
     Config[][]  currentTarget 
        .(lines, )
    
        .(lines, )
    

    
     Config[][]  triggerEnabled 
        .(lines, )
    
        .(lines, )
    

    
     infRangeActive 
        .(lines, )
    
        .(lines, )
    

    text.Text = .(lines, )
)
()