Grip and Carry [Server Script]

local RS = game:GetService("ReplicatedStorage")
local CS = game:GetService("CollectionService")
local RunService = game:GetService("RunService")

local Params = OverlapParams.new()
Params.FilterType = Enum.RaycastFilterType.Blacklist

local Toggle = {}
local Health = {}
local Trash = {}
local MainEvent = {}
local IsCarried = {};
local EnemyVar = {}
local EnemyAnim = {};
local Weld = {}
local stopService = {}
local v1 = {};
local v2 = {};

local Health_Limit = 6
local WaitKnockUp = 5

local function characterAdded(Player)
	local Character = Player.Character or Player.CharacterAdded:Wait()
	local Humanoid = Character.Humanoid
	Humanoid:GetPropertyChangedSignal("Health"):Connect(function()
		if stopService[Player] then return end
		if CS:HasTag(Character, "Ragdoll") then return end
		if Health_Limit >= Humanoid.Health then
			Humanoid.Health = Health_Limit
			CS:AddTag(Character, "Ragdoll")
		end
	end)

	local Event = nil
	Humanoid.HealthChanged:Connect(function()
		if stopService[Player] then return end
		if not CS:HasTag(Character, "Ragdoll") then return end
		if Event then return end
		local Start = tick()
		Event = RunService.Heartbeat:Connect(function()
			if not CS:HasTag(Character, "Ragdoll") then
				Event:Disconnect()
				Event = nil
			end
			if tick() - Start >= WaitKnockUp then
				print(v1[Player], v2[Player])
				if v1[Player.Character] then
					v1[Player.Character]:Destroy()
					v1[Player.Character] = nil
				end

				if v2[Player.Character] then
					v2[Player.Character]:Destroy()
					v2[Player.Character] = nil
				end
				--Player:WaitForChild("TrueNum").Value = true
				Character.Humanoid.PlatformStand = false;
				CS:RemoveTag(Character, "Ragdoll")
				Event:Disconnect()
				Event = nil
			end
		end)
	end)
end

game.Players.PlayerAdded:Connect(function(Player)
	local IsGripping = Instance.new("BoolValue", Player)
	IsGripping.Name = "IsGripping";
	IsGripping.Value = false;

	local IsCarried = Instance.new("BoolValue", Player)
	IsCarried.Name = "IsCarried"
	IsCarried.Value = false;

	--local TrueNum = Instance.new("BoolValue", Player);
	--TrueNum.Name = "TrueNum";
	--TrueNum.Value = false;

	characterAdded(Player)
	Player.CharacterAdded:Connect(function()
		characterAdded(Player)
	end)
end)

local function Movement(Humanoid, WalkSpeed, JumpPower) -- Adjust Movement
	Humanoid.WalkSpeed = WalkSpeed;
	Humanoid.JumpPower = JumpPower;
end

local function isTrash(Character)
	for i,v in pairs(Trash) do
		if v == Character then
			return true
		end
	end
	return false
end

-- [ Checks For Any Player Within a certain radius and check if they are not ragdolled ]

local function findEnemyWithInRadius(Radius: number, Player: Player)
	local Character = Player.Character or Player.CharacterAdded:Wait();
	local HRP = Character.HumanoidRootPart
	local ENECHAR = nil
	local ENEPLR = nil

	Params.FilterDescendantsInstances = {Character} -- Ignore whatever is in table

	for Index, Value in pairs(workspace:GetPartBoundsInRadius(HRP.Position, Radius, Params)) do
		local Humanoid = Value.Parent:FindFirstChild("Humanoid")
		if Humanoid and Humanoid.Health > 0 and not isTrash(Value.Parent) then
			local EnemyCharacter = Value.Parent -- Enemy Character
			ENEPLR = game.Players:GetPlayerFromCharacter(EnemyCharacter);
			local ENECHAR = EnemyCharacter
			if CS:HasTag(EnemyCharacter, "Ragdoll") then
				return true, ENEPLR, EnemyCharacter; -- they are ragdolled return, true, the player and char
			end
		end
	end
	return false, ENEPLR, ENECHAR
end

function massChecker(Player:Player, EnemyCharacter:Model)
	local massv1 = Instance.new("BoolValue")
	for i,v in pairs(Player.Character:GetChildren()) do
		if not v:IsA("Part") then continue end
		massv1.Value = v.Massless
	end

	massv1.Changed:Connect(function()
		if Weld[Player] then
			massv1.Value = true
		else
			massv1.Value = false
		end
	end)
end

