--========================================================--
-- BETTER DAMAGE SYSTEM
-- SIMPLE / STABLE CLIENT VERSION
-- R6 + R15
--========================================================--

local Players = game:GetService("Players")
local SoundService = game:GetService("SoundService")
local TweenService = game:GetService("TweenService")
local Debris = game:GetService("Debris")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer

print("================================")
print("[BETTER DAMAGE] SCRIPT STARTED")
print("Player:", player.Name)
print("================================")

--========================================================--
-- SETTINGS
--========================================================--

local DAMAGE_HITS = 10

local NORMAL_SPEED = 16
local WEAK_SPEED = 5

local WEAK_DAMAGE = 3
local WEAK_DAMAGE_TIME = 10

local REST_TIME = 5

local RAGDOLL_TIME = 2.5

local BLOOD_COUNT = 12

--========================================================--
-- SOUNDS
--========================================================--

local STARTUP_SOUND = "rbxassetid://5153734608"

local WARNING_SOUND = "rbxassetid://3289150551"

local BLOOD_SOUND = "rbxassetid://3626677712"

local DEATH_SOUND = "rbxassetid://9118864035"

-- Human-style scream pack
local SCREAMS = {
"rbxassetid://880159023",
"rbxassetid://58520081",
"rbxassetid://170399891"
}

--========================================================--
-- CHARACTER VARIABLES
--========================================================--

local character = nil
local humanoid = nil
local root = nil

local healthConnection = nil
local diedConnection = nil

local oldHealth = nil

local damageCount = 0

local isWeak = false

local weakTimer = 0
local restTimer = 0

local applyingWeakDamage = false

local isRagdoll = false
local deathPlayed = false

local lastScream = 0

--========================================================--
-- GUI
--========================================================--

local gui = Instance.new("ScreenGui")
gui.Name = "BetterDamageGui"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.Parent = player:WaitForChild("PlayerGui")

--========================================================--
-- ACTIVE TEXT
--========================================================--

local activeText = Instance.new("TextLabel")

activeText.Name = "ActiveText"
activeText.Size = UDim2.new(0.95, 0, 0, 65)
activeText.Position = UDim2.new(0.025, 0, 0.06, 0)

activeText.BackgroundTransparency = 1

activeText.Text =
"better damage script is active have fun son🤣✌️"

activeText.TextScaled = true
activeText.TextWrapped = true

activeText.Font = Enum.Font.GothamBold
activeText.TextStrokeTransparency = 0

activeText.Parent = gui

-- Rainbow effect
task.spawn(function()

local hue = 0  

while activeText.Parent do  

	hue += 0.015  

	if hue >= 1 then  
		hue = 0  
	end  

	activeText.TextColor3 =  
		Color3.fromHSV(hue, 1, 1)  

	task.wait(0.03)  

end

end)

--========================================================--
-- WARNING
--========================================================--

local warning = Instance.new("TextLabel")

warning.Name = "Warning"

warning.Size = UDim2.new(0.9, 0, 0, 115)
warning.Position = UDim2.new(0.05, 0, 0.18, 0)

warning.BackgroundColor3 =
Color3.fromRGB(25, 25, 25)

warning.BackgroundTransparency = 0.1

warning.Text =
"warning:this script is not FE\n" ..
"like ragdoll, sound, blood\n" ..
"only the damage are FE"

warning.TextColor3 =
Color3.fromRGB(255, 60, 60)

warning.TextScaled = true
warning.TextWrapped = true

warning.Font = Enum.Font.GothamBold
warning.TextStrokeTransparency = 0.5

warning.Visible = false

warning.Parent = gui

local warningCorner =
Instance.new("UICorner")

warningCorner.CornerRadius =
UDim.new(0, 12)

warningCorner.Parent = warning

--========================================================--
-- WEAK TEXT
--========================================================--

local weakText = Instance.new("TextLabel")

weakText.Name = "WeakText"

weakText.Size =
UDim2.new(0.9, 0, 0, 110)

