Keyless
Deephat | Skin Changer
furasekfilip 3 weeks ago 5.1K viewsRun it
Copy the script and paste it into your executor.
Deephat Skin Changer.lua · 2,021 lines
Players = :()
ReplicatedStorage = :()
UserInputService = :()
RunService = :()
Lighting = :()
SoundService = :()
HttpService = :()
LocalPlayer = Players.LocalPlayer
Camera = .CurrentCamera
LinoriaLib = {}
Library = {Theme = {}}
LinoriaLib.Library = Library
Library.Theme.Accent = .(, , )
Library.Theme.Background = .(, , )
Library.Theme.Outline = .(, , )
Library.Theme.Text = .(, , )
Library.Theme.TextDim = .(, , )
Library.Theme.Font = .Font.Gotham
UI = .()
UI.Name =
UI.ResetOnSpawn =
UI.IgnoreGuiInset =
UI.ZIndexBehavior = .ZIndexBehavior.Sibling
(() UI.Parent = gethui () :() )
Main = .()
Main.Name =
Main.Size = .(, , , )
Main.Position = .(, -, , -)
Main.BackgroundColor3 = Library.Theme.Background
Main.BorderSizePixel =
Main.Visible =
Main.Parent = UI
.(, Main).CornerRadius = .(, )
MainStroke = .(, Main)
MainStroke.Color = Library.Theme.Outline
MainStroke.Thickness =
dragging, dragStart, startPos
Main.InputBegan:((input)
input.UserInputType == .UserInputType.MouseButton1
dragging =
dragStart = input.Position
startPos = Main.Position
input.Changed:(()
input.UserInputState == .UserInputState.End dragging =
)
)
Main.InputChanged:((input)
dragging input.UserInputType == .UserInputType.MouseMovement
delta = input.Position - dragStart
Main.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X,
startPos.Y.Scale, startPos.Y.Offset + delta.Y)
)
TitleBar = .()
TitleBar.Size = .(, , , )
TitleBar.BackgroundColor3 = .(, , )
TitleBar.BorderSizePixel =
TitleBar.Parent = Main
.(, TitleBar).CornerRadius = .(, )
Title = .()
Title.Text =
Title.Font = Library.Theme.Font
Title.TextSize =
Title.TextColor3 = Library.Theme.Text
Title.BackgroundTransparency =
Title.Size = .(, -, , )
Title.Position = .(, , , )
Title.TextXAlignment = .TextXAlignment.Left
Title.Parent = TitleBar
TabBar = .()
TabBar.Size = .(, , , -)
TabBar.Position = .(, , , )
TabBar.BackgroundColor3 = .(, , )
TabBar.BorderSizePixel =
TabBar.Parent = Main
.(, TabBar).CornerRadius = .(, )
TabList = .()
TabList.SortOrder = .SortOrder.LayoutOrder
TabList.Padding = .(, )
TabList.Parent = TabBar
.(, TabBar).PaddingTop = .(, )
Content = .()
Content.Size = .(, -, , -)
Content.Position = .(, , , )
Content.BackgroundTransparency =
Content.Parent = Main
Tabs = {}
ActiveTab =
Library:(name)
Btn = .()
Btn.Text = name
Btn.Font = Library.Theme.Font
Btn.TextSize =
Btn.TextColor3 = Library.Theme.TextDim
Btn.BackgroundColor3 = .(, , )
Btn.BackgroundTransparency =
Btn.BorderSizePixel =
Btn.Size = .(, -, , )
Btn.Position = .(, , , )
Btn.Parent = TabBar
.(, Btn).CornerRadius = .(, )
Scroll = .()
Scroll.Size = .(, , , )
Scroll.BackgroundTransparency =
Scroll.BorderSizePixel =
Scroll.ScrollBarThickness =
Scroll.ScrollBarImageColor3 = Library.Theme.Accent
Scroll.CanvasSize = .(, , , )
Scroll.AutomaticCanvasSize = .AutomaticSize.Y
Scroll.Parent = Content
Scroll.Visible =
Layout = .(, Scroll)
Layout.SortOrder = .SortOrder.LayoutOrder
Layout.Padding = .(, )
Pad = .(, Scroll)
Pad.PaddingTop = .(, )
Pad.PaddingBottom = .(, )
Pad.PaddingLeft = .(, )
Pad.PaddingRight = .(, )
tab = {Button = Btn, Page = Scroll, Name = name}
Tabs[name] = tab
Btn.MouseButton1Click:(()
_, t (Tabs)
t.Page.Visible =
t.Button.TextColor3 = Library.Theme.TextDim
t.Button.BackgroundTransparency =
Scroll.Visible =
Btn.TextColor3 = Library.Theme.Text
Btn.BackgroundTransparency =
Btn.BackgroundColor3 = .(, , )
)
ActiveTab
ActiveTab = name
Scroll.Visible =
Btn.TextColor3 = Library.Theme.Text
Btn.BackgroundTransparency =
Btn.BackgroundColor3 = .(, , )
tab
Library:(parent, text, default, callback)
Row = .()
Row.Size = .(, , , )
Row.BackgroundTransparency =
Row.Parent = parent.Page
Lbl = .()
Lbl.Text = text
Lbl.Font = Library.Theme.Font
Lbl.TextSize =
Lbl.TextColor3 = Library.Theme.Text
Lbl.BackgroundTransparency =
Lbl.Size = .(, -, , )
Lbl.TextXAlignment = .TextXAlignment.Left
Lbl.Parent = Row
Box = .()
Box.Size = .(, , , )
Box.Position = .(, -, , -)
Box.BackgroundColor3 = default Library.Theme.Accent .(, , )
Box.BorderSizePixel =
Box.Text =
Box.Parent = Row
.(, Box).CornerRadius = .(, )
state = {Value = default}
Box.MouseButton1Click:(()
state.Value = state.Value
Box.BackgroundColor3 = state.Value Library.Theme.Accent .(, , )
callback (state.Value)
)
state
Library:(parent, text, min, max, default, callback)
Row = .()
Row.Size = .(, , , )
Row.BackgroundTransparency =
Row.Parent = parent.Page
Lbl = .()
Lbl.Text = text .. .. (default)
Lbl.Font = Library.Theme.Font
Lbl.TextSize =
Lbl.TextColor3 = Library.Theme.Text
Lbl.BackgroundTransparency =
Lbl.Size = .(, , , )
Lbl.TextXAlignment = .TextXAlignment.Left
Lbl.Parent = Row
Bar = .()
Bar.Size = .(, , , )
Bar.Position = .(, , , )
Bar.BackgroundColor3 = .(, , )
Bar.BorderSizePixel =
Bar.Parent = Row
.(, Bar).CornerRadius = .(, )
Fill = .()
Fill.Size = .((default - min) / (max - min), , , )
Fill.BackgroundColor3 = Library.Theme.Accent
Fill.BorderSizePixel =
Fill.Parent = Bar
.(, Fill).CornerRadius = .(, )
dragging =
(input)
pos = .((input.Position.X - Bar.AbsolutePosition.X) / Bar.AbsoluteSize.X, , )
value = min + pos * (max - min)
max >= value = .(value) value = .(value * ) /
Fill.Size = .(pos, , , )
Lbl.Text = text .. .. (value)
callback (value)
Bar.InputBegan:((input)
input.UserInputType == .UserInputType.MouseButton1
dragging =
(input)
input.Changed:(()
input.UserInputState == .UserInputState.End dragging =
)
)
Row.InputBegan:((input)
input.UserInputType == .UserInputType.MouseMovement dragging (input)
)
{Value = default}
Library:(parent, text, default, callback)
Row = .()
Row.Size = .(, , , )
Row.BackgroundTransparency =
Row.Parent = parent.Page
Lbl = .()
Lbl.Text = text
Lbl.Font = Library.Theme.Font
Lbl.TextSize =
Lbl.TextColor3 = Library.Theme.Text
Lbl.BackgroundTransparency =
Lbl.Size = .(, -, , )
Lbl.TextXAlignment = .TextXAlignment.Left
Lbl.Parent = Row
swatch = .()
swatch.Size = .(, , , )
swatch.Position = .(, -, , -)
swatch.BackgroundColor3 = default
swatch.BorderSizePixel =
swatch.Text =
swatch.Parent = Row
.(, swatch).CornerRadius = .(, )
state = {Value = default}
popup = .()
popup.Size = .(, , , )
popup.BackgroundColor3 = .(, , )
popup.BorderSizePixel =
popup.Visible =
popup.ZIndex =
popup.Parent = Main
.(, popup).CornerRadius = .(, )
hueBar = .()
hueBar.Size = .(, -, , )
hueBar.Position = .(, , , )
hueBar.Parent = popup
.(, hueBar).Color = ColorSequence.({
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
ColorSequenceKeypoint.(, .(, , )),
})
hueBtn = .()
hueBtn.Size = .(, , , )
hueBtn.BackgroundTransparency =
hueBtn.Text =
hueBtn.Parent = hueBar
h, s, v = default:()
s, v = ,
(px)
h = .((px - hueBar.AbsolutePosition.X) / hueBar.AbsoluteSize.X, , )
state.Value = .(h, s, v)
swatch.BackgroundColor3 = state.Value
callback (state.Value)
hueBtn.MouseButton1Down:(()
mv
mv = UserInputService.InputChanged:((input)
input.UserInputType == .UserInputType.MouseMovement (input.Position.X)
)
endConn
endConn = UserInputService.InputEnded:((input)
input.UserInputType == .UserInputType.MouseButton1
mv:(); endConn:()
)
)
swatch.MouseButton1Click:(()
popup.Visible = popup.Visible
popup.Visible
ap = swatch.AbsolutePosition
mp = Main.AbsolutePosition
popup.Position = .(, ap.X - mp.X - , , ap.Y - mp.Y + )
)
state
Library:(parent, text, options, default, callback)
Row = .()
Row.Size = .(, , , )
Row.BackgroundTransparency =
Row.Parent = parent.Page
Lbl = .()
Lbl.Text = text
Lbl.Font = Library.Theme.Font
Lbl.TextSize =
Lbl.TextColor3 = Library.Theme.Text
Lbl.BackgroundTransparency =
Lbl.Size = .(, , , )
Lbl.TextXAlignment = .TextXAlignment.Left
Lbl.Parent = Row
Select = .()
Select.Size = .(, -, , )
Select.Position = .(, , , -)
Select.BackgroundColor3 = .(, , )
Select.TextColor3 = Library.Theme.Text
Select.Font = Library.Theme.Font
Select.TextSize =
Select.Text = default options[]
Select.BorderSizePixel =
Select.Parent = Row
.(, Select).CornerRadius = .(, )
state = {Value = default options[]}
idx =
Select.MouseButton1Click:(()
i, opt (options)
opt == state.Value idx = i
idx = idx % #options +
state.Value = options[idx]
Select.Text = state.Value
callback (state.Value)
)
state
Library:() UI:()
UserInputService.InputBegan:((input, processed)
processed
input.KeyCode == .KeyCode.Insert
Main.Visible = Main.Visible
)
Library = LinoriaLib.Library
Config = {
Enabled = ,
MaxDistance = ,
ESP = {
Enabled = ,
Boxes = , Names = , GradientBoxes = ,
TeamCheck = , HealthCheck = , TeamColorMode = ,
BoxThickness = , NameOutline = , NameSize = ,
BoxCornerDots = , DotSize = ,
HealthBar = , HealthBarWidth = , HealthBarOffset = ,
Colors = {
BoxTop = .(, , ),
BoxBot = .(, , ),
CornerDot = .(, , ),
Name = .(, , ),
HealthLow = .(, , ),
HealthHigh = .(, , ),
HealthBack = .(, , ),
Terrorists = .(, , ),
CT = .(, , ),
CounterTerrorists = .(, , ),
},
},
World = { Enabled = , KillGameEffects = },
SkinChanger = {
Enabled = ,
KnifeModel = ,
KnifeSkin = ,
BaseKnives = { , , },
},
NoSpread = { Enabled = , Whitelist = { }, ScopedOnly = },
SpectatorList = { Enabled = , Position = .(, -, , ), Width = },
Hitmarker = {
Enabled = , Size = , Thickness = ,
Color = .(, , ), Duration = ,
Outline = , OutlineColor = .(, , ),
KillColor = .(, , ), KillDuration = , KillSize = ,
},
Hitsound = {
Enabled = , SoundId = ,
Volume = , PitchMin = , PitchMax = ,
KillPitch = , KillVolume = , MinInterval = ,
},
Movement = {
Bhop = {
Enabled = ,
Key = .KeyCode.Space,
},
EdgeBug = {
Enabled = ,
Key = .KeyCode.LeftShift,
HoldFrames = ,
MinFallSpeed = ,
Cooldown = ,
},
},
}
ESP_Data = {}
Connections = {}
Drawing_Registry = {}
WorldVisuals = {}
StolenEffects = {}
OriginalLighting = {}
WorldInitialized =
CachedSky, CachedAtmos, CachedCC, CachedBloom = , , ,
Applied = {}
CachedMyTeam =
Hooks = {SkinsModule=, ViewmodelModule=, originalGetCamera=, originalGetChar=, originalVmNew=, installed=}
SpreadHooks = {InventoryController=, originalShootWeapon=, installed=, lastShotTime=, _lastAmmo=}
SpectatorUI = {Root=, CountLabel=, ListContainer=, Rows={}, LastUpdate=, LastRowKey=}
Hitmarker = {Lines={}, OutlineLines={}, ShowUntil=, IsKill=, Initialized=}
Hitsound = {Instances={}, NextIndex=, PoolSize=, LastPlayed=}
BhopState = {WasGrounded=}
EdgeBugState = {LastTrigger=, FallFrames=, WasAir=}
RageTab = Library:()
VisualsTab = Library:()
WorldTab = Library:()
MovementTab= Library:()
SkinTab = Library:()
MiscTab = Library:()
Library:(RageTab, , Config.NoSpread.Enabled, (v) Config.NoSpread.Enabled = v )
Library:(RageTab, , Config.NoSpread.ScopedOnly, (v) Config.NoSpread.ScopedOnly = v )
Library:(VisualsTab, , Config.ESP.Enabled, (v) Config.ESP.Enabled = v )
Library:(VisualsTab, , Config.ESP.TeamCheck, (v) Config.ESP.TeamCheck = v )
Library:(VisualsTab, , Config.ESP.HealthCheck, (v) Config.ESP.HealthCheck = v )
Library:(VisualsTab, , Config.ESP.TeamColorMode, (v) Config.ESP.TeamColorMode = v )
Library:(VisualsTab, , Config.ESP.GradientBoxes, (v) Config.ESP.GradientBoxes = v )
Library:(VisualsTab, , Config.ESP.BoxCornerDots, (v) Config.ESP.BoxCornerDots = v )
Library:(VisualsTab, , Config.ESP.Names, (v) Config.ESP.Names = v )
Library:(VisualsTab, , Config.ESP.HealthBar, (v) Config.ESP.HealthBar = v )
Library:(VisualsTab, , , , Config.ESP.BoxThickness, (v) Config.ESP.BoxThickness = v )
Library:(VisualsTab, , , , Config.ESP.NameSize, (v) Config.ESP.NameSize = v )
Library:(VisualsTab, , , , , (v) Config.MaxDistance = v )
Library:(VisualsTab, , Config.ESP.Colors.BoxTop, (c) Config.ESP.Colors.BoxTop = c )
Library:(VisualsTab, , Config.ESP.Colors.BoxBot, (c) Config.ESP.Colors.BoxBot = c )
Library:(VisualsTab, , Config.ESP.Colors.CornerDot, (c) Config.ESP.Colors.CornerDot = c )
Library:(VisualsTab, , Config.ESP.Colors.Name, (c) Config.ESP.Colors.Name = c )
Library:(VisualsTab, , Config.ESP.Colors.Terrorists, (c) Config.ESP.Colors.Terrorists = c )
Library:(VisualsTab, , Config.ESP.Colors.CT, (c) Config.ESP.Colors.CT = c )
Library:(WorldTab, , Config.World.Enabled, (v) Config.World.Enabled = v )
Library:(WorldTab, , Config.World.KillGameEffects, (v) Config.World.KillGameEffects = v )
Library:(WorldTab, , Config.SpectatorList.Enabled, (v) Config.SpectatorList.Enabled = v )
Library:(MovementTab, , Config.Movement.Bhop.Enabled, (v) Config.Movement.Bhop.Enabled = v )
Library:(MovementTab, , Config.Movement.EdgeBug.Enabled, (v) Config.Movement.EdgeBug.Enabled = v )
Library:(MovementTab, , , , Config.Movement.EdgeBug.MinFallSpeed, (v) Config.Movement.EdgeBug.MinFallSpeed = v )
Library:(MovementTab, , , , Config.Movement.EdgeBug.Cooldown, (v) Config.Movement.EdgeBug.Cooldown = v )
Library:(SkinTab, , Config.SkinChanger.Enabled, (v) Config.SkinChanger.Enabled = v )
Library:(SkinTab, ,
{ , , , , , , },
Config.SkinChanger.KnifeModel,
(v) Config.SkinChanger.KnifeModel = v )
Library:(SkinTab, ,
{ , , , , , , , },
Config.SkinChanger.KnifeSkin,
(v) Config.SkinChanger.KnifeSkin = v )
Library:(MiscTab, , Config.Hitmarker.Enabled, (v) Config.Hitmarker.Enabled = v )
Library:(MiscTab, , , , Config.Hitmarker.Size, (v) Config.Hitmarker.Size = v )
Library:(MiscTab, , , , Config.Hitmarker.Duration, (v) Config.Hitmarker.Duration = v )
Library:(MiscTab, , Config.Hitmarker.Color, (c) Config.Hitmarker.Color = c )
Library:(MiscTab, , Config.Hitmarker.KillColor, (c) Config.Hitmarker.KillColor = c )
Library:(MiscTab, , Config.Hitsound.Enabled, (v) Config.Hitsound.Enabled = v )
Library:(MiscTab, , , , Config.Hitsound.Volume, (v) Config.Hitsound.Volume = v )
Library:(MiscTab, , , , Config.Hitsound.MinInterval, (v) Config.Hitsound.MinInterval = v )
()
GALAXY_SKYBOX = {
SkyboxBk = , SkyboxDn = ,
SkyboxFt = , SkyboxLf = ,
SkyboxRt = , SkyboxUp = ,
}
()
Config.World.KillGameEffects
_, child (Lighting:())
child:() child:()
child:() child:()
child:() child:()
child:()
child.Name:()
known =
_, entry (StolenEffects)
entry.inst == child known = ;
known
.(StolenEffects, {inst = child, parent = Lighting})
child.Parent =
()
_, entry (StolenEffects)
(()
entry.inst entry.inst.Parent ==
entry.inst.Parent = entry.parent
)
.(StolenEffects)
(force)
CachedSky
CachedSky.Parent
WorldInitialized =
_, obj (WorldVisuals) (() obj:() )
.(WorldVisuals)
CachedSky, CachedAtmos, CachedCC, CachedBloom = , , ,
.(Applied)
(target, key, value)
force Applied[key] ~= value target[key] = value; Applied[key] = value
(CachedSky, , GALAXY_SKYBOX.SkyboxBk)
(CachedSky, , GALAXY_SKYBOX.SkyboxDn)
(CachedSky, , GALAXY_SKYBOX.SkyboxFt)
(CachedSky, , GALAXY_SKYBOX.SkyboxLf)
(CachedSky, , GALAXY_SKYBOX.SkyboxRt)
(CachedSky, , GALAXY_SKYBOX.SkyboxUp)
(CachedSky, , )
(CachedAtmos, , )
(CachedAtmos, , )
(CachedAtmos, , .(, , ))
(CachedAtmos, , .(, , ))
(CachedAtmos, , )
(CachedAtmos, , )
(Lighting, , .(, , ))
(Lighting, , .(, , ))
(Lighting, , )
(Lighting, , )
(Lighting, , )
(Lighting, , )
(Lighting, , )
(CachedCC, , )
(CachedCC, , )
(CachedCC, , )
(CachedCC, , .(, , ))
(CachedBloom, , )
(CachedBloom, , )
(CachedBloom, , )
()
WorldInitialized
OriginalLighting.Ambient = Lighting.Ambient
OriginalLighting.OutdoorAmbient = Lighting.OutdoorAmbient
OriginalLighting.Brightness = Lighting.Brightness
OriginalLighting.ClockTime = Lighting.ClockTime
OriginalLighting.EnvironmentDiffuseScale = Lighting.EnvironmentDiffuseScale
OriginalLighting.EnvironmentSpecularScale = Lighting.EnvironmentSpecularScale
OriginalLighting.ExposureCompensation = Lighting.ExposureCompensation
OriginalLighting.Technology = Lighting.Technology
()
CachedSky = .(); CachedSky.Name = ; CachedSky.Parent = Lighting
CachedAtmos = .(); CachedAtmos.Name = ; CachedAtmos.Parent = Lighting
CachedCC = .(); CachedCC.Name = ; CachedCC.Parent = Lighting
CachedBloom = .(); CachedBloom.Name = ; CachedBloom.Parent = Lighting
.(WorldVisuals, CachedSky)
.(WorldVisuals, CachedAtmos)
.(WorldVisuals, CachedCC)
.(WorldVisuals, CachedBloom)
()
WorldInitialized =
()
_, obj (WorldVisuals) (() obj:() )
.(WorldVisuals)
OriginalLighting.Ambient ~=
Lighting.Ambient = OriginalLighting.Ambient
Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
Lighting.Brightness = OriginalLighting.Brightness
Lighting.ClockTime = OriginalLighting.ClockTime
Lighting.EnvironmentDiffuseScale = OriginalLighting.EnvironmentDiffuseScale
Lighting.EnvironmentSpecularScale = OriginalLighting.EnvironmentSpecularScale
Lighting.ExposureCompensation = OriginalLighting.ExposureCompensation
Lighting.Technology = OriginalLighting.Technology
()
CachedSky, CachedAtmos, CachedCC, CachedBloom = , , ,
WorldInitialized =
.(Applied)
(kind, props)
d = .(kind)
k, v (props) d[k] = v
Drawing_Registry[#Drawing_Registry + ] = d
d
(a, b, t)
.(a.R + (b.R - a.R) * t, a.G + (b.G - a.G) * t, a.B + (b.B - a.B) * t)
(player)
t = player.Team
(t) == t
(t) == t.Name t.Name
attr = player:()
attr attr
(player)
myTeam = CachedMyTeam (LocalPlayer)
myTeam
theirTeam = (player)
theirTeam
myTeam == theirTeam
(player)
name = (player)
name
colors = Config.ESP.Colors
colors[name] colors[name]
lower = name:()
lower:() lower == colors.Terrorists
lower:() lower:() colors.CT
(char)
hum = char:()
hum hum.Health, hum.MaxHealth
hp = char:()
hp hp:()
max = char:()
hp.Value, (max max.Value )
a = char:()
b = char:()
a a, (b )
,
(char)
hum = char:()
hum hum.Health >
hp = char:()
hp hp:() hp.Value >
attr = char:()
attr attr >
dead = char:()
dead ~= dead
_, part (char:())
part:()
_, tag (part:())
tag:():() tag:():()
()
Hitmarker.Initialized
Hitmarker.Initialized =
i = ,
Hitmarker.Lines[i] = (, {Thickness = Config.Hitmarker.Thickness, Color = Config.Hitmarker.Color, Visible = })
Config.Hitmarker.Outline
Hitmarker.OutlineLines[i] = (, {Thickness = Config.Hitmarker.Thickness + , Color = Config.Hitmarker.OutlineColor, Visible = })
(isKill)
Config.Hitmarker.Enabled
()
duration = isKill Config.Hitmarker.KillDuration Config.Hitmarker.Duration
Hitmarker.ShowUntil = .() + duration
Hitmarker.IsKill = isKill
()
Hitmarker.Initialized
visible = .() < Hitmarker.ShowUntil
cx = Camera.ViewportSize.X /
cy = Camera.ViewportSize.Y /
isKill = Hitmarker.IsKill
size = isKill Config.Hitmarker.KillSize Config.Hitmarker.Size
color = isKill Config.Hitmarker.KillColor Config.Hitmarker.Color
gap =
corners = {
{.(cx - gap - size, cy - gap - size), .(cx - gap, cy - gap)},
{.(cx + gap, cy - gap - size), .(cx + gap + size, cy - gap)},
{.(cx - gap - size, cy + gap), .(cx - gap, cy + gap + size)},
{.(cx + gap, cy + gap), .(cx + gap + size, cy + gap + size)},
}
i = ,
line = Hitmarker.Lines[i]
outline = Hitmarker.OutlineLines[i]
c = corners[i]
line
line.From = c[]; line.To = c[]; line.Color = color
line.Thickness = Config.Hitmarker.Thickness; line.Visible = visible
outline
outline.From = c[]; outline.To = c[]; outline.Color = Config.Hitmarker.OutlineColor
outline.Thickness = Config.Hitmarker.Thickness +
outline.Visible = visible Config.Hitmarker.Outline
()
#Hitsound.Instances >
group = .()
group.Name =
group.Volume = Config.Hitsound.Volume
group.Parent = SoundService
i = , Hitsound.PoolSize
sound = .()
sound.Name = .. i
sound.SoundId = Config.Hitsound.SoundId
sound.Volume = Config.Hitsound.Volume
sound.SoundGroup = group
sound.Parent = SoundService
Hitsound.Instances[i] = sound
(isKill)
Config.Hitsound.Enabled
now = .()
now - Hitsound.LastPlayed < Config.Hitsound.MinInterval
Hitsound.LastPlayed = now
()
sound = Hitsound.Instances[Hitsound.NextIndex]
Hitsound.NextIndex = (Hitsound.NextIndex % #Hitsound.Instances) +
sound
isKill
sound.PlaybackSpeed = Config.Hitsound.KillPitch
sound.Volume = Config.Hitsound.KillVolume
sound.PlaybackSpeed = Config.Hitsound.PitchMin + .() * (Config.Hitsound.PitchMax - Config.Hitsound.PitchMin)
sound.Volume = Config.Hitsound.Volume
(() sound:() )
(() sound:() )
(w)
w
_, k (Config.SkinChanger.BaseKnives)
w == k
(path)
node = ReplicatedStorage
_, name (path)
node = node:(name)
node
node
()
Hooks.installed
skinsScript = ({, , , })
vmScript = ({, , , })
skinsScript vmScript
()
ok1, Sk = (, skinsScript)
ok2, Vm = (, vmScript)
ok1 (Sk) ~= ok2 (Vm) ~=
()
(Sk.GetCameraModel) ==
Hooks.originalGetCamera = Sk.GetCameraModel
Sk.GetCameraModel = (w, sk, ...)
Config.SkinChanger.Enabled (w)
ok, result = (Hooks.originalGetCamera, Config.SkinChanger.KnifeModel, Config.SkinChanger.KnifeSkin, ...)
ok result result
ok, result = (Hooks.originalGetCamera, w, sk, ...)
ok result
(Sk.GetCharacterModel) ==
Hooks.originalGetChar = Sk.GetCharacterModel
Sk.GetCharacterModel = (w, sk, ...)
Config.SkinChanger.Enabled (w)
ok, result = (Hooks.originalGetChar, Config.SkinChanger.KnifeModel, Config.SkinChanger.KnifeSkin, ...)
ok result result
ok, result = (Hooks.originalGetChar, w, sk, ...)
ok result
(Vm.new) ==
Hooks.originalVmNew = Vm.new
Vm.new = (vc, w, sk, ...)
Config.SkinChanger.Enabled (w)
ok, result = (Hooks.originalVmNew, vc, Config.SkinChanger.KnifeModel, Config.SkinChanger.KnifeSkin, ...)
ok result result
ok, result = (Hooks.originalVmNew, vc, w, sk, ...)
ok result
Hooks.SkinsModule = Sk
Hooks.ViewmodelModule = Vm
Hooks.installed =
()
()
Hooks.installed
(() Hooks.SkinsModule Hooks.originalGetCamera Hooks.SkinsModule.GetCameraModel = Hooks.originalGetCamera )
(() Hooks.SkinsModule Hooks.originalGetChar Hooks.SkinsModule.GetCharacterModel = Hooks.originalGetChar )
(() Hooks.ViewmodelModule Hooks.originalVmNew Hooks.ViewmodelModule.new = Hooks.originalVmNew )
Hooks.installed =
()
_, child (Camera:())
child:() child:() child.Name
()
char = LocalPlayer.Character
char
scoped = char:()
scoped ~= scoped
pg = LocalPlayer:()
pg
_, gui (pg:())
gui.Name:():() gui.Enabled
()
SpreadHooks.installed
Config.NoSpread.Enabled
invScript = ({, })
invScript
ok, IC = (, invScript)
ok (IC) ~=
(IC.ShootWeapon) ~=
SpreadHooks.InventoryController = IC
SpreadHooks.originalShootWeapon = IC.ShootWeapon
IC.ShootWeapon = (Self, Data)
SpreadHooks.lastShotTime = .()
Config.NoSpread.Enabled
weapon = ()
weapon
lower = weapon:()
whitelisted =
_, w (Config.NoSpread.Whitelist)
lower:(w:(), , ) whitelisted = ;
whitelisted
Config.NoSpread.ScopedOnly ()
Data Data.Bullets
LookVector = .CurrentCamera.CFrame.LookVector
_, Bullet (Data.Bullets)
(() Bullet.Direction = LookVector )
SpreadHooks.(Self, Data)
SpreadHooks.installed =
()
()
SpreadHooks.installed
(()
SpreadHooks.InventoryController SpreadHooks.originalShootWeapon
SpreadHooks.InventoryController.ShootWeapon = SpreadHooks.originalShootWeapon
)
SpreadHooks.installed =
()
candidates = {}
_, d (ReplicatedStorage:())
d:()
lower = d.Name:()
lower:() lower:() lower:()
lower:() lower:() lower:()
lower:()
.(candidates, d)
_, d (ReplicatedStorage:())
d:()
lower = d.Name:()
lower:() lower:() lower:()
.(candidates, d)
.(()
Config.Enabled
.()
(()
ammo = LocalPlayer:()
ammo ~=
SpreadHooks._lastAmmo ~= ammo < SpreadHooks._lastAmmo
SpreadHooks.lastShotTime = .()
SpreadHooks._lastAmmo = ammo
)
)
myCharacter = LocalPlayer.Character
attached =
_, remote (candidates)
(()
remote.OnClientEvent:((...)
args = {...}
myPlayer = LocalPlayer
isMine =
victimIsDead =
_, arg (args)
arg == myPlayer
isMine =
(arg) ==
arg == myPlayer arg == myCharacter
isMine =
arg:() arg == myPlayer
isMine =
argPlayer =
arg:() argPlayer = arg
arg:() argPlayer = Players:(arg)
argPlayer argPlayer ~= myPlayer
vChar = argPlayer.Character
vChar
hp = vChar:()
hp ==
hum = vChar:()
hum hp = hum.Health
hp == victimIsDead =
isMine
now = .()
now - (SpreadHooks.lastShotTime ) <
isMine =
isMine
(victimIsDead)
(victimIsDead)
)
attached = attached +
)
(.(, attached))
attached >
BhopRayParams = RaycastParams.()
BhopRayParams.FilterType = .RaycastFilterType.Exclude
BhopRayParams.IgnoreWater =
()
char = LocalPlayer.Character
char
hum = char:()
hrp = char:()
hum hrp
char, hum, hrp
(hrp, char)
BhopRayParams.FilterDescendantsInstances = {char, Camera}
origin = hrp.Position
down = :(origin, .(, -, ), BhopRayParams)
down
offsets = {
.(, , ), .(-, , ),
.(, , ), .(, , -),
}
_, off (offsets)
ahead = :(origin + off, .(, -, ), BhopRayParams)
ahead
(dt)
Config.Movement.Bhop.Enabled
UserInputService:(Config.Movement.Bhop.Key)
char, hum, hrp = ()
char hum hrp
hum.Health <=
grounded = hum.FloorMaterial ~= .Material.Air
BhopState.WasGrounded = grounded
grounded
hum.Jump =
(dt)
Config.Movement.EdgeBug.Enabled
UserInputService:(Config.Movement.EdgeBug.Key)
char, hum, hrp = ()
char hum hrp
hum.Health <=
now = .()
now - EdgeBugState.LastTrigger < Config.Movement.EdgeBug.Cooldown
vel = hrp.AssemblyLinearVelocity
grounded = hum.FloorMaterial ~= .Material.Air
grounded
EdgeBugState.WasAir =
EdgeBugState.FallFrames =
vel.Y < -Config.Movement.EdgeBug.MinFallSpeed
(hrp, char)
hrp.AssemblyLinearVelocity = .(vel.X, , vel.Z)
EdgeBugState.LastTrigger = now
EdgeBugState.FallFrames =
WIN95 = {
BG = .(, , ), LightEdge = .(, , ),
MidEdge = .(, , ), DarkEdge = .(, , ),
TitleBar1 = .(, , ), TitleBar2 = .(, , ),
TitleText = .(, , ), Text = .(, , ),
TextDim = .(, , ),
}
(frame)
top = .(, frame)
top.BorderSizePixel = ; top.BackgroundColor3 = WIN95.LightEdge
top.Size = .(, , , ); top.Position = .(, , , ); top.ZIndex = frame.ZIndex +
left = .(, frame)
left.BorderSizePixel = ; left.BackgroundColor3 = WIN95.LightEdge
left.Size = .(, , , ); left.Position = .(, , , ); left.ZIndex = frame.ZIndex +
bot = .(, frame)
bot.BorderSizePixel = ; bot.BackgroundColor3 = WIN95.DarkEdge
bot.Size = .(, , , ); bot.Position = .(, , , -); bot.ZIndex = frame.ZIndex +
right = .(, frame)
right.BorderSizePixel = ; right.BackgroundColor3 = WIN95.DarkEdge
right.Size = .(, , , ); right.Position = .(, -, , ); right.ZIndex = frame.ZIndex +
mtop = .(, frame)
mtop.BorderSizePixel = ; mtop.BackgroundColor3 = WIN95.LightEdge
mtop.Size = .(, -, , ); mtop.Position = .(, , , ); mtop.ZIndex = frame.ZIndex +
mleft = .(, frame)
mleft.BorderSizePixel = ; mleft.BackgroundColor3 = WIN95.LightEdge
mleft.Size = .(, , , -); mleft.Position = .(, , , ); mleft.ZIndex = frame.ZIndex +
mbot = .(, frame)
mbot.BorderSizePixel = ; mbot.BackgroundColor3 = WIN95.MidEdge
mbot.Size = .(, -, , ); mbot.Position = .(, , , -); mbot.ZIndex = frame.ZIndex +
mright = .(, frame)
mright.BorderSizePixel = ; mright.BackgroundColor3 = WIN95.MidEdge
mright.Size = .(, , , -); mright.Position = .(, -, , ); mright.ZIndex = frame.ZIndex +
(frame)
top = .(, frame)
top.BorderSizePixel = ; top.BackgroundColor3 = WIN95.MidEdge
top.Size = .(, , , ); top.Position = .(, , , ); top.ZIndex = frame.ZIndex +
left = .(, frame)
left.BorderSizePixel = ; left.BackgroundColor3 = WIN95.MidEdge
left.Size = .(, , , ); left.Position = .(, , , ); left.ZIndex = frame.ZIndex +
bot = .(, frame)
bot.BorderSizePixel = ; bot.BackgroundColor3 = WIN95.LightEdge
bot.Size = .(, , , ); bot.Position = .(, , , -); bot.ZIndex = frame.ZIndex +
right = .(, frame)
right.BorderSizePixel = ; right.BackgroundColor3 = WIN95.LightEdge
right.Size = .(, , , ); right.Position = .(, -, , ); right.ZIndex = frame.ZIndex +
()
gethui ()
:()
()
SpectatorUI.Root SpectatorUI.Root
parent = ()
root = .()
root.Name =
root.Size = .(, Config.SpectatorList.Width, , )
root.Position = Config.SpectatorList.Position
root.BackgroundColor3 = WIN95.BG
root.BorderSizePixel =
root.ZIndex =
root.Parent = parent
(root)
dragging, dragStart, startPos
root.InputBegan:((input)
input.UserInputType == .UserInputType.MouseButton1
dragging = ; dragStart = input.Position; startPos = root.Position
input.Changed:(()
input.UserInputState == .UserInputState.End dragging =
)
)
root.InputChanged:((input)
dragging input.UserInputType == .UserInputType.MouseMovement
delta = input.Position - dragStart
root.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
)
title = .()
title.Size = .(, -, , ); title.Position = .(, , , )
title.BackgroundColor3 = WIN95.TitleBar1; title.BorderSizePixel =
title.ZIndex = ; title.Parent = root
.(, title).Color = ColorSequence.({
ColorSequenceKeypoint.(, WIN95.TitleBar1),
ColorSequenceKeypoint.(, WIN95.TitleBar2),
})
titleText = .()
titleText.Size = .(, -, , ); titleText.Position = .(, , , )
titleText.BackgroundTransparency =
titleText.Text = ; titleText.TextColor3 = WIN95.TitleText
titleText.TextXAlignment = .TextXAlignment.Left
titleText.Font = .Font.SourceSansBold; titleText.TextSize =
titleText.TextStrokeTransparency = ; titleText.ZIndex = ; titleText.Parent = title
closeBtn = .()
closeBtn.Size = .(, , , ); closeBtn.Position = .(, -, , )
closeBtn.BackgroundColor3 = WIN95.BG; closeBtn.BorderSizePixel =
closeBtn.Text = ; closeBtn.TextColor3 = WIN95.Text
closeBtn.Font = .Font.SourceSansBold; closeBtn.TextSize =
closeBtn.TextStrokeTransparency = ; closeBtn.ZIndex = ; closeBtn.Parent = title
(closeBtn)
closeBtn.MouseButton1Click:(()
Config.SpectatorList.Enabled =
root.Visible =
)
countLabel = .()
countLabel.Size = .(, -, , ); countLabel.Position = .(, , , )
countLabel.BackgroundTransparency =
countLabel.Text = ; countLabel.TextColor3 = WIN95.Text
countLabel.TextXAlignment = .TextXAlignment.Left
countLabel.Font = .Font.SourceSansBold; countLabel.TextSize =
countLabel.TextStrokeTransparency = ; countLabel.ZIndex = ; countLabel.Parent = root
listContainer = .()
listContainer.Size = .(, -, , ); listContainer.Position = .(, , , )
listContainer.BackgroundColor3 = .(, , ); listContainer.BorderSizePixel =
listContainer.ZIndex = ; listContainer.Visible = ; listContainer.Parent = root
(listContainer)
ll = .(, listContainer)
ll.FillDirection = .FillDirection.Vertical
ll.SortOrder = .SortOrder.LayoutOrder
ll.Padding = .(, )
SpectatorUI.Root = root
SpectatorUI.CountLabel = countLabel
SpectatorUI.ListContainer = listContainer
root
()
Config.SpectatorList.Enabled
SpectatorUI.Root SpectatorUI.Root.Visible =
root = ()
root.Visible =
now = .()
now - SpectatorUI.LastUpdate <
SpectatorUI.LastUpdate = now
count =
(() count = LocalPlayer:() )
SpectatorUI.CountLabel
count ==
SpectatorUI.CountLabel.Text =
SpectatorUI.CountLabel.TextColor3 = WIN95.TextDim
count ==
SpectatorUI.CountLabel.Text =
SpectatorUI.CountLabel.TextColor3 = WIN95.Text
SpectatorUI.CountLabel.Text = count ..
SpectatorUI.CountLabel.TextColor3 = WIN95.Text
(player)
player == LocalPlayer ESP_Data[player]
ESP_Data[player] = {
Box = (, {Filled = , Thickness = Config.ESP.BoxThickness, Visible = }),
BoxTop = (, {Thickness = Config.ESP.BoxThickness, Visible = }),
BoxBottom = (, {Thickness = Config.ESP.BoxThickness, Visible = }),
BoxLeft = (, {Thickness = Config.ESP.BoxThickness, Visible = }),
BoxRight = (, {Thickness = Config.ESP.BoxThickness, Visible = }),
DotTL = (, {Filled = , Thickness = , Visible = }),
DotTR = (, {Filled = , Thickness = , Visible = }),
DotBL = (, {Filled = , Thickness = , Visible = }),
DotBR = (, {Filled = , Thickness = , Visible = }),
HealthBar = (, {Thickness = Config.ESP.HealthBarWidth, Visible = }),
HealthBarBack = (, {Thickness = Config.ESP.HealthBarWidth, Visible = }),
Name = (, {Size = Config.ESP.NameSize, Center = , Outline = Config.ESP.NameOutline, Font = , Visible = }),
}
(data)
_, key ({, , , , , , , , , , , })
data[key] data[key].Visible =
(player)
d = ESP_Data[player]; d
_, obj (d) obj.Visible = ; obj:()
ESP_Data[player] =
(data, pos, width, height, player)
x1, y1 = pos.X - width * , pos.Y - height *
x2, y2 = pos.X + width * , pos.Y + height *
colors = Config.ESP.Colors
topC, botC = colors.BoxTop, colors.BoxBot
Config.ESP.TeamColorMode
tc = (player)
tc topC = tc; botC = (tc, .(, , ), )
data.Box.Visible =
data.BoxTop.From = .(x1, y1); data.BoxTop.To = .(x2, y1)
data.BoxTop.Color = topC; data.BoxTop.Visible =
data.BoxBottom.From = .(x1, y2); data.BoxBottom.To = .(x2, y2)
data.BoxBottom.Color = botC; data.BoxBottom.Visible =
midC = (topC, botC, )
data.BoxLeft.From = .(x1, y1); data.BoxLeft.To = .(x1, y2)
data.BoxLeft.Color = midC; data.BoxLeft.Visible =
data.BoxRight.From = .(x2, y1); data.BoxRight.To = .new(x2, y2)
data.BoxRight.Color = midC; data.BoxRight.Visible = true
if Config.ESP.BoxCornerDots then
local s = Config.ESP.DotSize
local dc = colors.CornerDot
local function place(dot, cx, cy)
dot.Size = Vector2.new(s, s); dot.Position = Vector2.new(cx - s * 0.5, cy - s * 0.5)
dot.Color = dc; dot.Visible = true
end
place(data.DotTL, x1, y1); place(data.DotTR, x2, y1)
place(data.DotBL, x1, y2); place(data.DotBR, x2, y2)
else
data.DotTL.Visible = false; data.DotTR.Visible = false
data.DotBL.Visible = false; data.DotBR.Visible = false
end
end
local function drawHealthBar(data, pos, width, height, cur, max)
if not Config.ESP.HealthBar or not cur or not max or max <= 0 then
data.HealthBar.Visible = false; data.HealthBarBack.Visible = false; return
end
local pct = math.clamp(cur / max, 0, 1)
local x = pos.X - width * 0.5 - Config.ESP.HealthBarOffset
local y1, y2 = pos.Y - height * 0.5, pos.Y + height * 0.5
data.HealthBarBack.From = Vector2.new(x, y1); data.HealthBarBack.To = Vector2.new(x, y2)
data.HealthBarBack.Color = Config.ESP.Colors.HealthBack; data.HealthBarBack.Visible = true
data.HealthBar.From = Vector2.new(x, y1); data.HealthBar.To = Vector2.new(x, y1 + height * pct)
data.HealthBar.Color = lerpColor(Config.ESP.Colors.HealthLow, Config.ESP.Colors.HealthHigh, pct)
data.HealthBar.Visible = true
end
-- ══════════════════════════════════════════════════════════════════════════
-- UNLOAD
-- ══════════════════════════════════════════════════════════════════════════
local function unload()
print("[DeepHat] Unloading...")
uninstallKnifeHooks()
uninstallSpreadHooks()
if SpectatorUI.Root then pcall(function() SpectatorUI.Root:Destroy() end); SpectatorUI.Root = nil end
for _, sound in ipairs(Hitsound.Instances) do pcall(function() sound:Destroy() end) end
Hitsound.Instances = {}
for _, conn in ipairs(Connections) do
if typeof(conn) == "RBXScriptConnection" then conn:Disconnect() end
end
table.clear(Connections)
for player in pairs(ESP_Data) do removeESP(player) end
for _, obj in ipairs(Drawing_Registry) do obj.Visible = false; obj:Remove() end
table.clear(Drawing_Registry)
if WorldInitialized then revertWorldVisuals() end
pcall(function() Library:Unload() end)
print("[DeepHat] Unload complete.")
end
-- ══════════════════════════════════════════════════════════════════════════
-- MAIN LOOP
-- ══════════════════════════════════════════════════════════════════════════
local function mainLoop()
if not Config.Enabled then
for _, data in pairs(ESP_Data) do hideESP(data) end
return
end
if Config.World.Enabled then
if Config.World.KillGameEffects then stealGameEffects() end
pcall(forceWorldVisuals, false)
end
pcall(updateWin95SpectatorList)
pcall(updateHitmarker)
if not Config.ESP.Enabled then
for _, data in pairs(ESP_Data) do hideESP(data) end
return
end
local camPos = Camera.CFrame.Position
for player, data in pairs(ESP_Data) do
if Config.ESP.TeamCheck and isTeammate(player) then
hideESP(data)
else
local char = player.Character
local hrp = char and char:FindFirstChild("HumanoidRootPart")
local alive = char and isAlive(char)
if char and hrp and (alive or not Config.ESP.HealthCheck) then
local pos, onScreen = Camera:WorldToViewportPoint(hrp.Position)
local dx, dy, dz = hrp.Position.X - camPos.X, hrp.Position.Y - camPos.Y, hrp.Position.Z - camPos.Z
local distance = math.sqrt(dx * dx + dy * dy + dz * dz)
if onScreen and distance <= Config.MaxDistance then
local head = char:FindFirstChild("Head")
local headPos = Camera:WorldToViewportPoint((head and head.Position or hrp.Position + Vector3.new(0, 2, 0)) + Vector3.new(0, 0.5, 0))
local legPos = Camera:WorldToViewportPoint(hrp.Position - Vector3.new(0, 3, 0))
local height = math.abs(headPos.Y - legPos.Y)
local width = height / 1.6
if Config.ESP.GradientBoxes then
drawGradientBox(data, pos, width, height, player)
else
hideESP(data)
end
local cur, max = getHealth(char)
drawHealthBar(data, pos, width, height, cur, max)
if Config.ESP.Names then
data.Name.Position = Vector2.new(pos.X, pos.Y - height * 0.5 - 15)
data.Name.Text = string.format("%s [%d]", player.DisplayName or player.Name, math.floor(distance))
data.Name.Color = Config.ESP.Colors.Name
data.Name.Visible = true
elseif data.Name.Visible then
data.Name.Visible = false
end
else
hideESP(data)
end
else
hideESP(data)
end
end
end
end
-- ══════════════════════════════════════════════════════════════════════════
-- INIT
-- ══════════════════════════════════════════════════════════════════════════
local function initialize()
CachedMyTeam = getTeamName(LocalPlayer)
if Config.World.Enabled then initWorldVisuals() end
if Config.Hitmarker.Enabled then initHitmarker() end
if Config.Hitsound.Enabled then initHitsound() end
if Config.SkinChanger.Enabled then
task.spawn(function() task.wait(0.5) installKnifeHooks() end)
end
if Config.NoSpread.Enabled then
task.spawn(function() task.wait(1) installSpreadHooks() end)
end
if Config.SpectatorList.Enabled then
task.spawn(function() task.wait(1) createWin95SpectatorList() end)
end
task.spawn(function() task.wait(1.5) installHitDetection() end)
RunService:BindToRenderStep("DeepHatBhop", Enum.RenderPriority.Character.Value + 1, function(dt)
pcall(bhopStep, dt)
end)
RunService:BindToRenderStep("DeepHatEdgeBug", Enum.RenderPriority.Character.Value + 2, function(dt)
pcall(edgeBugStep, dt)
end)
table.insert(Connections, Players.PlayerAdded:Connect(setupESP))
table.insert(Connections, Players.PlayerRemoving:Connect(removeESP))
for _, player in ipairs(Players:GetPlayers()) do task.spawn(setupESP, player) end
table.insert(Connections, LocalPlayer.CharacterAdded:Connect(function()
task.wait(1)
CachedMyTeam = getTeamName(LocalPlayer)
BhopState.WasGrounded = true
EdgeBugState.WasAir = false
EdgeBugState.FallFrames = 0
end))
table.insert(Connections, RunService.RenderStepped:Connect(mainLoop))
table.insert(Connections, UserInputService.InputBegan:Connect(function(input, processed)
if not processed and input.KeyCode == Enum.KeyCode.End then unload() end
end))
print("[DeepHat] Online. [INSERT] menu [END] unload.")
end
task.spawn(function()
task.wait(1)
initialize()
end)
-- DeepHat DEBUG: bhop + auto edgebug + pixel surf + wall glide + u/s counter.
-- [END] to unload.
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local RS = game:GetService("ReplicatedStorage")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local CharacterController = require(RS.Controllers.CharacterController)
-- ── config ────────────────────────────────────────────────────────────────
local Config = {
Bhop = {
Enabled = true,
Key = Enum.KeyCode.Space,
MinDelay = 0.03,
},
EdgeBug = {
Enabled = true,
MinFallSpeed = 15,
Cooldown = 0.1,
},
-- pixel surf: preserve velocity while moving along a wall at an angle
PixelSurf = {
Enabled = true,
-- surface normal must be more horizontal than this (0=up, 1=side)
MinNormalY = 0.6,
-- how much velocity to keep per frame while in contact (1.0 = none lost)
Retention = 0.98,
-- minimum horizontal speed to bother
MinSpeed = 8,
-- fire only when a wall/floor is under this many studs away
ContactDist = 1.2,
},
-- wall glide: cancel vertical fall while pressed against a vertical surface
WallGlide = {
Enabled = true,
-- how much to reduce downward velocity (0=none, 1=full cancel)
CancelFactor = 0.9,
-- how much horizontal speed to add per frame for the glide
PushSpeed = 0.15,
-- only glide if moving faster than this
MinSpeed = 5,
-- distance to wall to trigger
ContactDist = 1.2,
},
Counter = {
Enabled = true,
X = 20, Y = 20, Size = 20,
},
Debug = {
PrintBhopFires = false,
PrintEdgebug = true,
PrintSurf = false,
PrintGlide = false,
},
}
-- ── state ─────────────────────────────────────────────────────────────────
local Connections = {}
local Drawings = {}
local BhopState = {FireCount = 0, LastFire = 0}
local EdgeBugState = {LastTrigger = 0, Active = false, TriggerCount = 0}
local SurfState = {Active = false, Frames = 0}
local GlideState = {Active = false, Frames = 0, LastPush = 0}
local VelHistory = {LastPos = nil, LastTime = 0, Smoothed = 0, Peak = 0, PeakTime = 0}
-- ── drawing ───────────────────────────────────────────────────────────────
local function makeDrawing(kind, props)
local d = Drawing.new(kind)
for k, v in pairs(props) do d[k] = v end
Drawings[#Drawings + 1] = d
return d
end
local VelText = makeDrawing("Text", {Size = 20, Center = false, Outline = true, Font = 2, Color = Color3.fromRGB(255,255,255), Visible = false})
local PeakText = makeDrawing("Text", {Size = 18, Center = false, Outline = true, Font = 2, Color = Color3.fromRGB(180,180,255), Visible = false})
local StateText = makeDrawing("Text", {Size = 16, Center = false, Outline = true, Font = 2, Color = Color3.fromRGB(180,255,180), Visible = false})
-- ── helpers ───────────────────────────────────────────────────────────────
local function getLocalParts()
local char = LocalPlayer.Character
if not char then return nil end
local hrp = char:FindFirstChild("HumanoidRootPart")
if not hrp then return nil end
return char, hrp
end
local groundParams = RaycastParams.new()
groundParams.FilterType = Enum.RaycastFilterType.Exclude
groundParams.IgnoreWater = true
local function isGrounded(char, hrp)
groundParams.FilterDescendantsInstances = {char, Camera}
local r = workspace:Raycast(hrp.Position - Vector3.new(0, 1.5, 0),
Vector3.new(0, -2.5, 0), groundParams)
return r ~= nil
end
local function isOverLedge(char, hrp)
groundParams.FilterDescendantsInstances = {char, Camera}
if workspace:Raycast(hrp.Position, Vector3.new(0, -6, 0), groundParams) then
return false
end
local hits = 0
for _, off in ipairs({Vector3.new(1.2,0,0), Vector3.new(-1.2,0,0), Vector3.new(0,0,1.2), Vector3.new(0,0,-1.2)}) do
if workspace:Raycast(hrp.Position + off, Vector3.new(0, -8, 0), groundParams) then
hits = hits + 1
end
end
return hits >= 2
end
-- scan 8 directions around the HRP for a nearby surface hit
local function scanSurfaces(char, hrp, dist)
groundParams.FilterDescendantsInstances = {char, Camera}
local dirs = {
Vector3.new(1,0,0), Vector3.new(-1,0,0),
Vector3.new(0,0,1), Vector3.new(0,0,-1),
Vector3.new(1,0,1).Unit, Vector3.new(-1,0,1).Unit,
Vector3.new(1,0,-1).Unit, Vector3.new(-1,0,-1).Unit,
}
local results = {}
for _, dir in ipairs(dirs) do
local r = workspace:Raycast(hrp.Position, dir * dist, groundParams)
if r then
results[#results+1] = {
normal = r.Normal,
position = r.Position,
instance = r.Instance,
direction = dir,
}
end
end
return results
end
-- ── bhop ──────────────────────────────────────────────────────────────────
local function bhopStep()
if not Config.Bhop.Enabled then return end
if not UserInputService:IsKeyDown(Config.Bhop.Key) then return end
local char, hrp = getLocalParts()
if not char or not hrp then return end
if char:GetAttribute("Dead") then return end
local now = os.clock()
if now - BhopState.LastFire < Config.Bhop.MinDelay then return end
if not isGrounded(char, hrp) then return end
local ok, err = pcall(function() CharacterController.jump() end)
if not ok then
warn("[bhop] jump() error:", err)
return
end
BhopState.LastFire = now
BhopState.FireCount = BhopState.FireCount + 1
if Config.Debug.PrintBhopFires then
print(string.format("[bhop] fired #%d", BhopState.FireCount))
end
end
-- ── auto edgebug ─────────────────────────────────────────────────────────
local function edgeBugStep()
if not Config.EdgeBug.Enabled then return end
local char, hrp = getLocalParts()
if not char or not hrp then return end
if char:GetAttribute("Dead") then return end
if isGrounded(char, hrp) then
EdgeBugState.Active = false
return
end
local vel = hrp.AssemblyLinearVelocity
if vel.Y > -Config.EdgeBug.MinFallSpeed then return end
local now = os.clock()
if now - EdgeBugState.LastTrigger < Config.EdgeBug.Cooldown then return end
if not isOverLedge(char, hrp) then return end
hrp.AssemblyLinearVelocity = Vector3.new(vel.X, 0, vel.Z)
EdgeBugState.LastTrigger = now
EdgeBugState.Active = true
EdgeBugState.TriggerCount = EdgeBugState.TriggerCount + 1
if Config.Debug.PrintEdgebug then
print(string.format("[edgebug] #%d vy=%.2f", EdgeBugState.TriggerCount, vel.Y))
end
end
-- ── pixel surf ────────────────────────────────────────────────────────────
-- when a wall/slanted surface is nearby, project velocity onto the surface
-- plane and keep the magnitude. gives the slide feel.
local function pixelSurfStep()
if not Config.PixelSurf.Enabled then return end
local char, hrp = getLocalParts()
if not char or not hrp then return end
if char:GetAttribute("Dead") then return end
local vel = hrp.AssemblyLinearVelocity
local horizSpeed = math.sqrt(vel.X * vel.X + vel.Z * vel.Z)
if horizSpeed < Config.PixelSurf.MinSpeed then
SurfState.Active = false
return
end
local surfaces = scanSurfaces(char, hrp, Config.PixelSurf.ContactDist)
if #surfaces == 0 then
SurfState.Active = false
return
end
-- combine all surfaces into one averaged plane
local n = Vector3.new(0, 0, 0)
for _, s in ipairs(surfaces) do
-- ignore surfaces too flat to be walls (dot with up < threshold)
if math.abs(s.normal.Y) <= Config.PixelSurf.MinNormalY then
n = n + s.normal
end
end
if n.Magnitude < 0.01 then
SurfState.Active = false
return
end
n = n.Unit
-- project velocity onto the surface plane (remove component into wall)
local into = vel:Dot(n)
local projected = vel - (n * into)
-- keep horizontal magnitude, preserve vertical a bit
local newVel = projected * Config.PixelSurf.Retention
newVel = Vector3.new(newVel.X, math.min(newVel.Y, vel.Y * 0.9), newVel.Z)
hrp.AssemblyLinearVelocity = newVel
SurfState.Active = true
SurfState.Frames = SurfState.Frames + 1
if Config.Debug.PrintSurf and SurfState.Frames % 10 == 0 then
print(string.format("[surf] frames=%d hspeed=%.1f", SurfState.Frames, horizSpeed))
end
end
-- ── wall glide ────────────────────────────────────────────────────────────
-- when pressed against a vertical surface while airborne, cancel most of
-- vertical velocity and push horizontally along the wall.
local function wallGlideStep()
if not Config.WallGlide.Enabled then return end
local char, hrp = getLocalParts()
if not char or not hrp then return end
if char:GetAttribute("Dead") then return end
if isGrounded(char, hrp) then
GlideState.Active = false
return
end
local vel = hrp.AssemblyLinearVelocity
local horizSpeed = math.sqrt(vel.X * vel.X + vel.Z * vel.Z)
if horizSpeed < Config.WallGlide.MinSpeed then
GlideState.Active = false
return
end
local surfaces = scanSurfaces(char, hrp, Config.WallGlide.ContactDist)
-- find the most "wall-like" surface: normal is mostly horizontal
local best = nil
local bestDot = 0.5
for _, s in ipairs(surfaces) do
local walliness = 1 - math.abs(s.normal.Y)
if walliness > bestDot then
bestDot = walliness
best = s
end
end
if not best then
GlideState.Active = false
return
end
-- cancel part of the vertical fall
local newY = vel.Y * (1 - Config.WallGlide.CancelFactor)
-- push horizontally along the wall (perpendicular to normal, in the
-- direction of current horizontal velocity)
local horizDir = Vector3.new(vel.X, 0, vel.Z)
if horizDir.Magnitude > 0.01 then
horizDir = horizDir.Unit
-- remove any component that pushes into the wall
local into = horizDir:Dot(best.normal)
horizDir = (horizDir - best.normal * into)
if horizDir.Magnitude > 0.01 then
horizDir = horizDir.Unit
local push = horizDir * Config.WallGlide.PushSpeed
hrp.AssemblyLinearVelocity = Vector3.new(vel.X + push.X, newY, vel.Z + push.Z)
GlideState.Active = true
GlideState.Frames = GlideState.Frames + 1
if Config.Debug.PrintGlide and GlideState.Frames % 10 == 0 then
print(string.format("[glide] frames=%d vy=%.2f", GlideState.Frames, newY))
end
return
end
end
hrp.AssemblyLinearVelocity = Vector3.new(vel.X, newY, vel.Z)
GlideState.Active = true
GlideState.Frames = GlideState.Frames + 1
end
-- ── counter ───────────────────────────────────────────────────────────────
local function updateCounter()
local char, hrp = getLocalParts()
if not hrp then
VelText.Visible = false
PeakText.Visible = false
StateText.Visible = false
return
end
local now = os.clock()
if VelHistory.LastPos and VelHistory.LastTime > 0 then
local dt = now - VelHistory.LastTime
if dt > 0 then
local dx = hrp.Position.X - VelHistory.LastPos.X
local dz = hrp.Position.Z - VelHistory.LastPos.Z
local raw = math.sqrt(dx*dx + dz*dz) / dt
VelHistory.Smoothed = VelHistory.Smoothed + (raw - VelHistory.Smoothed) * 0.35
end
end
VelHistory.LastPos = hrp.Position
VelHistory.LastTime = now
if VelHistory.Smoothed > VelHistory.Peak then
VelHistory.Peak = VelHistory.Smoothed
VelHistory.PeakTime = now
end
if now - VelHistory.PeakTime > 4 then
VelHistory.Peak = VelHistory.Smoothed
VelHistory.PeakTime = now
end
VelText.Text = string.format("%.1f u/s", VelHistory.Smoothed)
VelText.Position = Vector2.new(Config.Counter.X, Config.Counter.Y)
VelText.Visible = true
PeakText.Text = string.format("peak: %.1f", VelHistory.Peak)
PeakText.Position = Vector2.new(Config.Counter.X, Config.Counter.Y + Config.Counter.Size + 2)
PeakText.Visible = true
local bits = {}
if char then
bits[#bits+1] = isGrounded(char, hrp) and "GROUND" or "AIR"
end
if BhopState.FireCount > 0 then bits[#bits+1] = "bh=" .. BhopState.FireCount end
if EdgeBugState.TriggerCount > 0 then bits[#bits+1] = "eb=" .. EdgeBugState.TriggerCount end
if SurfState.Active then bits[#bits+1] = "SURF" end
if GlideState.Active then bits[#bits+1] = "GLIDE" end
StateText.Text = table.concat(bits, " ")
StateText.Position = Vector2.new(Config.Counter.X, Config.Counter.Y + Config.Counter.Size * 2 + 4)
if GlideState.Active then
StateText.Color = Color3.fromRGB(100, 200, 255)
elseif SurfState.Active then
StateText.Color = Color3.fromRGB(255, 220, 100)
elseif EdgeBugState.Active then
StateText.Color = Color3.fromRGB(255, 180, 80)
else
StateText.Color = Color3.fromRGB(180, 255, 180)
end
StateText.Visible = true
end
-- ── unload ────────────────────────────────────────────────────────────────
local function unload()
print("[DeepHat-Debug] Unloading...")
RunService:UnbindFromRenderStep("DeepHatBhop")
RunService:UnbindFromRenderStep("DeepHatCounter")
for _, c in ipairs(Connections) do pcall(function() c:Disconnect() end) end
table.clear(Connections)
for _, d in ipairs(Drawings) do pcall(function() d.Visible = false; d:Remove() end) end
table.clear(Drawings)
print("[DeepHat-Debug] Unloaded.")
end
-- ── init ──────────────────────────────────────────────────────────────────
local function initialize()
print("[DeepHat-Debug] init")
if Config.Bhop.Enabled then
RunService:BindToRenderStep("DeepHatBhop",
Enum.RenderPriority.Last.Value, bhopStep)
end
if Config.Counter.Enabled then
RunService:BindToRenderStep("DeepHatCounter",
Enum.RenderPriority.Last.Value + 1, updateCounter)
end
-- surface features run on Heartbeat so they see the post-physics state
Connections[#Connections + 1] = RunService.Heartbeat:Connect(function(dt)
pcall(edgeBugStep, dt)
pcall(pixelSurfStep, dt)
pcall(wallGlideStep, dt)
end)
Connections[#Connections + 1] = UserInputService.InputBegan:Connect(function(input, processed)
if processed then return end
if input.KeyCode == Enum.KeyCode.End then unload() end
end)
print("[DeepHat-Debug] ready.")
print(" hold SPACE to bhop")
print(" edgebug, pixel surf, and wall glide are automatic")
end
task.spawn(function()
task.wait(0.5)
initialize()
end)About this script
WallHack, broken bhop idk if working EB