function connectPlayers(EnemyCharacter, Player) -- Welds them, positions them, and plays animation
	Trash[Player] = EnemyCharacter
	local Character = Player.Character
	if v1[EnemyCharacter] then
		v1[EnemyCharacter]:Destroy()
		v1[EnemyCharacter] = nil
	end

	if v2[EnemyCharacter] then
		v2[EnemyCharacter]:Destroy()
		v2[EnemyCharacter] = nil
	end

	local weldCon = Instance.new("WeldConstraint", Character.HumanoidRootPart);
	weldCon.Name = "weldConTemp"

	local EHRP = EnemyCharacter.HumanoidRootPart
	local HRP = Character.HumanoidRootPart

	EHRP.CFrame = HRP.CFrame * CFrame.new(-1.5,1.2,0) * CFrame.Angles(math.rad(270),0,0) -- (-1.5,.4,-1.5)
	weldCon.Part0 = HRP;
	weldCon.Part1 = EHRP

	for i,v in pairs(EnemyCharacter:GetDescendants()) do
		if not v:IsA("BasePart") then continue end
		v.Massless = true
	end

	Weld[Player] = weldCon
	CS:RemoveTag(EnemyCharacter, "Ragdoll")

	EnemyCharacter.Humanoid.PlatformStand = true;
end

function disconnectPlayer(EnemyCharacter, Player)
	Trash[Player] = nil
	Weld[Player]:Destroy()
	Weld[Player] = nil

	for i,v in pairs(EnemyCharacter:GetDescendants()) do
		if not v:IsA("BasePart") then continue end
		v.Massless = false
	end

	local floorPart = Instance.new("Part",workspace)
	floorPart.Name = "floorPart"
	floorPart.Anchored = true;
	floorPart.CanCollide = false;
	floorPart.Transparency = 1;

	EnemyCharacter.HumanoidRootPart.CFrame = Player.Character.HumanoidRootPart.CFrame * CFrame.new(0,0,-3)
	floorPart.CFrame = EnemyCharacter.HumanoidRootPart.CFrame * CFrame.new(0,-2.3,0);

	local weldToFloor = Instance.new("Weld",EnemyCharacter.HumanoidRootPart)
	weldToFloor.Name = "weldToFloor"
	weldToFloor.Part0 = EnemyCharacter.HumanoidRootPart
	weldToFloor.Part1 = floorPart

	v1[EnemyCharacter] = floorPart;
	v2[EnemyCharacter] = weldToFloor

	CS:AddTag(EnemyCharacter, "Ragdoll")
	EnemyCharacter.Humanoid.PlatformStand = false;
end

game.Players.PlayerAdded:Connect(function(Player)
	Player.CharacterAdded:Connect(function()
		stopService[Player] = false;

		if CS:HasTag(Player.Character,"Ragdoll") then
			CS:RemoveTag(Player.Character,"Ragdoll")
		end
	end)
end)

RS.KillEvent.OnServerEvent:Connect(function(Player)
	print(IsCarried[Player])
	if IsCarried[Player] then return end
	local Start = tick();
	local IsGrippin = Player:WaitForChild("IsGripping");

	local GripDuration = 2; -- Gripuration

	local InArea, EnemyPlayer, EnemyCharacter = findEnemyWithInRadius(7, Player)
	if InArea and not Toggle[Player] then
		local gripAni = Player.Character.Humanoid:LoadAnimation(game.ReplicatedStorage.Animation.GripAnimation);
		gripAni:Play()
		Player.Character.HumanoidRootPart.CFrame = Player.Character.HumanoidRootPart.CFrame * CFrame.Angles(0,math.pi,0)
		Toggle[Player] = true --Now gripping
		IsGrippin.Value = true
		Trash[Player] = EnemyCharacter
		Movement(Player.Character:WaitForChild("Humanoid"),0,0)
		print("Grip")
		MainEvent[Player] = RunService.Heartbeat:Connect(function()
			if (tick() - Start >= GripDuration) then-- wait until tick() - start is greater than gripduration
				print("Ungrip")
				stopService[Player] = true
				EnemyCharacter.Humanoid.Health = 0; -- When the grip is done player dies
				Toggle[Player] = nil -- resets toggle
				IsGrippin.Value = false; -- resets to false
				MainEvent[Player]:Disconnect();
				MainEvent[Player] = nil
				Trash[Player] = nil
				Movement(Player.Character:WaitForChild("Humanoid"),16,50)
			end

		end)
		return
	end

	if Toggle[Player] then
		print("Canceled Grip")
		Movement(Player.Character:WaitForChild("Humanoid"),16,50)
		if (MainEvent[Player]) then
			MainEvent[Player]:Disconnect();
			MainEvent[Player] = nil
		end
		Trash[Player] = nil
		Toggle[Player] = nil
		IsGrippin.Value = false
	end

end)

RS.CarryEvent.OnServerEvent:Connect(function(Player)
	if Toggle[Player] then return end
	if IsCarried[Player] then
		disconnectPlayer(EnemyVar[Player], Player)
		massChecker(Player,EnemyVar[Player])
		IsCarried[Player] = nil
		EnemyAnim[Player]:Stop()
		print("Remove Massless")
		return
	end
	local InArea, EnemyPlayer, EnemyCharacter = findEnemyWithInRadius(7, Player)
	if not InArea then return end
	EnemyVar[Player] = EnemyCharacter
	EnemyAnim[Player] = EnemyVar[Player]:WaitForChild("Humanoid"):LoadAnimation(RS.Animation.CarryAnimation)

	connectPlayers(EnemyCharacter, Player)
	massChecker(Player,EnemyCharacter)
	print("Added Massless")
	IsCarried[Player] = true
	EnemyAnim[Player]:Play()
end)