weakText.Position =
UDim2.new(0.05, 0, 0.30, 0)

weakText.BackgroundTransparency = 1

weakText.Text =
"⚠ WEAK ⚠\nREST TO RECOVER"

weakText.TextColor3 =
Color3.fromRGB(255, 45, 45)

weakText.TextStrokeTransparency = 0

weakText.TextScaled = true
weakText.TextWrapped = true

weakText.Font = Enum.Font.GothamBold

weakText.Visible = false

weakText.Parent = gui

--========================================================--
-- REST BAR
--========================================================--

local restBack = Instance.new("Frame")

restBack.Name = "RestBar"

restBack.Size =
UDim2.new(0.7, 0, 0, 18)

restBack.Position =
UDim2.new(0.15, 0, 0.44, 0)

restBack.BackgroundColor3 =
Color3.fromRGB(45, 45, 45)

restBack.BorderSizePixel = 0

restBack.Visible = false

restBack.Parent = gui

local restBackCorner =
Instance.new("UICorner")

restBackCorner.CornerRadius =
UDim.new(1, 0)

restBackCorner.Parent =
restBack

local restFill = Instance.new("Frame")

restFill.Name = "Fill"

restFill.Size =
UDim2.new(0, 0, 1, 0)

restFill.BackgroundColor3 =
Color3.fromRGB(255, 60, 60)

restFill.BorderSizePixel = 0

restFill.Parent = restBack

local restFillCorner =
Instance.new("UICorner")

restFillCorner.CornerRadius =
UDim.new(1, 0)

restFillCorner.Parent =
restFill

--========================================================--
-- DEATH RED SCREEN
--========================================================--

local deathScreen = Instance.new("Frame")

deathScreen.Name = "DeathScreen"

deathScreen.Size =
UDim2.new(1, 0, 1, 0)

deathScreen.Position =
UDim2.new(0, 0, 0, 0)

deathScreen.BackgroundColor3 =
Color3.fromRGB(180, 0, 0)

deathScreen.BackgroundTransparency = 1

deathScreen.BorderSizePixel = 0

deathScreen.ZIndex = 100

deathScreen.Visible = false

deathScreen.Parent = gui

--========================================================--
-- SOUND FUNCTION
--========================================================--

local function playSound(id, volume, speed)

local sound = Instance.new("Sound")  

sound.SoundId = id  

sound.Volume = volume or 1  

sound.PlaybackSpeed = speed or 1  

sound.Looped = false  

sound.Parent = SoundService  

SoundService:PlayLocalSound(sound)  

Debris:AddItem(sound, 8)  

return sound

end

--========================================================--
-- STARTUP SEQUENCE
--========================================================--

task.spawn(function()

task.wait(0.2)  

print("[BETTER DAMAGE] Playing startup")  

playSound(  
	STARTUP_SOUND,  
	1,  
	1  
)  

task.wait(3)  

if activeText then  
	activeText.Visible = false  
end  

-- User requested one-second delay.  
task.wait(1)  

if warning then  

	warning.Visible = true  

	print("[BETTER DAMAGE] Warning shown")  

	playSound(  
		WARNING_SOUND,  
		1,  
		1  
	)  

	task.wait(4)  

	warning.Visible = false  

end

end)

--========================================================--
-- SCREAM
--========================================================--

local function playScream()

if #SCREAMS == 0 then  
	return  
end  

local chosen  

if #SCREAMS == 1 then  

	chosen = 1  

else  

	repeat  

		chosen =  
			math.random(  
				1,  
				#SCREAMS  
			)  

	until chosen ~= lastScream  

end  

lastScream = chosen  

print(  
	"[BETTER DAMAGE] Playing scream",  
	chosen  
)  

playSound(  
	SCREAMS[chosen],  
	1,  
	1  
)

end

--========================================================--
-- BLOOD
--========================================================--

local function makeBlood()

if not root then  
	return  
end  

print("[BETTER DAMAGE] Blood")  

-- Blood sound  
playSound(  
	BLOOD_SOUND,  
	0.7,  
	2.5  
)  

for i = 1, BLOOD_COUNT do  

	local blood =  
		Instance.new("Part")  

	blood.Name =  
		"ClientBlood"  

	blood.Shape =  
		Enum.PartType.Ball  

	local size =  
		math.random(25, 60) / 100  

	blood.Size =  
		Vector3.new(  
			size,  
			size,  
			size  
		)  

	blood.Color =  
		Color3.fromRGB(  
			145,  
			0,  
			0  
		)  

	blood.Material =  
		Enum.Material.SmoothPlastic  

	blood.CanCollide = true  
	blood.CanTouch = true  
	blood.CanQuery = false  

	blood.Massless = false  

	blood.CFrame =  
		root.CFrame *  
		CFrame.new(  
			math.random(-15,15) / 10,  
			math.random(-10,15) / 10,  
			math.random(-15,15) / 10  
		)  

	blood.Parent = workspace  

	local velocity =  
		Instance.new("BodyVelocity")  

	velocity.MaxForce =  
		Vector3.new(  
			5000,  
			5000,  
			5000  
		)  

	velocity.Velocity =  
		Vector3.new(  
			math.random(-20,20),  
			math.random(8,22),  
			math.random(-20,20)  
		)  

	velocity.Parent = blood  

	Debris:AddItem(  
		velocity,  
		0.12  
	)  

	Debris:AddItem(  
		blood,  
		7  
	)  

end

end

--========================================================--
-- RAGDOLL
--========================================================--

local function ragdoll()

if isRagdoll then  
	return  
end  

if not character or not humanoid then  
	return  
end  

if humanoid.Health <= 0 then  
	return  
end  

isRagdoll = true  

print("[BETTER DAMAGE] Ragdoll")  

-- Save motors.  
local motors = {}  

-- Create constraints.  
for _, obj in ipairs(  
	character:GetDescendants()  
) do  

	if obj:IsA("Motor6D")  
		and obj.Part0  
		and obj.Part1 then  

		-- Don't break the root joint.  
		if obj.Name ~= "RootJoint" then  

			local part0 = obj.Part0  
			local part1 = obj.Part1  

			local att0 =  
				Instance.new("Attachment")  

			local att1 =  
				Instance.new("Attachment")  

			att0.CFrame = obj.C0  
			att1.CFrame = obj.C1  

			att0.Parent = part0  
			att1.Parent = part1  

			local socket =  
				Instance.new(  
					"BallSocketConstraint"  
				)  

			socket.Attachment0 = att0  
			socket.Attachment1 = att1  

			socket.LimitsEnabled = true  
			socket.UpperAngle = 70  

			socket.TwistLimitsEnabled = true  
			socket.TwistLowerAngle = -45  
			socket.TwistUpperAngle = 45  

			socket.Parent = part0  

			table.insert(  
				motors,  
				{  
					motor = obj,  
					attachment0 = att0,  
					attachment1 = att1,  
					socket = socket  
				}  
			)  

			obj.Enabled = false  

		end  
	end  

end  

-- Make every body part collide.  
for _, obj in ipairs(  
	character:GetDescendants()  
) do  

	if obj:IsA("BasePart") then  

		obj.CanCollide = true  
		obj.CanTouch = true  
		obj.Massless = false  

	end  

end  

humanoid.PlatformStand = true  

pcall(function()  
	humanoid.AutoRotate = false  
end)  

-- Push the character slightly.  
if root then  

	root.AssemblyLinearVelocity =  
		Vector3.new(  
			math.random(-8,8),  
			10,  
			math.random(-8,8)  
		)  

end  

-- Recover.  
task.delay(  
	RAGDOLL_TIME,  
	function()  

		if not character  
			or not character.Parent then  

			return  
		end  

		for _, data in ipairs(motors) do  

			if data.motor  
				and data.motor.Parent then  

				data.motor.Enabled = true  

			end  

			if data.attachment0 then  
				data.attachment0:Destroy()  
			end  

			if data.attachment1 then  
				data.attachment1:Destroy()  
			end  

			if data.socket then  
				data.socket:Destroy()  
			end  

		end  

		if humanoid  
			and humanoid.Parent  
			and humanoid.Health > 0 then  

			humanoid.PlatformStand = false  

			pcall(function()  
				humanoid.AutoRotate = true  
			end)  

			humanoid:ChangeState(  
				Enum.HumanoidStateType.GettingUp  
			)  

		end  

		-- Turn collision back off  
		-- so normal Roblox movement returns.  
		for _, obj in ipairs(  
			character:GetDescendants()  
		) do  

			if obj:IsA("BasePart") then  

				if obj.Name == "HumanoidRootPart" then  
					obj.CanCollide = false  
				else  
					obj.CanCollide = false  
				end  

			end  

		end  

		isRagdoll = false  

		print(  
			"[BETTER DAMAGE] Ragdoll ended"  
		)  

	end  
)

end

--========================================================--
-- DEATH EFFECT
--========================================================--

local function deathEffect()

if deathPlayed then  
	return  
end  

deathPlayed = true  

print("[BETTER DAMAGE] DEATH")  

playSound(  
	DEATH_SOUND,  
	1,  
	1  
)  

deathScreen.Visible = true  

deathScreen.BackgroundTransparency = 1  

local tween =  
	TweenService:Create(  
		deathScreen,  

		TweenInfo.new(  
			2.5,  
			Enum.EasingStyle.Quad,  
			Enum.EasingDirection.Out  
		),  

		{  
			BackgroundTransparency = 0.25  
		}  
	)  

tween:Play()

end

--========================================================--
-- ENTER WEAK
--========================================================--

local function enterWeak()

if isWeak then  
	return  
end  

isWeak = true  

weakTimer = 0  
restTimer = 0  

weakText.Visible = true  
restBack.Visible = true  

restFill.Size =  
	UDim2.new(  
		0,  
		0,  
		1,  
		0  
	)  

if humanoid then  
	humanoid.WalkSpeed =  
		WEAK_SPEED  
end  

print(  
	"[BETTER DAMAGE] WEAKNESS ACTIVATED"  
)

end

--========================================================--
-- RECOVER
--========================================================--

local function recover()

isWeak = false  

damageCount = 0  

weakTimer = 0  
restTimer = 0  

weakText.Visible = false  
restBack.Visible = false  

restFill.Size =  
	UDim2.new(  
		0,  
		0,  
		1,  
		0  
	)  

if humanoid  
	and humanoid.Health > 0 then  

	humanoid.WalkSpeed =  
		NORMAL_SPEED  

end  

print(  
	"[BETTER DAMAGE] RECOVERED"  
)

end

--========================================================--
-- WEAKNESS LOOP
--========================================================--

task.spawn(function()

while true do  

	task.wait(0.1)  

	if isWeak  
		and humanoid  
		and humanoid.Parent  
		and humanoid.Health > 0 then  

		-- Weak damage timer.  
		weakTimer += 0.1  

		if weakTimer >=  
			WEAK_DAMAGE_TIME then  

			weakTimer = 0  

			applyingWeakDamage = true  

			humanoid.Health =  
				math.max(  
					0,  
					humanoid.Health -  
					WEAK_DAMAGE  
				)  

			applyingWeakDamage = false  

			print(  
				"[BETTER DAMAGE] " ..  
				"Weak damage -3"  
			)  

		end  

		-- Rest timer.  
		if humanoid.MoveDirection.Magnitude < 0.05 then  

			restTimer += 0.1  

		else  

			restTimer = 0  

		end  

		local percent =  
			math.clamp(  
				restTimer / REST_TIME,  
				0,  
				1  
			)  

		restFill.Size =  
			UDim2.new(  
				percent,  
				0,  
				1,  
				0  
			)  

		if restTimer >= REST_TIME then  

			recover()  

		end  

	end  

end

end)

--========================================================--
-- DAMAGE LISTENER
--========================================================--

local function connectHealth()

if healthConnection then  
	healthConnection:Disconnect()  
	healthConnection = nil  
end  

if diedConnection then  
	diedConnection:Disconnect()  
	diedConnection = nil  
end  

if not humanoid then  
	return  
end  

oldHealth =  
	humanoid.Health  

print(  
	"[BETTER DAMAGE] Health:",  
	oldHealth  
)  

healthConnection =  
	humanoid.HealthChanged:Connect(  
		function(newHealth)  

			print(  
				"[BETTER DAMAGE] HealthChanged:",  
				newHealth  
			)  

			-- Death.  
			if newHealth <= 0 then  

				deathEffect()  

				oldHealth =  
					newHealth  

				return  

			end  

			-- Ignore our automatic weak damage.  
			if applyingWeakDamage then  

				oldHealth =  
					newHealth  

				return  

			end  

			-- Damage happened.  
			if oldHealth  
				and newHealth < oldHealth then  

				local damage =  
					oldHealth -  
					newHealth  

				damageCount += 1  

				print(  
					"------------------------------"  
				)  

				print(  
					"[BETTER DAMAGE] DAMAGE!"  
				)  

				print(  
					"Amount:",  
					damage  
				)  

				print(  
					"Hits:",  
					damageCount,  
					"/",  
					DAMAGE_HITS  
				)  

				print(  
					"------------------------------"  
				)  

				oldHealth =  
					newHealth  

				-- Effects.  
				makeBlood()  

				playScream()  

				ragdoll()  

				-- Weakness.  
				if damageCount >=  
					DAMAGE_HITS then  

					enterWeak()  

				end  

			else  

				oldHealth =  
					newHealth  

			end  

		end  
	)  

diedConnection =  
	humanoid.Died:Connect(  
		function()  

			deathEffect()  

		end  
	)  

print(  
	"[BETTER DAMAGE] " ..  
	"HEALTH LISTENER CONNECTED"  
)

end

--========================================================--
-- CHARACTER SETUP
--========================================================--

local function setupCharacter(newCharacter)

print(  
	"[BETTER DAMAGE] Character detected"  
)  

character =  
	newCharacter  

humanoid =  
	character:WaitForChild(  
		"Humanoid",  
		10  
	)  

root =  
	character:WaitForChild(  
		"HumanoidRootPart",  
		10  
	)  

if not humanoid then  

	warn(  
		"[BETTER DAMAGE] " ..  
		"Humanoid NOT FOUND"  
	)  

	return  

end  

if not root then  

	warn(  
		"[BETTER DAMAGE] " ..  
		"Root NOT FOUND"  
	)  

	return  

end  

-- Reset.  
damageCount = 0  

isWeak = false  

weakTimer = 0  
restTimer = 0  

applyingWeakDamage = false  

isRagdoll = false  
deathPlayed = false  

weakText.Visible = false  
restBack.Visible = false  

deathScreen.Visible = false  
deathScreen.BackgroundTransparency = 1  

humanoid.WalkSpeed =  
	NORMAL_SPEED  

connectHealth()  

print(  
	"[BETTER DAMAGE] CHARACTER READY"  
)

end

--========================================================--
-- INITIAL CHARACTER
--========================================================--

if player.Character then

task.spawn(function()  

	setupCharacter(  
		player.Character  
	)  

end)

end

--========================================================--
-- RESPAWN
--========================================================--

player.CharacterAdded:Connect(
function(newCharacter)

task.wait(0.2)  

	setupCharacter(  
		newCharacter  
	)  

end

)

print(
"================================"
)

print(
"[BETTER DAMAGE] READY!"
)

print(
"[BETTER DAMAGE] R6/R15"
)

print(
"[BETTER DAMAGE] Blood: ON"
)

print(
"[BETTER DAMAGE] Ragdoll: ON"
)

print(
"[BETTER DAMAGE] Screams: 3"
)

print(
"================================"
)