REDTIGER

 Players = :()




 RunService = :()




 ReplicatedStorage = :()




 UserInputService = :()




 Workspace = :()




 VirtualUser = :()
 TweenService = :()


 _S = {}




 player = Players.LocalPlayer




 mouse = player:()




 camera = Workspace.CurrentCamera









_S.espEnabled = 




_S.speedEnabled = 




_S.flyEnabled = 




_S.spectatingPlayer = 




_S.selectedPlayer = 




_S.speedValue = 




_S.flySpeed = 




_S.flyVelocity = 



_S.flyGyro = 



_S.swimEnabled = 



_S.swimSpeed = 



_S.swimVelocity = 



_S.swimGyro = 



 keys = {}




_S.espObjects = {}




_S.teleportToolEquipped = 




_S.noclipEnabled = 
_S.spinEnabled = 
_S.spinSpeed = 




_S.afkEnabled = 




_S.afkStartTime = 




_S.afkTimerGui = 




_S.afkTimerLabel = 




_S.lockAllEnabled = 




_S.lockSelectedEnabled = 




_S.lockEnemyEnabled = 




_S.lockRanges = { all = .huge, sel = .huge, enemy = .huge }  




_S.lockProximityRange =  




_S.damageAutoLockTarget =  




_S.damageAutoLockExpire =  




_S.infiniteJumpEnabled = 




_S.tpAllActive = 




_S.tpSavePosEnabled = 




_S.tpSaveSimpleEnabled = 




_S.tpSaveAutoPosition = 




_S.tpSaveInterval = 




_S.xrayEnabled = 




_S.xraySavedTransparency = {}




_S.nightVisionEnabled = 




_S.nightVisionSavedLighting = {}




_S.savedBillboards = {}









_S.omegaRenderStepNames = {}




_S.omegaConnections = {}




_S.omegaGuiSnapshot = {}




_S.omegaCoreGuiSnapshot = {}




_S.omegaCreatedInstances = {}




_S.omegaForceResetConn = 

_S.rightMouseHeld = 




_S.omegaThreads = {}




_S.omegaKilled = 




_S.omegaCleanupGeneration = 




_S.omegaHasExecuted = 




_S.omegaHiddenStates = {}









 stopSpectate




 addBtnSound




 makeToggle




 spectateCharConn = 




 updateVolLabel




 applySpeed




 updateScale









  (parent, text, pos, size, color)




	 b = .()




	b.Size = size  .(, -, , )




	b.Position = pos




	b.BackgroundColor3 = _S.customBtnColor  .(, , )

	_S.allButtons = _S.allButtons  {}

	.(_S.allButtons, b)




	b.BackgroundTransparency = 




	b.Text = text




	b.TextColor3 = .(, , )




	b.Font = .Font.SourceSans




	b.TextSize = 




	b.TextTruncate = .TextTruncate.AtEnd




	b.BorderSizePixel = 




	b.Parent = parent




	.(, b).CornerRadius = .(, )




	 addBtnSound  (b) 




	 b














 gui = .()




gui.Name = 




gui.ResetOnSpawn = 




gui.ZIndexBehavior = .ZIndexBehavior.Sibling




gui.DisplayOrder = 




gui.Parent = player:()









 hoverSound = .()




hoverSound.SoundId = 




hoverSound.Volume = 




hoverSound.Parent = gui




 clickSound = .()




clickSound.SoundId = 




clickSound.Volume = 




clickSound.PlaybackSpeed = 




clickSound.Parent = gui









_S.afkTimerGui = .()




_S.afkTimerGui.Name = 




_S.afkTimerGui.ResetOnSpawn = 




_S.afkTimerGui.ZIndexBehavior = .ZIndexBehavior.Sibling




_S.afkTimerGui.DisplayOrder = 




_S.afkTimerGui.Parent = player:()




 afkTimerFrame = .()




afkTimerFrame.Size = .(, , , )




afkTimerFrame.Position = .(, , , )




afkTimerFrame.BackgroundColor3 = .(, , )




afkTimerFrame.BackgroundTransparency = 




afkTimerFrame.Visible = 




afkTimerFrame.Parent = _S.afkTimerGui




 afkTimerCorner = .()




afkTimerCorner.CornerRadius = .(, )




afkTimerCorner.Parent = afkTimerFrame




 afkTimerStroke = .()




afkTimerStroke.Color = .(, , )




afkTimerStroke.Thickness = 




afkTimerStroke.Transparency = 




afkTimerStroke.Parent = afkTimerFrame




 afkTimerGrad = .()




afkTimerGrad.Color = ColorSequence.(.(, , ), .(, , ))




afkTimerGrad.Rotation = 




afkTimerGrad.Parent = afkTimerFrame




 afkTimerPad = .()




afkTimerPad.PaddingLeft = .(, )




afkTimerPad.PaddingRight = .(, )




afkTimerPad.PaddingTop = .(, )




afkTimerPad.PaddingBottom = .(, )




afkTimerPad.Parent = afkTimerFrame




 afkIconLabel = .()




afkIconLabel.Size = .(, , , )




afkIconLabel.Position = .(, , , )




afkIconLabel.BackgroundTransparency = 




afkIconLabel.Text = 




afkIconLabel.TextColor3 = .(, , )




afkIconLabel.Font = .Font.SourceSansBold




afkIconLabel.TextSize = 




afkIconLabel.TextXAlignment = .TextXAlignment.Center




afkIconLabel.TextYAlignment = .TextYAlignment.Center




afkIconLabel.Parent = afkTimerFrame




_S.afkTimerLabel = .()




_S.afkTimerLabel.Size = .(, -, , )




_S.afkTimerLabel.Position = .(, , , )




_S.afkTimerLabel.BackgroundTransparency = 




_S.afkTimerLabel.Text = 




_S.afkTimerLabel.TextColor3 = .(, , )




_S.afkTimerLabel.Font = .Font.SourceSansBold




_S.afkTimerLabel.TextSize = 




_S.afkTimerLabel.TextXAlignment = .TextXAlignment.Left




_S.afkTimerLabel.TextYAlignment = .TextYAlignment.Center




_S.afkTimerLabel.Parent = afkTimerFrame




 afkStatusLabel = .()




afkStatusLabel.Size = .(, -, , )




afkStatusLabel.Position = .(, , , )




afkStatusLabel.BackgroundTransparency = 




afkStatusLabel.Text = 




afkStatusLabel.TextColor3 = .(, , )




afkStatusLabel.Font = .Font.SourceSans




afkStatusLabel.TextSize = 




afkStatusLabel.TextXAlignment = .TextXAlignment.Left




afkStatusLabel.TextYAlignment = .TextYAlignment.Center




afkStatusLabel.Parent = afkTimerFrame




addBtnSound = (b)




	b.MouseEnter:(()




		hoverSound:()




	)




	b.MouseButton1Click:(()




		clickSound:()




	)














makeToggle = (button, label)




	button.Text = label




	 switchTrack = .()




	switchTrack.Size = .(, , , )




	switchTrack.Position = .(, -, , -)




	switchTrack.BackgroundColor3 = .(, , )




	switchTrack.BorderSizePixel = 




	switchTrack.Parent = button




	.(, switchTrack).CornerRadius = .(, )




	 stroke = .()




	stroke.Color = .(, , )




	stroke.Thickness = 




	stroke.Parent = switchTrack




	 switchKnob = .()




	switchKnob.Size = .(, , , )




	switchKnob.Position = .(, , , -)




	switchKnob.BackgroundColor3 = .(, , )




	switchKnob.BorderSizePixel = 




	switchKnob.Parent = switchTrack




	.(, switchKnob).CornerRadius = .(, )




	 TweenService = :()




	 (enabled)




		 enabled 




			TweenService:(switchTrack, TweenInfo.(), {BackgroundColor3 = .(, , )}):()




			TweenService:(switchKnob, TweenInfo.(), {Position = .(, -, , -), BackgroundColor3 = .(, , )}):()




			stroke.Color = .(, , )




		




			TweenService:(switchTrack, TweenInfo.(), {BackgroundColor3 = .(, , )}):()




			TweenService:(switchKnob, TweenInfo.(), {Position = .(, , , -), BackgroundColor3 = .(, , )}):()




			stroke.Color = .(, , )




		




	














 panel = .()




panel.Size = .(, , , )




panel.Position = .(, , , -)




panel.BackgroundColor3 = .(, , )




panel.BackgroundTransparency = 




panel.BorderSizePixel = 




panel.Visible = 




panel.ClipsDescendants = 




panel.Parent = gui




.(, panel).CornerRadius = .(, )









 titleBar = .()




titleBar.Size = .(, , , )




titleBar.BackgroundColor3 = .(, , )




titleBar.BackgroundTransparency = 




titleBar.BorderSizePixel = 




titleBar.Parent = panel




.(, titleBar).CornerRadius = .(, )









	 title = .()




	title.Size = .(, -, , )




	title.Position = .(, , , )




	title.BackgroundTransparency = 




	title.Text = 




	title.TextColor3 = .(, , )




	title.Font = .Font.SourceSansBold




	title.TextSize = 




	title.TextXAlignment = .TextXAlignment.Left




	title.Parent = titleBar









 closeBtn = .()




closeBtn.Size = .(, , , )




closeBtn.Position = .(, -, , )




closeBtn.BackgroundColor3 = .(, , )




closeBtn.BackgroundTransparency = 




closeBtn.Text = 




closeBtn.TextColor3 = .(, , )




closeBtn.Font = .Font.SourceSansBold




closeBtn.TextSize = 




closeBtn.BorderSizePixel = 




closeBtn.Parent = titleBar




.(, closeBtn).CornerRadius = .(, )




(closeBtn)









 isResizing = 




 dragging, dragStart, startPos = , , 




titleBar.InputBegan:((input)




	 input.UserInputType == .UserInputType.MouseButton1 




		dragging = 




		dragStart = input.Position




		startPos = panel.Position




	




)




titleBar.InputEnded:((input)




	 input.UserInputType == .UserInputType.MouseButton1  dragging =  




)




UserInputService.InputChanged:((input)




	 dragging   isResizing  input.UserInputType == .UserInputType.MouseMovement 




		 delta = input.Position - dragStart




		panel.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)




	




)









closeBtn.MouseButton1Click:(()




	panel.Visible = 




	UserInputService.MouseBehavior = .MouseBehavior.Default




)




UserInputService.InputBegan:((input, gp)




	 gp   




	 input.KeyCode == .KeyCode.K 




		panel.Visible =  panel.Visible




		 panel.Visible 




			UserInputService.MouseBehavior = .MouseBehavior.Default




		




			UserInputService.MouseBehavior = .MouseBehavior.Default




		




	




)


UserInputService.InputBegan:((input, gp)
	 gp   
	 panel.Visible  input.UserInputType == .UserInputType.MouseButton2 
		_S.rightMouseHeld = 
	
)

UserInputService.InputEnded:((input)
	 input.UserInputType == .UserInputType.MouseButton2 
		_S.rightMouseHeld = 
		 panel.Visible 
			UserInputService.MouseBehavior = .MouseBehavior.Default
			UserInputService.MouseIconEnabled = 
		
	
)














	 minW, minH = , 




	 resizeHandle = 




	 resizeMouseStart = 




	 resizePanelStart = 




	 resizeSizeStart = 




	  (name, pos, size)




		 h = .()




		h.Name = name




		h.Size = size




		h.Position = pos




		h.BackgroundTransparency = 




		h.BorderSizePixel = 




		h.Active = 




		h.ZIndex = 




		h.Parent = panel




		h.MouseEnter:(()




			h.BackgroundTransparency = 




			h.BackgroundColor3 = .(, , )




		)




		h.MouseLeave:(()




			  resizeHandle  resizeHandle ~= name 




				h.BackgroundTransparency = 




			




		)




		h.InputBegan:((input)




			 input.UserInputType == .UserInputType.MouseButton1 




				resizeHandle = name




				isResizing = 




				resizeMouseStart = input.Position




				resizePanelStart = panel.Position




				resizeSizeStart = panel.Size




				h.BackgroundTransparency = 




			




		)




		h.InputEnded:((input)




			 input.UserInputType == .UserInputType.MouseButton1 




				resizeHandle = 




				isResizing = 




				h.BackgroundTransparency = 




			




		)




		 h




	




	(,   .(, -, , ),  .(, , , -))




	(,  .(, -, , ),   .(, , , -))




	(,    .(, , , -),   .(, -, , ))




	(, .(, , , -),   .(, -, , ))




	(,     .(, -, , -),   .(, , , ))




	(,     .(, -, , -),   .(, , , ))




	(,     .(, -, , -),   .(, , , ))




	(,     .(, -, , -),   .(, , , ))




	UserInputService.InputChanged:((input)




		 resizeHandle  input.UserInputType == .UserInputType.MouseMovement 




			 delta = input.Position - resizeMouseStart




			 dX, dY = delta.X, delta.Y




			 startW = resizeSizeStart.X.Offset




			 startH = resizeSizeStart.Y.Offset




			 startX = resizePanelStart.X.Offset




			 startY = resizePanelStart.Y.Offset




			 newW, newH, newX, newY = startW, startH, startX, startY




			 isLeft = resizeHandle:()  resizeHandle:()  resizeHandle:()




			 isRight = resizeHandle:()  resizeHandle:()  resizeHandle:()




			 isTop = resizeHandle:()  resizeHandle:()  resizeHandle:()




			 isBottom = resizeHandle:()  resizeHandle:()  resizeHandle:()




			 isLeft 




				newW = .(minW, startW - dX)




				newX = startX + (startW - newW)




			




			 isRight 




				newW = .(minW, startW + dX)




			




			 isTop 




				newH = .(minH, startH - dY)




				newY = startY + (startH - newH)




			




			 isBottom 




				newH = .(minH, startH + dY)




			




			panel.Size = .(, newW, , newH)




			panel.Position = .(resizePanelStart.X.Scale, newX, resizePanelStart.Y.Scale, newY)




			 updateScale  () 




		




	)














 mainContainer = .()




mainContainer.Name = 




mainContainer.Size = .(, -, , -)




mainContainer.Position = .(, , , )




mainContainer.BackgroundTransparency = 




mainContainer.BorderSizePixel = 




mainContainer.Parent = panel









 mainScale = .()




mainScale.Parent = mainContainer









 DESIGN_W = 




 DESIGN_H = 




updateScale = ()




	 pw = panel.Size.X.Offset




	 ph = panel.Size.Y.Offset




	 s = .(pw / DESIGN_W, ph / DESIGN_H)




	s = .(s, ) 




	mainScale.Scale = s




	




	mainContainer.Size = .( / s, - / s,  / s, - / s)









()














 navBar = .()




navBar.Name = 




navBar.Size = .(, , , -)




navBar.Position = .(, , , )




navBar.BackgroundColor3 = .(, , )




navBar.BackgroundTransparency = 




navBar.BorderSizePixel = 




navBar.ScrollBarThickness = 




navBar.ScrollBarImageColor3 = .(, , )




navBar.AutomaticCanvasSize = .AutomaticSize.Y




navBar.CanvasSize = .(, , , )




navBar.ScrollingDirection = .ScrollingDirection.Y




navBar.Parent = mainContainer




.(, navBar).CornerRadius = .(, )




 navList = .()




navList.Padding = .(, )




navList.HorizontalAlignment = .HorizontalAlignment.Center




navList.SortOrder = .SortOrder.LayoutOrder




navList.Parent = navBar









 contentScroll = .()




contentScroll.Name = 




contentScroll.Size = .(, -, , )




contentScroll.Position = .(, , , )




contentScroll.BackgroundColor3 = .(, , )




contentScroll.BackgroundTransparency = 




contentScroll.BorderSizePixel = 




contentScroll.ScrollBarThickness = 




contentScroll.ScrollBarImageColor3 = .(, , )




contentScroll.AutomaticCanvasSize = .AutomaticSize.Y




contentScroll.CanvasSize = .(, , , )




contentScroll.ScrollingDirection = .ScrollingDirection.Y




contentScroll.Parent = mainContainer









 pages = {}




 navButtons = {}




 currentPage = 




  (pageName)




	 currentPage  pages[currentPage] 




		pages[currentPage].Visible = 




	




	 currentPage  navButtons[currentPage] 




		navButtons[currentPage].BackgroundColor3 = _S.customNavColor  .(, , )




	




	currentPage = pageName




	 pages[pageName] 




		pages[pageName].Visible = 




		




	




	 navButtons[pageName] 




		navButtons[pageName].BackgroundColor3 = _S.customNavActiveColor  .(, , )




	









  (name, label, order)




	 b = .()




	b.Size = .(, -, , )




	b.BackgroundColor3 = _S.customNavColor  .(, , )




	b.BackgroundTransparency = 




	b.Text = label




	b.TextColor3 = .(, , )




	b.Font = .Font.SourceSansBold




	b.TextSize = 




	b.TextTruncate = .TextTruncate.AtEnd




	b.BorderSizePixel = 




	b.LayoutOrder = order  




	b.Parent = navBar




	.(, b).CornerRadius = .(, )




	(b)




	navButtons[name] = b




	b.MouseButton1Click:(()




		(name)




	)




	 b









  (name, frame)




	pages[name] = frame




	frame.Visible = 














(, , )




(, , )




(, , )




(, , )




(, , )




(, , )




(, , )




(, , )




(, , )




(, , )









 profileCard = .()




profileCard.Name = 




profileCard.Size = .(, , , )




profileCard.Position = .(, , , -)




profileCard.BackgroundColor3 = .(, , )




profileCard.BackgroundTransparency = 




profileCard.BorderSizePixel = 




profileCard.Parent = mainContainer









 profileSep = .()




profileSep.Size = .(, -, , )




profileSep.Position = .(, , , )




profileSep.BackgroundColor3 = .(, , )




profileSep.BorderSizePixel = 




profileSep.Parent = profileCard









 avatarBg = .()




avatarBg.Size = .(, , , )




avatarBg.Position = .(, , , -)




avatarBg.BackgroundColor3 = .(, , )




avatarBg.BorderSizePixel = 




avatarBg.Parent = profileCard




.(, avatarBg).CornerRadius = .(, )




 avatar = .()




avatar.Size = .(, -, , -)




avatar.Position = .(, , , )




avatar.BackgroundColor3 = .(, , )




avatar.BorderSizePixel = 




avatar.Image = 




avatar.Parent = avatarBg




.(, avatar).CornerRadius = .(, )









 profileName = .()




profileName.Size = .(, -, , )




profileName.Position = .(, , , )




profileName.BackgroundTransparency = 




profileName.Text = player.Name




profileName.TextColor3 = .(, , )




profileName.Font = .Font.SourceSansBold




profileName.TextSize = 




profileName.TextXAlignment = .TextXAlignment.Left




profileName.TextTruncate = .TextTruncate.AtEnd




profileName.Parent = profileCard









 profileRole = .()




profileRole.Size = .(, -, , )




profileRole.Position = .(, , , )




profileRole.BackgroundTransparency = 




  ()




	 team = player.Team




	 team 




		profileRole.Text = team.Name




		 teamColor = team.TeamColor




		 teamColor 




			profileRole.TextColor3 = teamColor.Color




		




	




		profileRole.Text = 




		profileRole.TextColor3 = .(, , )




	









()




player:():(updateProfileRole)




profileRole.Font = .Font.SourceSans




profileRole.TextSize = 




profileRole.TextXAlignment = .TextXAlignment.Left




profileRole.TextTruncate = .TextTruncate.AtEnd




profileRole.Parent = profileCard









.(()




	 userId = player.UserId




	 success, result = (()




		 Players:(userId, .ThumbnailType.HeadShot, .ThumbnailSize.Size420x420)




	)




	 success  result  avatar  avatar.Parent 




		avatar.Image = result




	




)









 pSection = .()




pSection.Size = .(, -, , )




pSection.Position = .(, , , )




pSection.BackgroundTransparency = 




pSection.Parent = contentScroll









	 pHeader = .()




	pHeader.Size = .(, , , )




	pHeader.BackgroundTransparency = 




	pHeader.Text = 




	pHeader.TextColor3 = .(, , )




	pHeader.Font = .Font.SourceSansBold




	pHeader.TextSize = 




	pHeader.TextXAlignment = .TextXAlignment.Left




	pHeader.Parent = pSection














	 pDesc = .()




	pDesc.Size = .(, , , )




	pDesc.Position = .(, , , )




	pDesc.BackgroundTransparency = 




	pDesc.Text = 




	pDesc.TextColor3 = .(, , )




	pDesc.Font = .Font.SourceSans




	pDesc.TextSize = 




	pDesc.TextWrapped = 




	pDesc.TextTruncate = .TextTruncate.AtEnd




	pDesc.TextXAlignment = .TextXAlignment.Left




	pDesc.TextYAlignment = .TextYAlignment.Top




	pDesc.Parent = pSection














 searchBox = .()




searchBox.Size = .(, , , )




searchBox.Position = .(, , , )




searchBox.BackgroundColor3 = .(, , )




searchBox.BackgroundTransparency = 




searchBox.Text = 




searchBox.PlaceholderText = 




searchBox.TextColor3 = .(, , )




searchBox.Font = .Font.SourceSans




searchBox.TextSize = 




searchBox.BorderSizePixel = 




searchBox.Parent = pSection




.(, searchBox).CornerRadius = .(, ).(, searchBox).CornerRadius = .(, )









 spectateBtnRow = .()




spectateBtnRow.Size = .(, , , )




spectateBtnRow.Position = .(, , , )




spectateBtnRow.BackgroundTransparency = 




spectateBtnRow.Parent = pSection




 spectateBtn = (spectateBtnRow, , .(, , , ), .(, -, , ), .(, , ))




spectateBtn.Parent = spectateBtnRow




 stopSpectateBtn = (spectateBtnRow, , .(, , , ), .(, -, , ), .(, , ))




stopSpectateBtn.Parent = spectateBtnRow




 spectateNavRow = .()




spectateNavRow.Size = .(, , , )




spectateNavRow.Position = .(, , , )




spectateNavRow.BackgroundTransparency = 




spectateNavRow.Parent = pSection




 prevSpectateBtn = (spectateNavRow, , .(, , , ), .(, -, , ), .(, , ))




prevSpectateBtn.Parent = spectateNavRow




 nextSpectateBtn = (spectateNavRow, , .(, , , ), .(, -, , ), .(, , ))




nextSpectateBtn.Parent = spectateNavRow









 pScroll = .()




pScroll.Size = .(, , , -)




pScroll.Position = .(, , , )




pScroll.BackgroundColor3 = .(, , )




pScroll.BackgroundTransparency = 




pScroll.BorderSizePixel = 




pScroll.ScrollBarThickness = 




pScroll.AutomaticCanvasSize = .AutomaticSize.Y




pScroll.CanvasSize = .(, , , )




pScroll.Parent = pSection




.(, pScroll).CornerRadius = .(, )




.(, pScroll).Padding = .(, )









 mSection = .()




mSection.Size = .(, -, , )




mSection.Position = .(, , , )




mSection.BackgroundTransparency = 




mSection.Parent = contentScroll









	 mHeader = .()




	mHeader.Size = .(, , , )




	mHeader.BackgroundTransparency = 




	mHeader.Text = 




	mHeader.TextColor3 = .(, , )




	mHeader.Font = .Font.SourceSansBold




	mHeader.TextSize = 




	mHeader.TextXAlignment = .TextXAlignment.Left




	mHeader.Parent = mSection














	 mDesc = .()




	mDesc.Size = .(, , , )




	mDesc.Position = .(, , , )




	mDesc.BackgroundTransparency = 




	mDesc.Text = 




	mDesc.TextColor3 = .(, , )




	mDesc.Font = .Font.SourceSans




	mDesc.TextSize = 




	mDesc.TextWrapped = 




	mDesc.TextTruncate = .TextTruncate.AtEnd




	mDesc.TextXAlignment = .TextXAlignment.Left




	mDesc.TextYAlignment = .TextYAlignment.Top




	mDesc.Parent = mSection









 speedBtn = (mSection, , .(, , , ), .(, -, , ), .(, , ))




speedBtn.Font = .Font.SourceSansBold




speedBtn.TextSize = 




 setSpeedToggle = (speedBtn, )




 flyBtn = (mSection, , .(, , , ), .(, -, , ), .(, , ))




flyBtn.Font = .Font.SourceSansBold




flyBtn.TextSize = 




 setFlyToggle = (flyBtn, )





 walkCard = .()
walkCard.Size = .(, -, , )
walkCard.Position = .(, , , )
walkCard.BackgroundColor3 = .(, , )
walkCard.BackgroundTransparency = 
walkCard.BorderSizePixel = 
walkCard.Parent = mSection
.(, walkCard).CornerRadius = .(, )

	 walkStroke = .()
	walkStroke.Color = .(, , )
	walkStroke.Thickness = 
	walkStroke.Transparency = 
	walkStroke.Parent = walkCard


	 walkLabel = .()
	walkLabel.Size = .(, , , )
	walkLabel.Position = .(, , , )
	walkLabel.BackgroundTransparency = 
	walkLabel.Text = 
	walkLabel.TextColor3 = .(, , )
	walkLabel.Font = .Font.SourceSansBold
	walkLabel.TextSize = 
	walkLabel.TextXAlignment = .TextXAlignment.Left
	walkLabel.Parent = walkCard

 speedValueLabel = .()
speedValueLabel.Size = .(, , , )
speedValueLabel.Position = .(, -, , )
speedValueLabel.BackgroundColor3 = .(, , )
speedValueLabel.BackgroundTransparency = 
speedValueLabel.Text = (_S.speedValue)
speedValueLabel.TextColor3 = .(, , )
speedValueLabel.Font = .Font.SourceSansBold
speedValueLabel.TextSize = 
speedValueLabel.BorderSizePixel = 
speedValueLabel.ClearTextOnFocus = 
speedValueLabel.TextXAlignment = .TextXAlignment.Right
speedValueLabel.Parent = walkCard
 walkTrack = .()
walkTrack.Size = .(, -, , )
walkTrack.Position = .(, , , )
walkTrack.BackgroundColor3 = .(, , )
walkTrack.BorderSizePixel = 
walkTrack.Parent = walkCard
.(, walkTrack).CornerRadius = .(, )
 walkFill = .()
walkFill.Size = .(, , , )
walkFill.BackgroundColor3 = .(, , )
walkFill.BorderSizePixel = 
walkFill.Parent = walkTrack
.(, walkFill).CornerRadius = .(, )
 walkThumb = .()
walkThumb.Size = .(, , , )
walkThumb.AnchorPoint = .(, )
walkThumb.Position = .(, , , )
walkThumb.BackgroundColor3 = .(, , )
walkThumb.BorderSizePixel = 
walkThumb.Parent = walkTrack
.(, walkThumb).CornerRadius = .(, )

	 walkThumbShadow = .()
	walkThumbShadow.Color = .(, , )
	walkThumbShadow.Thickness = 
	walkThumbShadow.Transparency = 
	walkThumbShadow.Parent = walkThumb

 speedDownBtn = .()
speedDownBtn.Visible = 
speedDownBtn.Parent = walkCard
(speedDownBtn)
 speedUpBtn = .()
speedUpBtn.Visible = 
speedUpBtn.Parent = walkCard
(speedUpBtn)
 WALK_MIN = 
 WALK_MAX = 
  (animate)
	 pct = .((_S.speedValue - WALK_MIN) / (WALK_MAX - WALK_MIN), , )
	 animate 
		TweenService:(walkFill, TweenInfo.(), {Size = .(pct, , , )}):()
		TweenService:(walkThumb, TweenInfo.(), {Position = .(pct, , , )}):()
	
		walkFill.Size = .(pct, , , )
		walkThumb.Position = .(pct, , , )
	

 walkDragging = 
walkTrack.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		walkDragging = 
		 tp = walkTrack.AbsolutePosition.X
		 ts = walkTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.speedValue = .(, .(WALK_MIN + pct * (WALK_MAX - WALK_MIN)))
		speedValueLabel.Text = (_S.speedValue)
		()
		 _S.speedEnabled  () 
	
)
walkThumb.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		walkDragging = 
	
)
UserInputService.InputEnded:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		walkDragging = 
	
)
UserInputService.InputChanged:((input)
	 walkDragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
		 tp = walkTrack.AbsolutePosition.X
		 ts = walkTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.speedValue = .(, .(WALK_MIN + pct * (WALK_MAX - WALK_MIN)))
		speedValueLabel.Text = (_S.speedValue)
		()
		 _S.speedEnabled  () 
	
)
speedValueLabel:():(()
	  walkDragging 
		 num = (speedValueLabel.Text)
		 num 
			 pct = .((num - WALK_MIN) / (WALK_MAX - WALK_MIN), , )
			TweenService:(walkFill, TweenInfo.(), {Size = .(pct, , , )}):()
			TweenService:(walkThumb, TweenInfo.(), {Position = .(pct, , , )}):()
		
	
)
()
speedValueLabel.FocusLost:(()
	 num = (speedValueLabel.Text)
	 num 
		_S.speedValue = .(, .(num))
		speedValueLabel.Text = (_S.speedValue)
		()
		 _S.speedEnabled  () 
	
		speedValueLabel.Text = (_S.speedValue)
		()
	
)






 flySpeedCard = .()
flySpeedCard.Size = .(, -, , )
flySpeedCard.Position = .(, , , )
flySpeedCard.BackgroundColor3 = .(, , )
flySpeedCard.BackgroundTransparency = 
flySpeedCard.BorderSizePixel = 
flySpeedCard.Parent = mSection
.(, flySpeedCard).CornerRadius = .(, )

	 flySpeedStroke = .()
	flySpeedStroke.Color = .(, , )
	flySpeedStroke.Thickness = 
	flySpeedStroke.Transparency = 
	flySpeedStroke.Parent = flySpeedCard


	 flyLabel = .()
	flyLabel.Size = .(, , , )
	flyLabel.Position = .(, , , )
	flyLabel.BackgroundTransparency = 
	flyLabel.Text = 
	flyLabel.TextColor3 = .(, , )
	flyLabel.Font = .Font.SourceSansBold
	flyLabel.TextSize = 
	flyLabel.TextXAlignment = .TextXAlignment.Left
	flyLabel.Parent = flySpeedCard

 flySpeedValueLabel = .()
flySpeedValueLabel.Size = .(, , , )
flySpeedValueLabel.Position = .(, -, , )
flySpeedValueLabel.BackgroundColor3 = .(, , )
flySpeedValueLabel.BackgroundTransparency = 
flySpeedValueLabel.Text = (_S.flySpeed)
flySpeedValueLabel.TextColor3 = .(, , )
flySpeedValueLabel.Font = .Font.SourceSansBold
flySpeedValueLabel.TextSize = 
flySpeedValueLabel.BorderSizePixel = 
flySpeedValueLabel.ClearTextOnFocus = 
flySpeedValueLabel.TextXAlignment = .TextXAlignment.Right
flySpeedValueLabel.Parent = flySpeedCard
 flyTrack = .()
flyTrack.Size = .(, -, , )
flyTrack.Position = .(, , , )
flyTrack.BackgroundColor3 = .(, , )
flyTrack.BorderSizePixel = 
flyTrack.Parent = flySpeedCard
.(, flyTrack).CornerRadius = .(, )
 flyFill = .()
flyFill.Size = .(, , , )
flyFill.BackgroundColor3 = .(, , )
flyFill.BorderSizePixel = 
flyFill.Parent = flyTrack
.(, flyFill).CornerRadius = .(, )
 flyThumb = .()
flyThumb.Size = .(, , , )
flyThumb.AnchorPoint = .(, )
flyThumb.Position = .(, , , )
flyThumb.BackgroundColor3 = .(, , )
flyThumb.BorderSizePixel = 
flyThumb.Parent = flyTrack
.(, flyThumb).CornerRadius = .(, )

	 flyThumbShadow = .()
	flyThumbShadow.Color = .(, , )
	flyThumbShadow.Thickness = 
	flyThumbShadow.Transparency = 
	flyThumbShadow.Parent = flyThumb

 flySpeedDownBtn = .()
flySpeedDownBtn.Visible = 
flySpeedDownBtn.Parent = flySpeedCard
(flySpeedDownBtn)
 flySpeedUpBtn = .()
flySpeedUpBtn.Visible = 
flySpeedUpBtn.Parent = flySpeedCard
(flySpeedUpBtn)
 FLY_MIN = 
 FLY_MAX = 
  (animate)
	 pct = .((_S.flySpeed - FLY_MIN) / (FLY_MAX - FLY_MIN), , )
	 animate 
		TweenService:(flyFill, TweenInfo.(), {Size = .(pct, , , )}):()
		TweenService:(flyThumb, TweenInfo.(), {Position = .(pct, , , )}):()
	
		flyFill.Size = .(pct, , , )
		flyThumb.Position = .(pct, , , )
	

 flyDragging = 
flyTrack.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		flyDragging = 
		 tp = flyTrack.AbsolutePosition.X
		 ts = flyTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.flySpeed = .(, .(FLY_MIN + pct * (FLY_MAX - FLY_MIN)))
		flySpeedValueLabel.Text = (_S.flySpeed)
		()
	
)
flyThumb.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		flyDragging = 
	
)
UserInputService.InputEnded:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		flyDragging = 
	
)
UserInputService.InputChanged:((input)
	 flyDragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
		 tp = flyTrack.AbsolutePosition.X
		 ts = flyTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.flySpeed = .(, .(FLY_MIN + pct * (FLY_MAX - FLY_MIN)))
		flySpeedValueLabel.Text = (_S.flySpeed)
		()
	
)
flySpeedValueLabel:():(()
	  flyDragging 
		 num = (flySpeedValueLabel.Text)
		 num 
			 pct = .((num - FLY_MIN) / (FLY_MAX - FLY_MIN), , )
			TweenService:(flyFill, TweenInfo.(), {Size = .(pct, , , )}):()
			TweenService:(flyThumb, TweenInfo.(), {Position = .(pct, , , )}):()
		
	
)
()
flySpeedValueLabel.FocusLost:(()
	 num = (flySpeedValueLabel.Text)
	 num 
		_S.flySpeed = .(, .(num))
		flySpeedValueLabel.Text = (_S.flySpeed)
	
		flySpeedValueLabel.Text = (_S.flySpeed)
	
)



	 swimBtn = (mSection, , .(, , , ), .(, -, , ), .(, , ))
	swimBtn.Font = .Font.SourceSansBold
	swimBtn.TextSize = 
	_S.setSwimToggle = (swimBtn, )
	_S.swimBtn = swimBtn

	
	 swimCard = .()
	swimCard.Size = .(, -, , )
	swimCard.Position = .(, , , )
	swimCard.BackgroundColor3 = .(, , )
	swimCard.BackgroundTransparency = 
	swimCard.BorderSizePixel = 
	swimCard.Parent = mSection
	.(, swimCard).CornerRadius = .(, )
	
		 swimStroke = .()
		swimStroke.Color = .(, , )
		swimStroke.Thickness = 
		swimStroke.Transparency = 
		swimStroke.Parent = swimCard
	
	
		 swimLabel = .()
		swimLabel.Size = .(, , , )
		swimLabel.Position = .(, , , )
		swimLabel.BackgroundTransparency = 
		swimLabel.Text = 
		swimLabel.TextColor3 = .(, , )
		swimLabel.Font = .Font.SourceSansBold
		swimLabel.TextSize = 
		swimLabel.TextXAlignment = .TextXAlignment.Left
		swimLabel.Parent = swimCard
	
	 swimSpeedValueLabel = .()
	swimSpeedValueLabel.Size = .(, , , )
	swimSpeedValueLabel.Position = .(, -, , )
	swimSpeedValueLabel.BackgroundColor3 = .(, , )
	swimSpeedValueLabel.BackgroundTransparency = 
	swimSpeedValueLabel.Text = (_S.swimSpeed)
	swimSpeedValueLabel.TextColor3 = .(, , )
	swimSpeedValueLabel.Font = .Font.SourceSansBold
	swimSpeedValueLabel.TextSize = 
	swimSpeedValueLabel.BorderSizePixel = 
	swimSpeedValueLabel.ClearTextOnFocus = 
	swimSpeedValueLabel.TextXAlignment = .TextXAlignment.Right
	swimSpeedValueLabel.Parent = swimCard
	_S.swimSpeedValueLabel = swimSpeedValueLabel

	 swimTrack = .()
	swimTrack.Size = .(, -, , )
	swimTrack.Position = .(, , , )
	swimTrack.BackgroundColor3 = .(, , )
	swimTrack.BorderSizePixel = 
	swimTrack.Parent = swimCard
	.(, swimTrack).CornerRadius = .(, )
	 swimFill = .()
	swimFill.Size = .(, , , )
	swimFill.BackgroundColor3 = .(, , )
	swimFill.BorderSizePixel = 
	swimFill.Parent = swimTrack
	.(, swimFill).CornerRadius = .(, )
	 swimThumb = .()
	swimThumb.Size = .(, , , )
	swimThumb.AnchorPoint = .(, )
	swimThumb.Position = .(, , , )
	swimThumb.BackgroundColor3 = .(, , )
	swimThumb.BorderSizePixel = 
	swimThumb.Parent = swimTrack
	.(, swimThumb).CornerRadius = .(, )
	
		 swimThumbShadow = .()
		swimThumbShadow.Color = .(, , )
		swimThumbShadow.Thickness = 
		swimThumbShadow.Transparency = 
		swimThumbShadow.Parent = swimThumb
	

	 swimSpeedDownBtn = .()
	swimSpeedDownBtn.Visible = 
	swimSpeedDownBtn.Parent = swimCard
	(swimSpeedDownBtn)
	_S.swimSpeedDownBtn = swimSpeedDownBtn

	 swimSpeedUpBtn = .()
	swimSpeedUpBtn.Visible = 
	swimSpeedUpBtn.Parent = swimCard
	(swimSpeedUpBtn)
	_S.swimSpeedUpBtn = swimSpeedUpBtn

	 SWIM_MIN = 
	 SWIM_MAX = 
	  (animate)
		 pct = .((_S.swimSpeed - SWIM_MIN) / (SWIM_MAX - SWIM_MIN), , )
		 animate 
			TweenService:(swimFill, TweenInfo.(), {Size = .(pct, , , )}):()
			TweenService:(swimThumb, TweenInfo.(), {Position = .(pct, , , )}):()
		
			swimFill.Size = .(pct, , , )
			swimThumb.Position = .(pct, , , )
		
	
	_S.swimUpdateSlider = swimUpdateSlider

	 swimDragging = 
	swimTrack.InputBegan:((input)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			swimDragging = 
			 tp = swimTrack.AbsolutePosition.X
			 ts = swimTrack.AbsoluteSize.X
			 pct = .((input.Position.X - tp) / ts, , )
			_S.swimSpeed = .(, .(SWIM_MIN + pct * (SWIM_MAX - SWIM_MIN)))
			swimSpeedValueLabel.Text = (_S.swimSpeed)
			()
		
	)
	swimThumb.InputBegan:((input)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			swimDragging = 
		
	)
	UserInputService.InputEnded:((input)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			swimDragging = 
		
	)
	UserInputService.InputChanged:((input)
		 swimDragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
			 tp = swimTrack.AbsolutePosition.X
			 ts = swimTrack.AbsoluteSize.X
			 pct = .((input.Position.X - tp) / ts, , )
			_S.swimSpeed = .(, .(SWIM_MIN + pct * (SWIM_MAX - SWIM_MIN)))
			swimSpeedValueLabel.Text = (_S.swimSpeed)
			()
		
	)
	swimSpeedValueLabel:():(()
		  swimDragging 
			 num = (swimSpeedValueLabel.Text)
			 num 
				 pct = .((num - SWIM_MIN) / (SWIM_MAX - SWIM_MIN), , )
				TweenService:(swimFill, TweenInfo.(), {Size = .(pct, , , )}):()
				TweenService:(swimThumb, TweenInfo.(), {Position = .(pct, , , )}):()
			
		
	)
	()
	swimSpeedValueLabel.FocusLost:(()
		 num = (swimSpeedValueLabel.Text)
		 num 
			_S.swimSpeed = .(, .(num))
			swimSpeedValueLabel.Text = (_S.swimSpeed)
		
			swimSpeedValueLabel.Text = (_S.swimSpeed)
		
	)







 aSection = .()




aSection.Size = .(, -, , )




aSection.Position = .(, , , )




aSection.BackgroundTransparency = 




aSection.Parent = contentScroll









	 aHeader = .()




	aHeader.Size = .(, , , )




	aHeader.BackgroundTransparency = 




	aHeader.Text = 




	aHeader.TextColor3 = .(, , )




	aHeader.Font = .Font.SourceSansBold




	aHeader.TextSize = 




	aHeader.TextXAlignment = .TextXAlignment.Left




	aHeader.Parent = aSection














	 aDesc = .()




	aDesc.Size = .(, , , )




	aDesc.Position = .(, , , )




	aDesc.BackgroundTransparency = 




	aDesc.Text = 




	aDesc.TextColor3 = .(, , )




	aDesc.Font = .Font.SourceSans




	aDesc.TextSize = 




	aDesc.TextWrapped = 




	aDesc.TextTruncate = .TextTruncate.AtEnd




	aDesc.TextXAlignment = .TextXAlignment.Left




	aDesc.TextYAlignment = .TextYAlignment.Top




	aDesc.Parent = aSection









 espBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 setESPToggle = (espBtn, )




 noclipBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 setNoclipToggle = (noclipBtn, )




 tpPlayerBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 tpToolBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 giveToolsBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 respawnBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 tpAllBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 setTpAllToggle = (tpAllBtn, )




 xrayBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 setXrayToggle = (xrayBtn, )




 nightVisionBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))




 setNightVisionToggle = (nightVisionBtn, )


 spinBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))
 setSpinToggle = (spinBtn, )


 spinSpeedCard = .()
spinSpeedCard.Size = .(, -, , )
spinSpeedCard.Position = .(, , , )
spinSpeedCard.BackgroundColor3 = .(, , )
spinSpeedCard.BackgroundTransparency = 
spinSpeedCard.BorderSizePixel = 
spinSpeedCard.Parent = aSection
.(, spinSpeedCard).CornerRadius = .(, )

	 spinStroke = .()
	spinStroke.Color = .(, , )
	spinStroke.Thickness = 
	spinStroke.Transparency = 
	spinStroke.Parent = spinSpeedCard


	 spinLabel = .()
	spinLabel.Size = .(, , , )
	spinLabel.Position = .(, , , )
	spinLabel.BackgroundTransparency = 
	spinLabel.Text = 
	spinLabel.TextColor3 = .(, , )
	spinLabel.Font = .Font.SourceSansBold
	spinLabel.TextSize = 
	spinLabel.TextXAlignment = .TextXAlignment.Left
	spinLabel.Parent = spinSpeedCard

 spinSpeedValueLabel = .()
spinSpeedValueLabel.Size = .(, , , )
spinSpeedValueLabel.Position = .(, -, , )
spinSpeedValueLabel.BackgroundColor3 = .(, , )
spinSpeedValueLabel.BackgroundTransparency = 
spinSpeedValueLabel.Text = (_S.spinSpeed)
spinSpeedValueLabel.TextColor3 = .(, , )
spinSpeedValueLabel.Font = .Font.SourceSansBold
spinSpeedValueLabel.TextSize = 
spinSpeedValueLabel.BorderSizePixel = 
spinSpeedValueLabel.ClearTextOnFocus = 
spinSpeedValueLabel.TextXAlignment = .TextXAlignment.Right
spinSpeedValueLabel.Parent = spinSpeedCard
 spinTrack = .()
spinTrack.Size = .(, -, , )
spinTrack.Position = .(, , , )
spinTrack.BackgroundColor3 = .(, , )
spinTrack.BorderSizePixel = 
spinTrack.Parent = spinSpeedCard
.(, spinTrack).CornerRadius = .(, )
 spinFill = .()
spinFill.Size = .(, , , )
spinFill.BackgroundColor3 = .(, , )
spinFill.BorderSizePixel = 
spinFill.Parent = spinTrack
.(, spinFill).CornerRadius = .(, )
 spinThumb = .()
spinThumb.Size = .(, , , )
spinThumb.AnchorPoint = .(, )
spinThumb.Position = .(, , , )
spinThumb.BackgroundColor3 = .(, , )
spinThumb.BorderSizePixel = 
spinThumb.Parent = spinTrack
.(, spinThumb).CornerRadius = .(, )

	 spinThumbShadow = .()
	spinThumbShadow.Color = .(, , )
	spinThumbShadow.Thickness = 
	spinThumbShadow.Transparency = 
	spinThumbShadow.Parent = spinThumb

 SPIN_MIN = 
 SPIN_MAX = 
  (animate)
	 pct = .((_S.spinSpeed - SPIN_MIN) / (SPIN_MAX - SPIN_MIN), , )
	 animate 
		TweenService:(spinFill, TweenInfo.(), {Size = .(pct, , , )}):()
		TweenService:(spinThumb, TweenInfo.(), {Position = .(pct, , , )}):()
	
		spinFill.Size = .(pct, , , )
		spinThumb.Position = .(pct, , , )
	

 spinDragging = 
spinTrack.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		spinDragging = 
		 tp = spinTrack.AbsolutePosition.X
		 ts = spinTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.spinSpeed = .(, .(SPIN_MIN + pct * (SPIN_MAX - SPIN_MIN)))
		spinSpeedValueLabel.Text = (_S.spinSpeed)
		()
	
)
spinThumb.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		spinDragging = 
	
)
UserInputService.InputEnded:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		spinDragging = 
	
)
UserInputService.InputChanged:((input)
	 spinDragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
		 tp = spinTrack.AbsolutePosition.X
		 ts = spinTrack.AbsoluteSize.X
		 pct = .((input.Position.X - tp) / ts, , )
		_S.spinSpeed = .(, .(SPIN_MIN + pct * (SPIN_MAX - SPIN_MIN)))
		spinSpeedValueLabel.Text = (_S.spinSpeed)
		()
	
)
spinSpeedValueLabel:():(()
	  spinDragging 
		 num = (spinSpeedValueLabel.Text)
		 num 
			 pct = .((num - SPIN_MIN) / (SPIN_MAX - SPIN_MIN), , )
			TweenService:(spinFill, TweenInfo.(), {Size = .(pct, , , )}):()
			TweenService:(spinThumb, TweenInfo.(), {Position = .(pct, , , )}):()
		
	
)
()
spinSpeedValueLabel.FocusLost:(()
	 num = (spinSpeedValueLabel.Text)
	 num 
		_S.spinSpeed = .(, .(num))
		spinSpeedValueLabel.Text = (_S.spinSpeed)
	
		spinSpeedValueLabel.Text = (_S.spinSpeed)
	
)


_S.brEnabled = 
_S.brConn = 
_S.brCons = {}
_S.brRUA = 
 brBtn = (aSection, , .(, , , ), .(, -, , ), .(, , ))
 setBRToggle = (brBtn, )
brBtn.MouseButton1Click:(()
	_S.brEnabled =  _S.brEnabled
	(_S.brEnabled)
	 char = player.Character
	  char   
	 _S.brEnabled 
		 hum = char:()
		 anim = hum  hum:()
		 anim 
			 _, tr  (anim:())  tr:() 
		
		 as = char:()
		 as  as.Disabled =  
		 lt = char:()
		_S.brRUA = char:()
		 lt  _S.brRUA 
			_S.brCons = {}
			 ac = _S.brRUA:()
			 bs = _S.brRUA:()
			 ac  ac:()  ac.Enabled = ; .(_S.brCons, ac) 
			 bs  bs:()  bs.Enabled = ; .(_S.brCons, bs) 
			_S.brRUA.Anchored = 
			_S.brConn = RunService.RenderStepped:(()
				  _S.brEnabled   _S.brRUA   _S.brRUA.Parent   
				 lt2 = player.Character  player.Character:()
				  lt2   
				 bob = .(() * ) * 
				_S.brRUA.CFrame = lt2.CFrame * .(, - + bob, -)
			)
		
	
		 _S.brConn  _S.brConn:(); _S.brConn =  
		 _S.brRUA  _S.brRUA.Parent  _S.brRUA.Anchored =  
		_S.brRUA = 
		 _, c  (_S.brCons)  c.Enabled =  
		_S.brCons = {}
		 as = char:()
		 as  as.Disabled =  
	
)
player.CharacterAdded:(()
	 _S.brEnabled  .() 
)





_S.savedPosition = 




_S.savedPlayerPosition = 









 posSection = .()




posSection.Size = .(, -, , )




posSection.Position = .(, , , )




posSection.BackgroundTransparency = 




posSection.Parent = contentScroll









	 posHeader = .()




	posHeader.Size = .(, , , )




	posHeader.BackgroundTransparency = 




	posHeader.Text = 




	posHeader.TextColor3 = .(, , )




	posHeader.Font = .Font.SourceSansBold




	posHeader.TextSize = 




	posHeader.TextXAlignment = .TextXAlignment.Left




	posHeader.Parent = posSection














	 posDesc = .()




	posDesc.Size = .(, , , )




	posDesc.Position = .(, , , )




	posDesc.BackgroundTransparency = 




	posDesc.Text = 




	posDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	posDesc.Font = Enum.Font.SourceSans




	posDesc.TextSize = 12




	posDesc.TextWrapped = true




	posDesc.TextTruncate = Enum.TextTruncate.AtEnd




	posDesc.TextXAlignment = Enum.TextXAlignment.Left




	posDesc.TextYAlignment = Enum.TextYAlignment.Top




	posDesc.Parent = posSection




end




local savePosBtn = btn(posSection, "Save Position", UDim2.new(0, 0, 0, 48), UDim2.new(1, -2, 0, 24), Color3.fromRGB(45, 35, 55))




local tpPosBtn = btn(posSection, "TP Position", UDim2.new(0, 0, 0, 84), UDim2.new(1, -2, 0, 24), Color3.fromRGB(35, 45, 55))




local tpSavePosBtn = btn(posSection, "TP SAVE AUTO ALT", UDim2.new(0, 0, 0, 120), UDim2.new(1, -2, 0, 24), Color3.fromRGB(35, 55, 45))




local setTpSavePosToggle = makeToggle(tpSavePosBtn, "TP SAVE AUTO ALT")




local tpSaveSimpleBtn = btn(posSection, "TP SAVE AUTO SIMPLE", UDim2.new(0, 0, 0, 156), UDim2.new(1, -2, 0, 24), Color3.fromRGB(45, 55, 35))




local setTpSaveSimpleToggle = makeToggle(tpSaveSimpleBtn, "TP SAVE AUTO SIMPLE")




local savePlayerPosBtn = btn(posSection, "Save Pos Joueur Select", UDim2.new(0, 0, 0, 192), UDim2.new(1, -2, 0, 24), Color3.fromRGB(45, 35, 55))




local intervalCard = Instance.new("Frame")
intervalCard.Size = UDim2.new(1, -2, 0, 44)
intervalCard.Position = UDim2.new(0, 0, 0, 228)
intervalCard.BackgroundColor3 = Color3.fromRGB(22, 22, 28)
intervalCard.BackgroundTransparency = 0
intervalCard.BorderSizePixel = 0
intervalCard.Parent = posSection
Instance.new("UICorner", intervalCard).CornerRadius = UDim.new(0, 8)
do
	local intervalStroke = Instance.new("UIStroke")
	intervalStroke.Color = Color3.fromRGB(50, 50, 55)
	intervalStroke.Thickness = 1
	intervalStroke.Transparency = 0.3
	intervalStroke.Parent = intervalCard
end
do
	local intervalLabel = Instance.new("TextLabel")
	intervalLabel.Size = UDim2.new(0, 80, 0, 16)
	intervalLabel.Position = UDim2.new(0, 8, 0, 5)
	intervalLabel.BackgroundTransparency = 1
	intervalLabel.Text = "Interval"
	intervalLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
	intervalLabel.Font = Enum.Font.SourceSansBold
	intervalLabel.TextSize = 13
	intervalLabel.TextXAlignment = Enum.TextXAlignment.Left
	intervalLabel.Parent = intervalCard
end
local intervalValueLabel = Instance.new("TextBox")
intervalValueLabel.Size = UDim2.new(0, 50, 0, 16)
intervalValueLabel.Position = UDim2.new(1, -58, 0, 5)
intervalValueLabel.BackgroundColor3 = Color3.fromRGB(22, 22, 28)
intervalValueLabel.BackgroundTransparency = 1
intervalValueLabel.Text = tostring(_S.tpSaveInterval)
intervalValueLabel.TextColor3 = Color3.fromRGB(255, 60, 60)
intervalValueLabel.Font = Enum.Font.SourceSansBold
intervalValueLabel.TextSize = 13
intervalValueLabel.BorderSizePixel = 0
intervalValueLabel.ClearTextOnFocus = false
intervalValueLabel.TextXAlignment = Enum.TextXAlignment.Right
intervalValueLabel.Parent = intervalCard
local intervalTrack = Instance.new("Frame")
intervalTrack.Size = UDim2.new(1, -16, 0, 4)
intervalTrack.Position = UDim2.new(0, 8, 0, 30)
intervalTrack.BackgroundColor3 = Color3.fromRGB(12, 12, 16)
intervalTrack.BorderSizePixel = 0
intervalTrack.Parent = intervalCard
Instance.new("UICorner", intervalTrack).CornerRadius = UDim.new(1, 0)
local intervalFill = Instance.new("Frame")
intervalFill.Size = UDim2.new(0, 0, 1, 0)
intervalFill.BackgroundColor3 = Color3.fromRGB(220, 50, 50)
intervalFill.BorderSizePixel = 0
intervalFill.Parent = intervalTrack
Instance.new("UICorner", intervalFill).CornerRadius = UDim.new(1, 0)
local intervalThumb = Instance.new("Frame")
intervalThumb.Size = UDim2.new(0, 14, 0, 14)
intervalThumb.AnchorPoint = Vector2.new(0.5, 0.5)
intervalThumb.Position = UDim2.new(0, 0, 0.5, 0)
intervalThumb.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
intervalThumb.BorderSizePixel = 0
intervalThumb.Parent = intervalTrack
Instance.new("UICorner", intervalThumb).CornerRadius = UDim.new(1, 0)
do
	local intervalThumbShadow = Instance.new("UIStroke")
	intervalThumbShadow.Color = Color3.fromRGB(0, 0, 0)
	intervalThumbShadow.Thickness = 1
	intervalThumbShadow.Transparency = 0.5
	intervalThumbShadow.Parent = intervalThumb
end
local intervalDownBtn = Instance.new("TextButton")
intervalDownBtn.Visible = false
intervalDownBtn.Parent = intervalCard
local intervalUpBtn = Instance.new("TextButton")
intervalUpBtn.Visible = false
intervalUpBtn.Parent = intervalCard
local INTERVAL_MIN = 0.1
local INTERVAL_MAX = 10
local function intervalUpdateSlider(animate)
	local pct = math.clamp((_S.tpSaveInterval - INTERVAL_MIN) / (INTERVAL_MAX - INTERVAL_MIN), 0, 1)
	if animate then
		TweenService:Create(intervalFill, TweenInfo.new(0.15), {Size = UDim2.new(pct, 0, 1, 0)}):Play()
		TweenService:Create(intervalThumb, TweenInfo.new(0.15), {Position = UDim2.new(pct, 0, 0.5, 0)}):Play()
	else
		intervalFill.Size = UDim2.new(pct, 0, 1, 0)
		intervalThumb.Position = UDim2.new(pct, 0, 0.5, 0)
	end
end
local intervalDragging = false
intervalTrack.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
		intervalDragging = true
		local tp = intervalTrack.AbsolutePosition.X
		local ts = intervalTrack.AbsoluteSize.X
		local pct = math.clamp((input.Position.X - tp) / ts, 0, 1)
		_S.tpSaveInterval = math.max(0.1, INTERVAL_MIN + pct * (INTERVAL_MAX - INTERVAL_MIN))
		intervalValueLabel.Text = tostring(_S.tpSaveInterval)
		intervalUpdateSlider(true)
	end
end)
intervalThumb.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
		intervalDragging = true
	end
end)
UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
		intervalDragging = false
	end
end)
UserInputService.InputChanged:Connect(function(input)
	if intervalDragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
		local tp = intervalTrack.AbsolutePosition.X
		local ts = intervalTrack.AbsoluteSize.X
		local pct = math.clamp((input.Position.X - tp) / ts, 0, 1)
		_S.tpSaveInterval = math.max(0.1, INTERVAL_MIN + pct * (INTERVAL_MAX - INTERVAL_MIN))
		intervalValueLabel.Text = tostring(_S.tpSaveInterval)
		intervalUpdateSlider(true)
	end
end)
intervalValueLabel:GetPropertyChangedSignal("Text"):Connect(function()
	if not intervalDragging then
		local num = tonumber(intervalValueLabel.Text)
		if num then
			local pct = math.clamp((num - INTERVAL_MIN) / (INTERVAL_MAX - INTERVAL_MIN), 0, 1)
			TweenService:Create(intervalFill, TweenInfo.new(0.15), {Size = UDim2.new(pct, 0, 1, 0)}):Play()
			TweenService:Create(intervalThumb, TweenInfo.new(0.15), {Position = UDim2.new(pct, 0, 0.5, 0)}):Play()
		end
	end
end)
intervalUpdateSlider(false)
intervalValueLabel.FocusLost:Connect(function()
	local num = tonumber(intervalValueLabel.Text)
	if num then
		_S.tpSaveInterval = math.max(0.1, num)
		intervalValueLabel.Text = tostring(_S.tpSaveInterval)
		intervalUpdateSlider(true)
	else
		intervalValueLabel.Text = tostring(_S.tpSaveInterval)
		intervalUpdateSlider(true)
	end
end)





-- === Section Voice Chat ===




local vSection = Instance.new("Frame")




vSection.Size = UDim2.new(1, -10, 0, 80)




vSection.Position = UDim2.new(0, 5, 0, 5)




vSection.BackgroundTransparency = 1




vSection.Parent = contentScroll




do




	local vHeader = Instance.new("TextLabel")




	vHeader.Size = UDim2.new(1, 0, 0, 18)




	vHeader.BackgroundTransparency = 1




	vHeader.Text = "Voice Chat"




	vHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	vHeader.Font = Enum.Font.SourceSansBold




	vHeader.TextSize = 14




	vHeader.TextXAlignment = Enum.TextXAlignment.Left




	vHeader.Parent = vSection




end




do




	local vDesc = Instance.new("TextLabel")




	vDesc.Size = UDim2.new(1, 0, 0, 28)




	vDesc.Position = UDim2.new(0, 0, 0, 18)




	vDesc.BackgroundTransparency = 1




	vDesc.Text = "Sélectionnez d'abord un joueur dans la catégorie Joueurs, puis utilisez Vol - et Vol + pour réduire ou augmenter son volume vocal. Le volume actuel est affiché entre les deux boutons."




	vDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	vDesc.Font = Enum.Font.SourceSans




	vDesc.TextSize = 12




	vDesc.TextWrapped = true




	vDesc.TextTruncate = Enum.TextTruncate.AtEnd




	vDesc.TextXAlignment = Enum.TextXAlignment.Left




	vDesc.TextYAlignment = Enum.TextYAlignment.Top




	vDesc.Parent = vSection




end




local volDownBtn = btn(vSection, "Vol -", UDim2.new(0, 0, 0, 48), UDim2.new(0.18, -2, 0, 24), Color3.fromRGB(40, 30, 50))




local volLabel = Instance.new("TextBox")




volLabel.Size = UDim2.new(0.58, -2, 0, 24)




volLabel.Position = UDim2.new(0.22, 0, 0, 48)




volLabel.BackgroundColor3 = Color3.fromRGB(30, 30, 45)




volLabel.BackgroundTransparency = 0




volLabel.Text = "Vol: 100%"




volLabel.TextColor3 = Color3.fromRGB(255, 255, 255)




volLabel.Font = Enum.Font.SourceSans




volLabel.TextSize = 14




volLabel.BorderSizePixel = 0




volLabel.ClearTextOnFocus = false




volLabel.Parent = vSection




Instance.new("UICorner", volLabel).CornerRadius = UDim.new(0, 4)




local volUpBtn = btn(vSection, "Vol +", UDim2.new(0.82, 0, 0, 48), UDim2.new(0.18, -2, 0, 24), Color3.fromRGB(40, 30, 50))




-- === Section Auto ===




local auSection = Instance.new("Frame")




auSection.Size = UDim2.new(1, -10, 0, 176)




auSection.Position = UDim2.new(0, 5, 0, 5)




auSection.BackgroundTransparency = 1




auSection.Parent = contentScroll




do




	local auHeader = Instance.new("TextLabel")




	auHeader.Size = UDim2.new(1, 0, 0, 18)




	auHeader.BackgroundTransparency = 1




	auHeader.Text = "Auto"




	auHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	auHeader.Font = Enum.Font.SourceSansBold




	auHeader.TextSize = 14




	auHeader.TextXAlignment = Enum.TextXAlignment.Left




	auHeader.Parent = auSection




end




do




	local auDesc = Instance.new("TextLabel")




	auDesc.Size = UDim2.new(1, 0, 0, 28)




	auDesc.Position = UDim2.new(0, 0, 0, 18)




	auDesc.BackgroundTransparency = 1




	auDesc.Text = "AFK: active le mode anti-AFK (empêche d'être kické pour inactivité). Jump Infini: permet de sauter indéfiniment en maintenant la barre espace. Auto Rejoin: relance automatiquement le jeu si vous êtes déconnecté. Cliquez sur chaque bouton pour activer/désactiver."




	auDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	auDesc.Font = Enum.Font.SourceSans




	auDesc.TextSize = 12




	auDesc.TextWrapped = true




	auDesc.TextTruncate = Enum.TextTruncate.AtEnd




	auDesc.TextXAlignment = Enum.TextXAlignment.Left




	auDesc.TextYAlignment = Enum.TextYAlignment.Top




	auDesc.Parent = auSection




end




local afkBtn = btn(auSection, "AFK", UDim2.new(0, 0, 0, 48), UDim2.new(1, -2, 0, 24), Color3.fromRGB(30, 50, 50))




local setAfkToggle = makeToggle(afkBtn, "AFK")




local autoRejoinBtn = btn(auSection, "Auto Rejoin", UDim2.new(0, 0, 0, 84), UDim2.new(1, -2, 0, 24), Color3.fromRGB(50, 40, 30))




local jumpInfiniteBtn = btn(auSection, "Jump Infini", UDim2.new(0, 0, 0, 120), UDim2.new(1, -2, 0, 24), Color3.fromRGB(40, 50, 30))




local setJumpInfiniteToggle = makeToggle(jumpInfiniteBtn, "Jump Infini")




-- === Section Lock ===




local lockSection = Instance.new("Frame")




lockSection.Size = UDim2.new(1, -10, 0, 315)




lockSection.Position = UDim2.new(0, 5, 0, 5)




lockSection.BackgroundTransparency = 1




lockSection.Parent = contentScroll




do




	local lockHeader = Instance.new("TextLabel")




	lockHeader.Size = UDim2.new(1, 0, 0, 18)




	lockHeader.BackgroundTransparency = 1




	lockHeader.Text = "Lock"




	lockHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	lockHeader.Font = Enum.Font.SourceSansBold




	lockHeader.TextSize = 14




	lockHeader.TextXAlignment = Enum.TextXAlignment.Left




	lockHeader.Parent = lockSection




end




do




	local lockDesc = Instance.new("TextLabel")




	lockDesc.Size = UDim2.new(1, 0, 0, 28)




	lockDesc.Position = UDim2.new(0, 0, 0, 18)




	lockDesc.BackgroundTransparency = 1




	lockDesc.Text = "Lock Joueur: verrouille la caméra sur tous les joueurs. Lock Select: verrouille sur le joueur sélectionné dans Joueurs. Lock Equipe Adverse: verrouille sur l'équipe adverse. Utilisez les sliders - et + pour ajuster la portée de verrouillage (Infini = portée illimitée)."




	lockDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	lockDesc.Font = Enum.Font.SourceSans




	lockDesc.TextSize = 12




	lockDesc.TextWrapped = true




	lockDesc.TextTruncate = Enum.TextTruncate.AtEnd




	lockDesc.TextXAlignment = Enum.TextXAlignment.Left




	lockDesc.TextYAlignment = Enum.TextYAlignment.Top




	lockDesc.Parent = lockSection




end




local lockAllBtn = btn(lockSection, "Lock Joueur", UDim2.new(0, 0, 0, 48), UDim2.new(1, -2, 0, 24), Color3.fromRGB(50, 30, 30))




local setLockAllToggle = makeToggle(lockAllBtn, "Lock Joueur")




local lockSelBtn = btn(lockSection, "Lock Select", UDim2.new(0, 0, 0, 84), UDim2.new(1, -2, 0, 24), Color3.fromRGB(50, 30, 30))




local setLockSelToggle = makeToggle(lockSelBtn, "Lock Select")




local lockEnemyBtn = btn(lockSection, "Lock Equipe Adverse", UDim2.new(0, 0, 0, 120), UDim2.new(1, -2, 0, 24), Color3.fromRGB(50, 30, 30))




local setLockEnemyToggle = makeToggle(lockEnemyBtn, "Lock Equipe Adverse")




-- Slider control for lock range
local function makeRangeControl(parent, posY, size, label, rangeKey)
	local card = Instance.new("Frame")
	card.Size = size
	card.Position = posY
	card.BackgroundColor3 = Color3.fromRGB(22, 22, 28)
	card.BackgroundTransparency = 0
	card.BorderSizePixel = 0
	card.Parent = parent
	Instance.new("UICorner", card).CornerRadius = UDim.new(0, 8)
	do
		local cardStroke = Instance.new("UIStroke")
		cardStroke.Color = Color3.fromRGB(50, 50, 55)
		cardStroke.Thickness = 1
		cardStroke.Transparency = 0.3
		cardStroke.Parent = card
	end
	local lbl = Instance.new("TextLabel")
	lbl.Size = UDim2.new(0, 100, 0, 16)
	lbl.Position = UDim2.new(0, 8, 0, 5)
	lbl.BackgroundTransparency = 1
	lbl.Text = label
	lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
	lbl.Font = Enum.Font.SourceSansBold
	lbl.TextSize = 13
	lbl.TextXAlignment = Enum.TextXAlignment.Left
	lbl.Parent = card
	local valBox = Instance.new("TextBox")
	valBox.Size = UDim2.new(0, 60, 0, 16)
	valBox.Position = UDim2.new(1, -68, 0, 5)
	valBox.BackgroundColor3 = Color3.fromRGB(22, 22, 28)
	valBox.BackgroundTransparency = 1
	valBox.Text = _S.lockRanges[rangeKey] == math.huge and "Infini" or tostring(_S.lockRanges[rangeKey])
	valBox.TextColor3 = Color3.fromRGB(255, 60, 60)
	valBox.Font = Enum.Font.SourceSansBold
	valBox.TextSize = 13
	valBox.BorderSizePixel = 0
	valBox.ClearTextOnFocus = false
	valBox.TextXAlignment = Enum.TextXAlignment.Right
	valBox.Parent = card
	local track = Instance.new("Frame")
	track.Size = UDim2.new(1, -16, 0, 4)
	track.Position = UDim2.new(0, 8, 0, 30)
	track.BackgroundColor3 = Color3.fromRGB(12, 12, 16)
	track.BorderSizePixel = 0
	track.Parent = card
	Instance.new("UICorner", track).CornerRadius = UDim.new(1, 0)
	local fill = Instance.new("Frame")
	fill.Size = UDim2.new(0, 0, 1, 0)
	fill.BackgroundColor3 = Color3.fromRGB(220, 50, 50)
	fill.BorderSizePixel = 0
	fill.Parent = track
	Instance.new("UICorner", fill).CornerRadius = UDim.new(1, 0)
	local thumb = Instance.new("Frame")
	thumb.Size = UDim2.new(0, 14, 0, 14)
	thumb.AnchorPoint = Vector2.new(0.5, 0.5)
	thumb.Position = UDim2.new(0, 0, 0.5, 0)
	thumb.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
	thumb.BorderSizePixel = 0
	thumb.Parent = track
	Instance.new("UICorner", thumb).CornerRadius = UDim.new(1, 0)
	do
		local thumbShadow = Instance.new("UIStroke")
		thumbShadow.Color = Color3.fromRGB(0, 0, 0)
		thumbShadow.Thickness = 1
		thumbShadow.Transparency = 0.5
		thumbShadow.Parent = thumb
	end
	local downBtn = Instance.new("TextButton")
	downBtn.Visible = false
	downBtn.Parent = card
	addBtnSound(downBtn)
	local upBtn = Instance.new("TextButton")
	upBtn.Visible = false
	upBtn.Parent = card
	addBtnSound(upBtn)
	local RANGE_MIN = 10
	local RANGE_MAX = 1000
	local function updateLabel()
		valBox.Text = _S.lockRanges[rangeKey] == math.huge and "Infini" or tostring(_S.lockRanges[rangeKey])
	end
	local function updateSlider(animate)
		local val = _S.lockRanges[rangeKey]
		local pct
		if val == math.huge then
			pct = 1
		else
			pct = math.clamp((val - RANGE_MIN) / (RANGE_MAX - RANGE_MIN), 0, 1)
		end
		if animate then
			TweenService:Create(fill, TweenInfo.new(0.15), {Size = UDim2.new(pct, 0, 1, 0)}):Play()
			TweenService:Create(thumb, TweenInfo.new(0.15), {Position = UDim2.new(pct, 0, 0.5, 0)}):Play()
		else
			fill.Size = UDim2.new(pct, 0, 1, 0)
			thumb.Position = UDim2.new(pct, 0, 0.5, 0)
		end
	end
	local dragging = false
	track.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			local tp = track.AbsolutePosition.X
			local ts = track.AbsoluteSize.X
			local pct = math.clamp((input.Position.X - tp) / ts, 0, 1)
			if pct >= 0.99 then
				_S.lockRanges[rangeKey] = math.huge
			else
				_S.lockRanges[rangeKey] = math.max(RANGE_MIN, math.floor(RANGE_MIN + pct * (RANGE_MAX - RANGE_MIN)))
			end
			updateLabel()
			updateSlider(true)
		end
	end)
	thumb.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
		end
	end)
	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)
	UserInputService.InputChanged:Connect(function(input)
		if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
			local tp = track.AbsolutePosition.X
			local ts = track.AbsoluteSize.X
			local pct = math.clamp((input.Position.X - tp) / ts, 0, 1)
			if pct >= 0.99 then
				_S.lockRanges[rangeKey] = math.huge
			else
				_S.lockRanges[rangeKey] = math.max(RANGE_MIN, math.floor(RANGE_MIN + pct * (RANGE_MAX - RANGE_MIN)))
			end
			updateLabel()
			updateSlider(true)
		end
	end)
	valBox:GetPropertyChangedSignal("Text"):Connect(function()
		if not dragging then
			local val = _S.lockRanges[rangeKey]
			local pct
			if val == math.huge then
				pct = 1
			else
				pct = math.clamp((val - RANGE_MIN) / (RANGE_MAX - RANGE_MIN), 0, 1)
			end
			TweenService:Create(fill, TweenInfo.new(0.15), {Size = UDim2.new(pct, 0, 1, 0)}):Play()
			TweenService:Create(thumb, TweenInfo.new(0.15), {Position = UDim2.new(pct, 0, 0.5, 0)}):Play()
		end
	end)
	downBtn.MouseButton1Click:Connect(function()
		local r = _S.lockRanges[rangeKey]
		if r == math.huge then
			_S.lockRanges[rangeKey] = 500
		elseif r > 50 then
			_S.lockRanges[rangeKey] = r - 50
		else
			_S.lockRanges[rangeKey] = 10
		end
		updateLabel()
	end)
	upBtn.MouseButton1Click:Connect(function()
		local r = _S.lockRanges[rangeKey]
		if r == math.huge then
			return
		elseif r >= 500 then
			_S.lockRanges[rangeKey] = math.huge
		else
			_S.lockRanges[rangeKey] = r + 50
		end
		updateLabel()
	end)
	valBox.FocusLost:Connect(function()
		local txt = valBox.Text:lower()
		if txt == "infini" or txt == "inf" or txt == "infinite" then
			_S.lockRanges[rangeKey] = math.huge
		else
			local num = tonumber(txt)
			if num then
				_S.lockRanges[rangeKey] = math.max(10, math.floor(num))
			end
		end
		updateLabel()
	end)
	updateSlider(false)
end





-- Range controls pour chaque lock
do
	makeRangeControl(lockSection, UDim2.new(0, 0, 0, 156), UDim2.new(1, -2, 0, 44), "R:Joueur", "all")
	makeRangeControl(lockSection, UDim2.new(0, 0, 0, 208), UDim2.new(1, -2, 0, 44), "R:Select", "sel")
	makeRangeControl(lockSection, UDim2.new(0, 0, 0, 260), UDim2.new(1, -2, 0, 44), "R:Equipe Adv.", "enemy")
end

-- === Section Infos ===




local iSection = Instance.new("Frame")




iSection.Size = UDim2.new(1, -10, 0, 348)




iSection.Position = UDim2.new(0, 5, 0, 5)




iSection.BackgroundTransparency = 1




iSection.Parent = contentScroll




do




	local iHeader = Instance.new("TextLabel")




	iHeader.Size = UDim2.new(1, 0, 0, 18)




	iHeader.BackgroundTransparency = 1




	iHeader.Text = "Infos"




	iHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	iHeader.Font = Enum.Font.SourceSansBold




	iHeader.TextSize = 14




	iHeader.TextXAlignment = Enum.TextXAlignment.Left




	iHeader.Parent = iSection




end




do




	local iDesc = Instance.new("TextLabel")




	iDesc.Size = UDim2.new(1, 0, 0, 28)




	iDesc.Position = UDim2.new(0, 0, 0, 18)




	iDesc.BackgroundTransparency = 1




	iDesc.Text = "Voir mon sac: affiche tous les outils que vous possédez actuellement. Profil joueur: affiche les informations détaillées d'un joueur (sélectionnez-le d'abord dans la catégorie Joueurs)."




	iDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	iDesc.Font = Enum.Font.SourceSans




	iDesc.TextSize = 12




	iDesc.TextWrapped = true




	iDesc.TextTruncate = Enum.TextTruncate.AtEnd




	iDesc.TextXAlignment = Enum.TextXAlignment.Left




	iDesc.TextYAlignment = Enum.TextYAlignment.Top




	iDesc.Parent = iSection




end




local bagBtn = btn(iSection, "Voir mon sac", UDim2.new(0, 0, 0, 48), UDim2.new(1, -2, 0, 24), Color3.fromRGB(30, 50, 50))




local profileBtn = btn(iSection, "Profil joueur", UDim2.new(0, 0, 0, 84), UDim2.new(1, -2, 0, 24), Color3.fromRGB(50, 40, 60))




-- === Section Paramètres ===




local paramSection = Instance.new("Frame")




paramSection.Size = UDim2.new(1, -10, 0, 280)




paramSection.Position = UDim2.new(0, 5, 0, 5)




paramSection.BackgroundTransparency = 1




paramSection.Parent = contentScroll




do




	local paramHeader = Instance.new("TextLabel")




	paramHeader.Size = UDim2.new(1, 0, 0, 18)




	paramHeader.BackgroundTransparency = 1




	paramHeader.Text = "Paramètres"




	paramHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	paramHeader.Font = Enum.Font.SourceSansBold




	paramHeader.TextSize = 14




	paramHeader.TextXAlignment = Enum.TextXAlignment.Left




	paramHeader.Parent = paramSection




end




do




	local paramDesc = Instance.new("TextLabel")




	paramDesc.Size = UDim2.new(1, 0, 0, 28)




	paramDesc.Position = UDim2.new(0, 0, 0, 18)




	paramDesc.BackgroundTransparency = 1




	paramDesc.Text = "Personnalisez le panel: changez la couleur du panel, des boutons et des catégories. Choisissez un son de clic parmi Original, Click, Pop, Modern ou Aucun. Réinitialiser: restaure tous les réglages par défaut. Supprimer le panel: désactive toutes les fonctionnalités, tue Omega et supprime complètement le panel REDTIGER."




	paramDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




	paramDesc.Font = Enum.Font.SourceSans




	paramDesc.TextSize = 12




	paramDesc.TextWrapped = true




	paramDesc.TextTruncate = Enum.TextTruncate.AtEnd




	paramDesc.TextXAlignment = Enum.TextXAlignment.Left




	paramDesc.TextYAlignment = Enum.TextYAlignment.Top




	paramDesc.Parent = paramSection




end




-- === Personnalisation du Panel ===

-- Valeurs originales pour le reset
local originalColors = {
	panel = Color3.fromRGB(8, 8, 12),
	titleBar = Color3.fromRGB(18, 18, 28),
	navBar = Color3.fromRGB(14, 14, 22),
	contentScroll = Color3.fromRGB(8, 8, 12),
	profileCard = Color3.fromRGB(14, 14, 22),
	btnDefault = Color3.fromRGB(120, 30, 30),
	navColor = Color3.fromRGB(60, 60, 65),
	navActiveColor = Color3.fromRGB(100, 100, 110),
}

local originalSoundId = "rbxassetid://88442833509532"

-- Helper: creer un echantillon de couleur
local function makeColorSwatch(parent, color, posY, posX, onClick)
	local swatch = Instance.new("TextButton")
	swatch.Size = UDim2.new(0, 22, 0, 22)
	swatch.Position = UDim2.new(0, posX, 0, posY)
	swatch.BackgroundColor3 = color
	swatch.Text = ""
	swatch.BorderSizePixel = 1
	swatch.BorderColor3 = Color3.fromRGB(80, 80, 90)
	swatch.Parent = parent
	Instance.new("UICorner", swatch).CornerRadius = UDim.new(0, 4)
	addBtnSound(swatch)
	swatch.MouseButton1Click:Connect(function()
		onClick(color)
	end)
	return swatch
end

-- Appliquer la couleur du panel
local function applyPanelColor(c)
	panel.BackgroundColor3 = c
	titleBar.BackgroundColor3 = Color3.new(
		math.min(c.R + 0.04, 1),
		math.min(c.G + 0.04, 1),
		math.min(c.B + 0.04, 1)
	)
	navBar.BackgroundColor3 = Color3.new(
		math.min(c.R + 0.03, 1),
		math.min(c.G + 0.03, 1),
		math.min(c.B + 0.03, 1)
	)
	contentScroll.BackgroundColor3 = c
	profileCard.BackgroundColor3 = Color3.new(
		math.min(c.R + 0.03, 1),
		math.min(c.G + 0.03, 1),
		math.min(c.B + 0.03, 1)
	)
end

-- Appliquer la couleur des boutons
local function applyButtonColor(c)
	_S.customBtnColor = c
	if _S.allButtons then
		for _, b in ipairs(_S.allButtons) do
			pcall(function()
				b.BackgroundColor3 = c
			end)
		end
	end
	for name, navBtn in pairs(navButtons) do
		pcall(function()
			if name == currentPage then
				navBtn.BackgroundColor3 = _S.customNavActiveColor or Color3.fromRGB(100, 100, 110)
			else
				navBtn.BackgroundColor3 = _S.customNavColor or Color3.fromRGB(60, 60, 65)
			end
		end)
	end
end

local function applyNavColor(c, isActive)
	if isActive then
		_S.customNavActiveColor = c
	else
		_S.customNavColor = c
	end
	for name, navBtn in pairs(navButtons) do
		pcall(function()
			if name == currentPage then
				navBtn.BackgroundColor3 = _S.customNavActiveColor or Color3.fromRGB(100, 100, 110)
			else
				navBtn.BackgroundColor3 = _S.customNavColor or Color3.fromRGB(60, 60, 65)
			end
		end)
	end
end

-- Appliquer le son des boutons
local ContentProvider = game:GetService("ContentProvider")
local function applySound(soundId)
	if soundId and soundId ~= "" then
		hoverSound.SoundId = soundId
		clickSound.SoundId = soundId
		task.spawn(function()
			ContentProvider:PreloadAsync({hoverSound, clickSound})
		end)
	else
		hoverSound.SoundId = ""
		clickSound.SoundId = ""
	end
end

-- === UI: Couleur du Panel ===
do
	local lbl = Instance.new("TextLabel")
	lbl.Size = UDim2.new(1, 0, 0, 14)
	lbl.Position = UDim2.new(0, 0, 0, 50)
	lbl.BackgroundTransparency = 1
	lbl.Text = "Couleur du Panel"
	lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
	lbl.Font = Enum.Font.SourceSansBold
	lbl.TextSize = 13
	lbl.TextXAlignment = Enum.TextXAlignment.Left
	lbl.Parent = paramSection

	local panelColors = {
		Color3.fromRGB(8, 8, 12),
		Color3.fromRGB(8, 12, 30),
		Color3.fromRGB(8, 30, 12),
		Color3.fromRGB(20, 8, 30),
		Color3.fromRGB(30, 8, 8),
		Color3.fromRGB(30, 25, 10),
		Color3.fromRGB(10, 10, 10),
		Color3.fromRGB(25, 20, 30),
	}

	for i, c in ipairs(panelColors) do
		makeColorSwatch(paramSection, c, 68, (i - 1) * 26, applyPanelColor)
	end
end

-- === UI: Couleur des Boutons ===
do
	local lbl = Instance.new("TextLabel")
	lbl.Size = UDim2.new(1, 0, 0, 14)
	lbl.Position = UDim2.new(0, 0, 0, 96)
	lbl.BackgroundTransparency = 1
	lbl.Text = "Couleur des Boutons"
	lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
	lbl.Font = Enum.Font.SourceSansBold
	lbl.TextSize = 13
	lbl.TextXAlignment = Enum.TextXAlignment.Left
	lbl.Parent = paramSection

	local btnColors = {
		Color3.fromRGB(120, 30, 30),
		Color3.fromRGB(30, 60, 120),
		Color3.fromRGB(30, 120, 50),
		Color3.fromRGB(80, 30, 120),
		Color3.fromRGB(150, 80, 30),
		Color3.fromRGB(50, 50, 60),
		Color3.fromRGB(120, 100, 30),
		Color3.fromRGB(30, 100, 100),
	}

	for i, c in ipairs(btnColors) do
		makeColorSwatch(paramSection, c, 114, (i - 1) * 26, applyButtonColor)
	end
end

-- === UI: Couleur des Categories ===
do
	local lbl = Instance.new("TextLabel")
	lbl.Size = UDim2.new(1, 0, 0, 14)
	lbl.Position = UDim2.new(0, 0, 0, 142)
	lbl.BackgroundTransparency = 1
	lbl.Text = "Couleur des Categories"
	lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
	lbl.Font = Enum.Font.SourceSansBold
	lbl.TextSize = 13
	lbl.TextXAlignment = Enum.TextXAlignment.Left
	lbl.Parent = paramSection

	local navColors = {
		Color3.fromRGB(60, 60, 65),
		Color3.fromRGB(30, 50, 80),
		Color3.fromRGB(50, 30, 80),
		Color3.fromRGB(30, 70, 50),
		Color3.fromRGB(80, 60, 30),
		Color3.fromRGB(70, 30, 60),
		Color3.fromRGB(40, 40, 80),
		Color3.fromRGB(80, 50, 50),
	}

	for i, c in ipairs(navColors) do
		makeColorSwatch(paramSection, c, 160, (i - 1) * 26, function(color)
			applyNavColor(color, false)
		end)
	end
end

-- === UI: Son des Boutons ===
do
	local lbl = Instance.new("TextLabel")
	lbl.Size = UDim2.new(1, 0, 0, 14)
	lbl.Position = UDim2.new(0, 0, 0, 188)
	lbl.BackgroundTransparency = 1
	lbl.Text = "Son des Boutons"
	lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
	lbl.Font = Enum.Font.SourceSansBold
	lbl.TextSize = 13
	lbl.TextXAlignment = Enum.TextXAlignment.Left
	lbl.Parent = paramSection

	local soundOptions = {
		{name = "Original", id = "rbxassetid://88442833509532"},
		{name = "Click", id = "rbxassetid://9065073444"},
		{name = "Pop", id = "rbxassetid://72264591133889"},
		{name = "Modern", id = "rbxassetid://119393948345399"},
		{name = "Aucun", id = ""},
	}

	for i, opt in ipairs(soundOptions) do
		local soundBtn = btn(paramSection, opt.name, UDim2.new(0, (i - 1) * 48, 0, 204), UDim2.new(0, 44, 0, 20))
		soundBtn.TextSize = 12
		soundBtn.MouseButton1Click:Connect(function()
			applySound(opt.id)
			if opt.id and opt.id ~= "" then
				task.wait(0.1)
				clickSound:Play()
			end
		end)
	end
end

-- === UI: Reinitialiser ===
do
	local resetBtn = btn(paramSection, "Reinitialiser", UDim2.new(0, 0, 0, 230), UDim2.new(1, -2, 0, 22), Color3.fromRGB(50, 50, 60))
	resetBtn.Font = Enum.Font.SourceSansBold
	resetBtn.TextSize = 14
	resetBtn.MouseButton1Click:Connect(function()
		applyPanelColor(originalColors.panel)
		applyButtonColor(originalColors.btnDefault)
		_S.customBtnColor = nil
		_S.customNavColor = nil
		_S.customNavActiveColor = nil
		applyNavColor(originalColors.navColor, false)
		applyNavColor(originalColors.navActiveColor, true)
		applySound(originalSoundId)
	end)
end

local killPanelBtn = btn(paramSection, "Supprimer le panel", UDim2.new(0, 0, 0, 256), UDim2.new(1, -2, 0, 24), Color3.fromRGB(150, 30, 30))




killPanelBtn.Font = Enum.Font.SourceSansBold




killPanelBtn.TextSize = 15




-- Enregistrer les pages dans le système de navigation




registerPage("Joueurs", pSection)




registerPage("Deplacement", mSection)




registerPage("Actions", aSection)




registerPage("Position", posSection)




registerPage("Voice", vSection)




registerPage("Auto", auSection)




registerPage("Lock", lockSection)




registerPage("Infos", iSection)




registerPage("Parametres", paramSection)




-- Afficher la première page par défaut




switchPage("Joueurs")




local bagFrame, profileFrame




do




	-- === Page 2 (Omega) ===




	local page2 = Instance.new("Frame")




	page2.Size = UDim2.new(1, -10, 0, 200)




	page2.Position = UDim2.new(0, 5, 0, 5)




	page2.BackgroundColor3 = Color3.fromRGB(8, 8, 12)




	page2.BackgroundTransparency = 1




	page2.BorderSizePixel = 0




	page2.Visible = false




	page2.Parent = contentScroll




	Instance.new("UICorner", page2).CornerRadius = UDim.new(0, 10)




	-- Omega header




	local omegaHeader = Instance.new("TextLabel")




	omegaHeader.Size = UDim2.new(1, -20, 0, 18)




	omegaHeader.Position = UDim2.new(0, 10, 0, 10)




	omegaHeader.BackgroundTransparency = 1




	omegaHeader.Text = "Omega"




	omegaHeader.TextColor3 = Color3.fromRGB(255, 255, 255)




	omegaHeader.Font = Enum.Font.SourceSansBold




	omegaHeader.TextSize = 14




	omegaHeader.TextXAlignment = Enum.TextXAlignment.Left




	omegaHeader.Parent = page2




	do




		local oDesc = Instance.new("TextLabel")




		oDesc.Size = UDim2.new(1, -20, 0, 28)




		oDesc.Position = UDim2.new(0, 10, 0, 28)




		oDesc.BackgroundTransparency = 1




		oDesc.Text = "Executer Omega: lance le script Omega. Cacher Omega: masque l'interface Omega. Afficher Omega: réaffiche l'interface Omega. Kill Omega: arrête complètement Omega et libère les ressources."




		oDesc.TextColor3 = Color3.fromRGB(255, 255, 255)




		oDesc.Font = Enum.Font.SourceSans




		oDesc.TextSize = 12




		oDesc.TextWrapped = true




		oDesc.TextTruncate = Enum.TextTruncate.AtEnd




		oDesc.TextXAlignment = Enum.TextXAlignment.Left




		oDesc.TextYAlignment = Enum.TextYAlignment.Top




		oDesc.Parent = page2




	end




	local executeOmegaBtn = btn(page2, "Executer Omega", UDim2.new(0, 10, 0, 60), UDim2.new(1, -20, 0, 25), Color3.fromRGB(100, 30, 120))




	local hideOmegaBtn = btn(page2, "Cacher Omega", UDim2.new(0, 10, 0, 96), UDim2.new(1, -20, 0, 25), Color3.fromRGB(180, 100, 30))




	local setHideOmegaToggle = makeToggle(hideOmegaBtn, "Cacher Omega")




	local showOmegaBtn = btn(page2, "Afficher Omega", UDim2.new(0, 10, 0, 132), UDim2.new(1, -20, 0, 25), Color3.fromRGB(30, 130, 50))




	local setShowOmegaToggle = makeToggle(showOmegaBtn, "Afficher Omega")




	local killOmegaBtn = btn(page2, "Kill Omega", UDim2.new(0, 10, 0, 168), UDim2.new(1, -20, 0, 25), Color3.fromRGB(180, 40, 40))




	-- Initially disable Hide/Show buttons until Omega is executed




	hideOmegaBtn.Active = false




	hideOmegaBtn.AutoButtonColor = false




	hideOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




	showOmegaBtn.Active = false




	showOmegaBtn.AutoButtonColor = false




	showOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




	killOmegaBtn.Active = false




	killOmegaBtn.AutoButtonColor = false




	killOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




	registerPage("Omega", page2)




	-- Sac (backpack viewer - items cliquables)




	bagFrame = Instance.new("ScrollingFrame")




	bagFrame.Size = UDim2.new(1, 0, 0, 200)




	bagFrame.Position = UDim2.new(0, 0, 0, 140)




	bagFrame.BackgroundColor3 = Color3.fromRGB(20, 20, 30)




	bagFrame.BackgroundTransparency = 0




	bagFrame.BorderSizePixel = 0




	bagFrame.ScrollBarThickness = 4




	bagFrame.AutomaticCanvasSize = Enum.AutomaticSize.Y




	bagFrame.CanvasSize = UDim2.new(0, 0, 0, 0)




	bagFrame.Visible = false




	bagFrame.Parent = iSection




	Instance.new("UICorner", bagFrame).CornerRadius = UDim.new(0, 4)




	Instance.new("UIListLayout", bagFrame).Padding = UDim.new(0, 1)




	-- Profil frame




	profileFrame = Instance.new("ScrollingFrame")




	profileFrame.Size = UDim2.new(1, 0, 0, 200)




	profileFrame.Position = UDim2.new(0, 0, 0, 140)




	profileFrame.BackgroundColor3 = Color3.fromRGB(20, 20, 30)




	profileFrame.BackgroundTransparency = 0




	profileFrame.BorderSizePixel = 0




	profileFrame.ScrollBarThickness = 4




	profileFrame.AutomaticCanvasSize = Enum.AutomaticSize.Y




	profileFrame.CanvasSize = UDim2.new(0, 0, 0, 0)




	profileFrame.Visible = false




	profileFrame.Parent = iSection




	Instance.new("UICorner", profileFrame).CornerRadius = UDim.new(0, 4)




	Instance.new("UIListLayout", profileFrame).Padding = UDim.new(0, 2)




	-- EXECUTE SCRIPT




	local function createFakeRunService()




		return setmetatable({}, {




			__index = function(t, k)




				if _S.omegaKilled then




					if k == "BindToRenderStep" or k == "UnbindFromRenderStep" then




						return function() end




					end




					if k == "RenderStepped" or k == "Heartbeat" or k == "Stepped" then




						return setmetatable({}, {




							__index = function(_, key)




								if key == "Connect" or key == "ConnectParallel" then




									return function() return {Disconnect = function() end} end




								end




								if key == "Wait" then




									return function() error("Omega killed") end




								end




								return function() end




							end




						})




					end




					return function() end




				end




				local val = RunService[k]




				if k == "BindToRenderStep" then




					return function(_, name, priority, func)




						table.insert(_S.omegaRenderStepNames, name)




						return RunService:BindToRenderStep(name, priority, func)




					end




				end




				if k == "UnbindFromRenderStep" then




					return function(_, name)




						for i, n in ipairs(_S.omegaRenderStepNames) do




							if n == name then table.remove(_S.omegaRenderStepNames, i) break end




						end




						return RunService:UnbindFromRenderStep(name)




					end




				end




				if k == "RenderStepped" or k == "Heartbeat" or k == "Stepped" then




					local signal = val




					return setmetatable({}, {




						__index = function(_, key)




							if key == "Connect" then




								return function(_, func)




									local conn = signal:Connect(func)




									table.insert(_S.omegaConnections, conn)




									return conn




								end




							end




							if key == "ConnectParallel" then




								return function(_, func)




									local conn = signal:ConnectParallel(func)




									table.insert(_S.omegaConnections, conn)




									return conn




								end




							end




							if key == "Wait" then




								return function(_, ...) return signal:Wait(...) end




							end




							return signal[key]




						end,




						__tostring = function() return tostring(signal) end




					})




				end




				if type(val) == "function" then




					return function(_, ...) return val(RunService, ...) end




				end




				return val




			end




		})




	end




	local function createFakeGame()




		local fakeGame = setmetatable({}, {




			__index = function(t, k)




				local val = game[k]




				if k == "GetService" then




					return function(_, serviceName)




						local service = game:GetService(serviceName)




						if serviceName == "RunService" then




							return createFakeRunService()




						end




						if serviceName == "UserInputService" then




							return setmetatable({}, {




								__index = function(_, key)




									if _S.omegaKilled then




										if key == "InputBegan" or key == "InputEnded" or key == "InputChanged" then




											return setmetatable({}, {




												__index = function(_, skey)




													if skey == "Connect" or skey == "ConnectParallel" then




														return function() return {Disconnect = function() end} end




													end




													return function() end




												end




											})




										end




									end




									local sval = service[key]




									if key == "InputBegan" or key == "InputEnded" or key == "InputChanged" then




										return setmetatable({}, {




											__index = function(_, skey)




												if skey == "Connect" then




													return function(_, func)




														local conn = sval:Connect(func)




														table.insert(_S.omegaConnections, conn)




														return conn




													end




												end




												if skey == "ConnectParallel" then




													return function(_, func)




														local conn = sval:ConnectParallel(func)




														table.insert(_S.omegaConnections, conn)




														return conn




													end




												end




												if skey == "Wait" then




													return function(_, ...) return sval:Wait(...) end




												end




												return sval[skey]




											end,




											__tostring = function() return tostring(sval) end




										})




									end




									if type(sval) == "function" then




										return function(_, ...) return sval(service, ...) end




									end




									return sval




								end,




								__newindex = function(_, key, value)




									service[key] = value




								end,




								__tostring = function() return tostring(service) end




							})




						end




						return service




					end




				end




				if type(val) == "function" then




					return function(_, ...) return val(game, ...) end




				end




				return val




			end,




			__tostring = function() return tostring(game) end




		})




		return fakeGame




	end




	executeOmegaBtn.MouseButton1Click:Connect(function()




		if _S.omegaHasExecuted then return end




		_S.omegaHasExecuted = true




		executeOmegaBtn.Active = false




		executeOmegaBtn.Text = "Execution..."




		executeOmegaBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




		-- Arrêter tout nettoyage précédent (pour permettre l'exécution à l'infini)




		_S.omegaCleanupGeneration = _S.omegaCleanupGeneration + 1




		if _S.omegaForceResetConn then




			pcall(function() _S.omegaForceResetConn:Disconnect() end)




			_S.omegaForceResetConn = nil




		end




		-- Déconnecter les anciennes connexions et débind les anciens RenderStep




		for _, conn in ipairs(_S.omegaConnections) do




			pcall(function() conn:Disconnect() end)




		end




		for _, name in ipairs(_S.omegaRenderStepNames) do




			pcall(function() RunService:UnbindFromRenderStep(name) end)




		end




		-- Annuler les anciens threads




		for _, thread in ipairs(_S.omegaThreads) do




			pcall(function() task.cancel(thread) end)




		end




		-- Détruire les anciennes instances




		for _, inst in ipairs(_S.omegaCreatedInstances) do




			pcall(function()




				if inst and inst.Parent then inst:Destroy() end




			end)




		end




		local playerGui = player:FindFirstChildOfClass("PlayerGui")




		if playerGui then




			_S.omegaGuiSnapshot = {}




			for _, child in playerGui:GetChildren() do




				_S.omegaGuiSnapshot[child] = true




			end




		end




		-- Snapshot CoreGui aussi (le script Omega peut créer des GUIs là)




		_S.omegaCoreGuiSnapshot = {}




		pcall(function()




			local coreGui = game:GetService("CoreGui")




			if coreGui then




				for _, child in coreGui:GetChildren() do




					_S.omegaCoreGuiSnapshot[child] = true




				end




			end




		end)




		_S.omegaRenderStepNames = {}




		_S.omegaConnections = {}




		_S.omegaCreatedInstances = {}




		_S.omegaKilled = false




		_S.omegaThreads = {}




		_S.omegaHiddenStates = {}




		local fakeRS = createFakeRunService()




		local fakeG = createFakeGame()




		local fakeInstance = setmetatable({}, {




			__index = function(_, key)




				if key == "new" then




					return function(className, parent)




						if _S.omegaKilled then return nil end




						local inst = Instance.new(className, parent)




						table.insert(_S.omegaCreatedInstances, inst)




						return inst




					end




				end




				return Instance[key]




			end,




			__tostring = function() return tostring(Instance) end




		})




		local fakeTask = setmetatable({}, {




			__index = function(_, k)




				local val = task[k]




				if _S.omegaKilled then




					if k == "spawn" or k == "delay" or k == "defer" then




						return function() end




					end




					if k == "wait" then




						return function() error("Omega killed") end




					end




				end




				if k == "spawn" then




					return function(f, ...)




						local thread = task.spawn(f, ...)




						table.insert(_S.omegaThreads, thread)




						return thread




					end




				end




				if k == "delay" then




					return function(d, f, ...)




						local thread = task.delay(d, f, ...)




						table.insert(_S.omegaThreads, thread)




						return thread




					end




				end




				if k == "defer" then




					return function(f, ...)




						local thread = task.defer(f, ...)




						table.insert(_S.omegaThreads, thread)




						return thread




					end




				end




				if type(val) == "function" then




					return function(_, ...) return val(...) end




				end




				return val




			end




		})




		local fakeCoroutine = setmetatable({}, {




			__index = function(_, k)




				if _S.omegaKilled then




					if k == "create" then




						return function() return coroutine.create(function() end) end




					end




					if k == "wrap" then




						return function() return function() end end




					end




					if k == "resume" then




						return function() return false, "killed" end




					end




				end




				local val = coroutine[k]




				if k == "create" then




					return function(f)




						local co = coroutine.create(f)




						table.insert(_S.omegaThreads, co)




						return co




					end




				end




				if k == "wrap" then




					return function(f)




						local co = coroutine.create(f)




						table.insert(_S.omegaThreads, co)




						return function(...)




							return coroutine.resume(co, ...)




						end




					end




				end




				if type(val) == "function" then




					return function(_, ...) return val(...) end




				end




				return val




			end




		})




		local omegaEnv = setmetatable({}, {




			__index = function(t, k)




				if k == "RunService" then return fakeRS end




				if k == "game" then return fakeG end




				if k == "Instance" then return fakeInstance end




				if k == "task" then return fakeTask end




				if k == "coroutine" then return fakeCoroutine end




				if k == "wait" then




					if _S.omegaKilled then return function() error("Omega killed") end end




					return task.wait




				end




				if k == "spawn" then




					if _S.omegaKilled then return function() end end




					return function(f, ...)




						local thread = task.spawn(f, ...)




						table.insert(_S.omegaThreads, thread)




						return thread




					end




				end




				if k == "delay" then




					if _S.omegaKilled then return function() end end




					return function(d, f, ...)




						local thread = task.delay(d, f, ...)




						table.insert(_S.omegaThreads, thread)




						return thread




					end




				end




				return getfenv()[k]




			end




		})




		local success, result = pcall(function()




			local func = loadstring(game:HttpGet("https://rawscripts.net/raw/School-RP-V3-FR-School-rp-fr-omega-219467"))




			if func then




				setfenv(func, omegaEnv)




				return func()




			end




		end)




		if success then




			executeOmegaBtn.Text = "Omega executé"




			executeOmegaBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




			-- Enable Hide button (Omega is visible by default, so Show stays disabled)




			hideOmegaBtn.Active = true




			hideOmegaBtn.AutoButtonColor = true




			hideOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




			showOmegaBtn.Active = false




			showOmegaBtn.AutoButtonColor = false




			showOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




			killOmegaBtn.Active = true




			killOmegaBtn.AutoButtonColor = true




			killOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		else




			executeOmegaBtn.Text = "Erreur Omega"




			executeOmegaBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




			executeOmegaBtn.Active = true




			_S.omegaHasExecuted = false




			killOmegaBtn.Active = false




			killOmegaBtn.AutoButtonColor = false




			killOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		end




	end)




	-- CACHER OMEGA




	hideOmegaBtn.MouseButton1Click:Connect(function()




		if not _S.omegaHasExecuted or _S.omegaKilled then return end




		_S.omegaHiddenStates = {}




		-- Cacher les instances tracées en sauvegardant leur état original




		for _, inst in ipairs(_S.omegaCreatedInstances) do




			pcall(function()




				if inst and inst.Parent then




					if inst:IsA("ScreenGui") then




						_S.omegaHiddenStates[inst] = {enabled = inst.Enabled}




						inst.Enabled = false




					elseif inst:IsA("BasePart") then




						_S.omegaHiddenStates[inst] = {transparency = inst.Transparency, canCollide = inst.CanCollide}




						inst.Transparency = 1




						inst.CanCollide = false




					elseif inst:IsA("Decal") or inst:IsA("Texture") then




						_S.omegaHiddenStates[inst] = {transparency = inst.Transparency}




						inst.Transparency = 1




					elseif inst:IsA("Sound") then




						_S.omegaHiddenStates[inst] = {volume = inst.Volume}




						inst.Volume = 0




					elseif inst:IsA("BillboardGui") or inst:IsA("SurfaceGui") then




						_S.omegaHiddenStates[inst] = {enabled = inst.Enabled}




						inst.Enabled = false




					elseif inst:IsA("ParticleEmitter") or inst:IsA("Trail") or inst:IsA("Beam") or inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then




						_S.omegaHiddenStates[inst] = {enabled = inst.Enabled}




						inst.Enabled = false




					end




				end




			end)




		end




		-- Cacher aussi les GUIs dans PlayerGui qui n'etaient pas la avant Omega




		local playerGui = player:FindFirstChildOfClass("PlayerGui")




		if playerGui then




			for _, child in playerGui:GetChildren() do




				if not _S.omegaGuiSnapshot[child] and child.Name ~= "AdminPanel" then




					pcall(function()




						if child:IsA("ScreenGui") then




							_S.omegaHiddenStates[child] = {enabled = child.Enabled}




							child.Enabled = false




						elseif child:IsA("Folder") then




							for _, desc in child:GetDescendants() do




								if desc:IsA("ScreenGui") then




									_S.omegaHiddenStates[desc] = {enabled = desc.Enabled}




									desc.Enabled = false




								elseif desc:IsA("GuiObject") then




									_S.omegaHiddenStates[desc] = {visible = desc.Visible}




									desc.Visible = false




								end




							end




						end




					end)




				end




			end




		end




		-- Cacher aussi les GUIs dans CoreGui qui n'etaient pas la avant Omega




		local coreGui = game:GetService("CoreGui")




		for _, child in coreGui:GetChildren() do




			if not _S.omegaCoreGuiSnapshot[child] then




				pcall(function()




					if child:IsA("ScreenGui") then




						_S.omegaHiddenStates[child] = {enabled = child.Enabled}




						child.Enabled = false




					end




				end)




			end




		end












		setHideOmegaToggle(true)




		setShowOmegaToggle(false)




		-- Disable Hide (already hidden), enable Show




		hideOmegaBtn.Active = false




		hideOmegaBtn.AutoButtonColor = false




		hideOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		showOmegaBtn.Active = true




		showOmegaBtn.AutoButtonColor = true




		showOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




	end)




	-- AFFICHER OMEGA




	showOmegaBtn.MouseButton1Click:Connect(function()




		if not _S.omegaHasExecuted or _S.omegaKilled then return end




		-- Afficher les instances tracées en restaurant leur état original




		for _, inst in ipairs(_S.omegaCreatedInstances) do




			pcall(function()




				if inst and inst.Parent then




					local saved = _S.omegaHiddenStates[inst]




					if inst:IsA("ScreenGui") then




						inst.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




					elseif inst:IsA("BasePart") then




						inst.Transparency = (saved and saved.transparency ~= nil) and saved.transparency or 0




						inst.CanCollide = (saved and saved.canCollide ~= nil) and saved.canCollide or true




					elseif inst:IsA("Decal") or inst:IsA("Texture") then




						inst.Transparency = (saved and saved.transparency ~= nil) and saved.transparency or 0




					elseif inst:IsA("Sound") then




						inst.Volume = (saved and saved.volume ~= nil) and saved.volume or 1




					elseif inst:IsA("BillboardGui") or inst:IsA("SurfaceGui") then




						inst.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




					elseif inst:IsA("ParticleEmitter") or inst:IsA("Trail") or inst:IsA("Beam") or inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then




						inst.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




					end




				end




			end)




		end




		-- Afficher aussi les GUIs dans PlayerGui qui n'etaient pas la avant Omega




		local playerGui = player:FindFirstChildOfClass("PlayerGui")




		if playerGui then




			for _, child in playerGui:GetChildren() do




				if not _S.omegaGuiSnapshot[child] and child.Name ~= "AdminPanel" then




					pcall(function()




						if child:IsA("ScreenGui") then




							local saved = _S.omegaHiddenStates[child]




							child.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




						elseif child:IsA("Folder") then




							for _, desc in child:GetDescendants() do




								local saved = _S.omegaHiddenStates[desc]




								if desc:IsA("ScreenGui") then




									desc.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




								elseif desc:IsA("GuiObject") then




									desc.Visible = (saved and saved.visible ~= nil) and saved.visible or true




								end




							end




						end




					end)




				end




			end




		end




		-- Afficher aussi les GUIs dans CoreGui qui n'etaient pas la avant Omega




		local coreGui = game:GetService("CoreGui")




		for _, child in coreGui:GetChildren() do




			if not _S.omegaCoreGuiSnapshot[child] then




				pcall(function()




					if child:IsA("ScreenGui") then




						local saved = _S.omegaHiddenStates[child]




						child.Enabled = (saved and saved.enabled ~= nil) and saved.enabled or true




					end




				end)




			end




		end




		_S.omegaHiddenStates = {}












		setShowOmegaToggle(true)




		setHideOmegaToggle(false)




		-- Disable Show (already shown), enable Hide




		showOmegaBtn.Active = false




		showOmegaBtn.AutoButtonColor = false




		showOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		hideOmegaBtn.Active = true




		hideOmegaBtn.AutoButtonColor = true




		hideOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




	end)




	-- KILL OMEGA (ne peut etre relancé qu'en quittant et revenant)




	killOmegaBtn.MouseButton1Click:Connect(function()




		if not _S.omegaHasExecuted or _S.omegaKilled then return end




		_S.omegaKilled = true




		-- Déconnecter toutes les connexions




		for _, conn in ipairs(_S.omegaConnections) do




			pcall(function() conn:Disconnect() end)




		end



		_S.omegaConnections = {}




		-- Débind tous les RenderStep




		for _, name in ipairs(_S.omegaRenderStepNames) do




			pcall(function() RunService:UnbindFromRenderStep(name) end)




		end




		_S.omegaRenderStepNames = {}




		-- Annuler tous les threads




		for _, thread in ipairs(_S.omegaThreads) do




			pcall(function() task.cancel(thread) end)




		end




		_S.omegaThreads = {}




		-- Détruire toutes les instances créées par Omega




		for _, inst in ipairs(_S.omegaCreatedInstances) do




			pcall(function()




				if inst and inst.Parent then inst:Destroy() end




			end)




		end




		_S.omegaCreatedInstances = {}




		-- Réinitialiser les snapshots et états




		_S.omegaGuiSnapshot = {}




		_S.omegaCoreGuiSnapshot = {}




		_S.omegaHiddenStates = {}




		-- Le bouton Execute reste désactivé — Omega ne peut etre relancé qu'en quittant et revenant




		executeOmegaBtn.Active = false




		executeOmegaBtn.AutoButtonColor = false




		executeOmegaBtn.Text = "Omega Killed (quittez & revenez)"




		executeOmegaBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




		executeOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		-- Désactiver tous les boutons de la Page 2 sauf le bouton Retour




		hideOmegaBtn.Active = false




		hideOmegaBtn.AutoButtonColor = false




		hideOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)








		showOmegaBtn.Active = false




		showOmegaBtn.AutoButtonColor = false




		showOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)








		setHideOmegaToggle(false)




		setShowOmegaToggle(false)




		killOmegaBtn.Active = false




		killOmegaBtn.AutoButtonColor = false




		killOmegaBtn.TextColor3 = Color3.fromRGB(255, 255, 255)




		-- Feedback visuel sur le bouton Kill




		killOmegaBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




		killOmegaBtn.Text = "Omega Killed!"




		task.wait(1)




		killOmegaBtn.Text = "Omega Killed (quittez & revenez)"




		killOmegaBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




	end)




end




-- === FONCTIONS ===




-- SPECTATE




function startSpectate(targetPlayer)




	if not targetPlayer or not targetPlayer.Parent then




		return false




	end




	if _S.spectatingPlayer == targetPlayer then




		return false




	end




	stopSpectate()




	_S.spectatingPlayer = targetPlayer




	local function onCharAdded(char)




		local hum = char:FindFirstChildOfClass("Humanoid")




		if hum then




			-- CameraType not forced to avoid sync errors with custom camera games




			camera.CameraSubject = hum




		end




	end




	if targetPlayer.Character then




		onCharAdded(targetPlayer.Character)




	end




	spectateCharConn = targetPlayer.CharacterAdded:Connect(onCharAdded)




	return true




end




function stopSpectate()




	_S.spectatingPlayer = nil




	if spectateCharConn then




		spectateCharConn:Disconnect()




		spectateCharConn = nil




	end









	local char = player.Character




	if char then




		local hum = char:FindFirstChildOfClass("Humanoid")




		if hum then




			-- CameraType not forced to avoid sync errors with custom camera games




			camera.CameraSubject = hum




		end




	end




end
-- Non-aggressive spectate camera guard: only re-applies CameraSubject when changed by other scripts




local spectateCameraGuardConn




local function refreshSpectateCameraGuard()




	if spectateCameraGuardConn then




		spectateCameraGuardConn:Disconnect()




		spectateCameraGuardConn = nil




	end




	spectateCameraGuardConn = camera:GetPropertyChangedSignal("CameraSubject"):Connect(function()




		if _S.spectatingPlayer and _S.spectatingPlayer.Parent and _S.spectatingPlayer.Character then




			local hum = _S.spectatingPlayer.Character:FindFirstChildOfClass("Humanoid")




			if hum and camera.CameraSubject ~= hum then




				camera.CameraSubject = hum




			end




		end




	end)




end




refreshSpectateCameraGuard()




-- ESP




local function getESPColor(p)




	local team = p.Team




	if team and team.TeamColor then




		return team.TeamColor.Color




	end




	return Color3.fromRGB(255, 255, 0)




end




local function applyESP(p)




	if not p or not p.Character then return end




	local char = p.Character




	local espColor = getESPColor(p)




	local hl = Instance.new("Highlight")




	hl.Name = "ESP_HL"




	hl.FillColor = espColor




	hl.FillTransparency = 0.5




	hl.OutlineColor = Color3.fromRGB(255, 255, 255)




	hl.OutlineTransparency = 0




	hl.Parent = char




	local bb = Instance.new("BillboardGui")




	bb.Name = "ESP_BB"




	bb.Size = UDim2.new(0, 200, 0, 60)




	bb.StudsOffset = Vector3.new(0, 4, 0)




	bb.AlwaysOnTop = true




	bb.Parent = char




	local lbl = Instance.new("TextLabel")




	lbl.Size = UDim2.new(1, 0, 0, 20)




	lbl.BackgroundTransparency = 1




	lbl.Text = p.Name




	lbl.TextColor3 = espColor




	lbl.Font = Enum.Font.SourceSansBold




	lbl.TextSize = 16




	lbl.Parent = bb




	local roleLbl = Instance.new("TextLabel")




	roleLbl.Name = "RoleLabel"




	roleLbl.Size = UDim2.new(1, 0, 0, 20)




	roleLbl.Position = UDim2.new(0, 0, 0, 20)




	roleLbl.BackgroundTransparency = 1




	local team = p.Team




	if team then




		roleLbl.Text = team.Name




		local tc = team.TeamColor




		if tc then roleLbl.TextColor3 = tc.Color else roleLbl.TextColor3 = espColor end




	else




		roleLbl.Text = "Aucune équipe"




		roleLbl.TextColor3 = Color3.fromRGB(255, 255, 0)




	end




	roleLbl.Font = Enum.Font.SourceSans




	roleLbl.TextSize = 13




	roleLbl.Parent = bb




	local hpLbl = Instance.new("TextLabel")




	hpLbl.Name = "HPLabel"




	hpLbl.Size = UDim2.new(1, 0, 0, 20)




	hpLbl.Position = UDim2.new(0, 0, 0, 40)




	hpLbl.BackgroundTransparency = 1




	hpLbl.Text = ""




	hpLbl.TextColor3 = Color3.fromRGB(255, 255, 255)




	hpLbl.Font = Enum.Font.SourceSansBold




	hpLbl.TextSize = 14




	hpLbl.Visible = false




	hpLbl.Parent = bb




	_S.espObjects[p] = {hl = hl, bb = bb}




end




local function removeESP(p)




	if _S.espObjects[p] then




		if _S.espObjects[p].hl then _S.espObjects[p].hl:Destroy() end




		if _S.espObjects[p].bb then _S.espObjects[p].bb:Destroy() end




		_S.espObjects[p] = nil




	end




end




local function refreshESP()




	for _, p in Players:GetPlayers() do




		if p ~= player then




			if _S.espEnabled then




				-- Only apply if not already applied or if character changed




				if not _S.espObjects[p] or not _S.espObjects[p].hl or not _S.espObjects[p].hl.Parent then




					removeESP(p)




					applyESP(p)




				else




					-- Mettre à jour la couleur si l'équipe a changé




					local espColor = getESPColor(p)




					if _S.espObjects[p].hl then




						_S.espObjects[p].hl.FillColor = espColor




					end




					if _S.espObjects[p].bb then




						local lbl = _S.espObjects[p].bb:FindFirstChildOfClass("TextLabel")




						if lbl then




							lbl.TextColor3 = espColor




						end




						local roleLbl = _S.espObjects[p].bb:FindFirstChild("RoleLabel")




						if roleLbl then




							local team = p.Team




							if team then




								roleLbl.Text = team.Name




								local tc = team.TeamColor




								if tc then roleLbl.TextColor3 = tc.Color else roleLbl.TextColor3 = espColor end




							else




								roleLbl.Text = "Aucune équipe"




								roleLbl.TextColor3 = Color3.fromRGB(255, 255, 0)




							end




						end




					end




				end




			else




				removeESP(p)




			end




		end




	end




end




-- VITESSE




applySpeed = function()




	local char = player.Character




	if char then




		local hum = char:FindFirstChildOfClass("Humanoid")




		if hum then hum.WalkSpeed = _S.speedEnabled and _S.speedValue or 16 end




	end




end




-- FLY




local function setupFly()


	local char = player.Character


	if not char then return end


	local hrp = char:FindFirstChild("HumanoidRootPart")


	local hum = char:FindFirstChildOfClass("Humanoid")


	if not hrp or not hum then return end


	if _S.flyVelocity then _S.flyVelocity:Destroy() end


	if _S.flyGyro then _S.flyGyro:Destroy() end


	_S.flyVelocity = Instance.new("BodyVelocity")


	_S.flyVelocity.MaxForce = Vector3.new(400000, 400000, 400000)


	_S.flyVelocity.Velocity = Vector3.new(0, 0, 0)


	_S.flyVelocity.Parent = hrp


	_S.flyGyro = Instance.new("BodyGyro")


	_S.flyGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)


	_S.flyGyro.P = 50000


	_S.flyGyro.D = 400


	_S.flyGyro.CFrame = hrp.CFrame


	_S.flyGyro.Parent = hrp


	hum.PlatformStand = true



















end




local function disableFly()


	if _S.flyVelocity then _S.flyVelocity:Destroy() _S.flyVelocity = nil end


	if _S.flyGyro then _S.flyGyro:Destroy() _S.flyGyro = nil end


	local char = player.Character


	if char then


		local hum = char:FindFirstChildOfClass("Humanoid")


		if hum then hum.PlatformStand = false end


	end















end




-- === SWIM (Nager dans l'air) ===
local function setupSwim()
	local char = player.Character
	if not char then return end
	local hrp = char:FindFirstChild("HumanoidRootPart")
	local hum = char:FindFirstChildOfClass("Humanoid")
	if not hrp or not hum then return end
	if _S.swimVelocity then _S.swimVelocity:Destroy() end
	if _S.swimGyro then _S.swimGyro:Destroy() end
	_S.swimVelocity = Instance.new("BodyVelocity")
	_S.swimVelocity.MaxForce = Vector3.new(400000, 400000, 400000)
	_S.swimVelocity.Velocity = Vector3.new(0, 0, 0)
	_S.swimVelocity.Parent = hrp
	_S.swimGyro = Instance.new("BodyGyro")
	_S.swimGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)
	_S.swimGyro.P = 50000
	_S.swimGyro.D = 400
	_S.swimGyro.CFrame = hrp.CFrame
	_S.swimGyro.Parent = hrp
	hum:SetStateEnabled(Enum.HumanoidStateType.Freefall, false)
	hum:ChangeState(Enum.HumanoidStateType.Swimming)
end

local function disableSwim()
	if _S.swimVelocity then _S.swimVelocity:Destroy() _S.swimVelocity = nil end
	if _S.swimGyro then _S.swimGyro:Destroy() _S.swimGyro = nil end
	local char = player.Character
	if char then
		local hum = char:FindFirstChildOfClass("Humanoid")
		if hum then
			hum:SetStateEnabled(Enum.HumanoidStateType.Freefall, true)
		end
	end
end

-- === LISTE DES JOUEURS ===




local entries = {}




local searchText = ""




-- Refresh sans flicker: met à jour en place, crée/supprime seulement si nécessaire




local function refreshList()




	local seen = {}




	for _, p in Players:GetPlayers() do




		seen[p] = true




		local teamName = p.Team and p.Team.Name or "Aucune"




		local text = string.format("%s (%s) | ID: %d | %s", p.Name, p.DisplayName, p.UserId, teamName)




		if entries[p] then




			-- Entrée existe: juste mettre à jour le texte et la couleur




			local e = entries[p]




			local lbl = e:FindFirstChildOfClass("TextLabel")




			if lbl and lbl.Text ~= text then lbl.Text = text end




			local newColor = (p == _S.selectedPlayer) and Color3.fromRGB(55, 75, 115) or Color3.fromRGB(30, 30, 45)




			if e.BackgroundColor3 ~= newColor then e.BackgroundColor3 = newColor end




		else




			-- Nouvelle entrée




			local e = Instance.new("TextButton")




			e.Name = p.Name




			e.Size = UDim2.new(1, -6, 0, 26)




			e.BackgroundColor3 = (p == _S.selectedPlayer) and Color3.fromRGB(55, 75, 115) or Color3.fromRGB(30, 30, 45)




			e.BackgroundTransparency = 0.12




			e.Text = ""




			e.BorderSizePixel = 0




			e.Parent = pScroll




			Instance.new("UICorner", e).CornerRadius = UDim.new(0, 4)




			-- Avatar du joueur




			local avBg = Instance.new("Frame")




			avBg.Size = UDim2.new(0, 22, 0, 22)




			avBg.Position = UDim2.new(0, 4, 0.5, -11)




			avBg.BackgroundColor3 = Color3.fromRGB(40, 40, 55)




			avBg.BorderSizePixel = 0




			avBg.Parent = e




			Instance.new("UICorner", avBg).CornerRadius = UDim.new(1, 0)




			local avImg = Instance.new("ImageLabel")




			avImg.Size = UDim2.new(1, -2, 1, -2)




			avImg.Position = UDim2.new(0, 1, 0, 1)




			avImg.BackgroundColor3 = Color3.fromRGB(30, 30, 40)




			avImg.BorderSizePixel = 0




			avImg.Image = ""




			avImg.Parent = avBg




			Instance.new("UICorner", avImg).CornerRadius = UDim.new(1, 0)




			local lbl = Instance.new("TextLabel")




			lbl.Size = UDim2.new(1, -36, 1, 0)




			lbl.Position = UDim2.new(0, 32, 0, 0)




			lbl.BackgroundTransparency = 1




			lbl.Text = text




			lbl.TextColor3 = Color3.fromRGB(255, 255, 255)




			lbl.Font = Enum.Font.SourceSans




			lbl.TextSize = 14




			lbl.TextXAlignment = Enum.TextXAlignment.Left




			lbl.TextTruncate = Enum.TextTruncate.AtEnd




			lbl.Parent = e




			-- Charger l'avatar du joueur




			task.spawn(function()




				local success, result = pcall(function()




					return Players:GetUserThumbnailAsync(p.UserId, Enum.ThumbnailType.HeadShot, Enum.ThumbnailSize.Size420x420)




				end)




				if success and result and avImg and avImg.Parent then




					avImg.Image = result




				end




			end)




			e.MouseButton1Click:Connect(function()




				clickSound:Play()




				_S.selectedPlayer = p




				refreshList()




				if updateVolLabel then updateVolLabel() end




			end)




			entries[p] = e




		end




	end




	-- Supprimer seulement les entrées des joueurs partis




	for p, e in pairs(entries) do




		if not seen[p] then




			if e and e.Parent then e:Destroy() end




			entries[p] = nil




		end




	end




	-- Filtrer par recherche




	local search = string.lower(searchText)




	for p, e in pairs(entries) do




		local match = search == "" or




			string.find(string.lower(p.Name), search, 1, true) or




			string.find(string.lower(p.DisplayName), search, 1, true)




		e.Visible = match and true or false




	end




end




refreshList()




searchBox:GetPropertyChangedSignal("Text"):Connect(function()




	searchText = searchBox.Text




	refreshList()




end)




Players.PlayerAdded:Connect(refreshList)




Players.PlayerRemoving:Connect(function(p)




	if p == _S.selectedPlayer then _S.selectedPlayer = nil end




	if p == _S.spectatingPlayer then stopSpectate() end




	refreshList()




end)




-- Refresh continu invisible (met à jour les équipes etc. sans recréer)




task.spawn(function()




	while task.wait(2) do




		refreshList()




	end




end)




-- === CONNEXIONS BOUTONS ===




-- ESP




local function setupESPChar(p)




	if p == player then return end -- Ne pas mettre l'ESP sur soi-mme




	p.CharacterAdded:Connect(function(char)




		if _S.espEnabled then




			-- Wait for character to be fully loaded




			task.wait(0.5)




			if p.Character and p.Character.Parent then




				removeESP(p)




				applyESP(p)




			end




		end




	end)




end




for _, p in Players:GetPlayers() do setupESPChar(p) end




Players.PlayerAdded:Connect(function(p)




	setupESPChar(p)




	refreshList()




	if _S.espEnabled then




		-- Wait for the new player's character to spawn




		task.spawn(function()




			-- Wait for character




			local waited = 0




			while not p.Character and waited < 10 do




				task.wait(0.5)




				waited = waited + 0.5




			end




			if p.Character and _S.espEnabled then




				removeESP(p)




				applyESP(p)




			end




		end)




	end




end)




Players.PlayerRemoving:Connect(function(p) removeESP(p) end)




-- Continuous ESP monitor: ensures ESP stays active on all players




task.spawn(function()




	while task.wait(0.5) do




		if _S.espEnabled then




			-- Nettoyer l'ESP sur soi-mme si prsent




			removeESP(player)




			for _, p in Players:GetPlayers() do




				if p ~= player then




					local needsESP = false




					if not _S.espObjects[p] then




						needsESP = true




					elseif not _S.espObjects[p].hl or not _S.espObjects[p].hl.Parent then




						needsESP = true




					elseif not _S.espObjects[p].bb or not _S.espObjects[p].bb.Parent then




						needsESP = true




					end




					if needsESP then




						if p.Character and p.Character.Parent then




							removeESP(p)




							applyESP(p)




						end




					end




				end




			end




		end




	end




end)




espBtn.MouseButton1Click:Connect(function()




	_S.espEnabled = not _S.espEnabled




	setESPToggle(_S.espEnabled)




	if _S.espEnabled then








	else








	end




	refreshESP()




end)




-- Vitesse




speedBtn.MouseButton1Click:Connect(function()




	_S.speedEnabled = not _S.speedEnabled




	setSpeedToggle(_S.speedEnabled)




	if _S.speedEnabled then








	else








	end




	applySpeed()




end)




speedDownBtn.MouseButton1Click:Connect(function()
	_S.speedValue = math.max(1, _S.speedValue - 10)
	speedValueLabel.Text = tostring(_S.speedValue)
	walkUpdateSlider(true)
	if _S.speedEnabled then
		applySpeed()
	end
end)
speedUpBtn.MouseButton1Click:Connect(function()
	_S.speedValue = _S.speedValue + 10
	speedValueLabel.Text = tostring(_S.speedValue)
	walkUpdateSlider(true)
	if _S.speedEnabled then
		applySpeed()
	end
end)





-- Fly speed +/- controls




flySpeedDownBtn.MouseButton1Click:Connect(function()




	_S.flySpeed = math.max(1, _S.flySpeed - 10)




	flySpeedValueLabel.Text = tostring(_S.flySpeed)




end)




flySpeedUpBtn.MouseButton1Click:Connect(function()




	_S.flySpeed = _S.flySpeed + 10




	flySpeedValueLabel.Text = tostring(_S.flySpeed)




end)




-- Fly




flyBtn.MouseButton1Click:Connect(function()




	_S.flyEnabled = not _S.flyEnabled




	setFlyToggle(_S.flyEnabled)




	if _S.flyEnabled then








		setupFly()




	else








		disableFly()




	end




end)




-- Swim (Nager dans l'air)
_S.swimBtn.MouseButton1Click:Connect(function()
	_S.swimEnabled = not _S.swimEnabled
	_S.setSwimToggle(_S.swimEnabled)
	if _S.swimEnabled then
		setupSwim()
	else
		disableSwim()
	end
end)

_S.swimSpeedDownBtn.MouseButton1Click:Connect(function()
	_S.swimSpeed = math.max(1, _S.swimSpeed - 10)
	_S.swimSpeedValueLabel.Text = tostring(_S.swimSpeed)
	_S.swimUpdateSlider(true)
end)

_S.swimSpeedUpBtn.MouseButton1Click:Connect(function()
	_S.swimSpeed = _S.swimSpeed + 10
	_S.swimSpeedValueLabel.Text = tostring(_S.swimSpeed)
	_S.swimUpdateSlider(true)
end)

-- Boucle de surveillance: réapplique Walk et Fly en permanence s'ils sont activés




-- Empêche d'autres scripts ou Roblox de réinitialiser la vitesse sans cliquer sur le bouton




task.spawn(function()




	while task.wait(0.3) do




		local char = player.Character




		if char then




			local hum = char:FindFirstChildOfClass("Humanoid")




			local hrp = char:FindFirstChild("HumanoidRootPart")




			-- Réappliquer la Walk Speed si activée et si elle a été changée




			if _S.speedEnabled and hum and hum.WalkSpeed ~= _S.speedValue then




				hum.WalkSpeed = _S.speedValue




			end




			-- Réappliquer le Fly si activé et si le BodyVelocity/BodyGyro a été supprimé


			if _S.flyEnabled and hrp then

				if not _S.flyVelocity or not _S.flyVelocity.Parent then

					_S.flyVelocity = Instance.new("BodyVelocity")

					_S.flyVelocity.MaxForce = Vector3.new(400000, 400000, 400000)

					_S.flyVelocity.Velocity = Vector3.new(0, 0, 0)

					_S.flyVelocity.Parent = hrp

				end

				if not _S.flyGyro or not _S.flyGyro.Parent then

					_S.flyGyro = Instance.new("BodyGyro")

					_S.flyGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

					_S.flyGyro.P = 50000

					_S.flyGyro.D = 400

					_S.flyGyro.CFrame = hrp.CFrame

					_S.flyGyro.Parent = hrp

				end

				if hum then

					hum.PlatformStand = true

				end

			end




























		end




	end




end)




-- NOCLIP




noclipBtn.MouseButton1Click:Connect(function()




	_S.noclipEnabled = not _S.noclipEnabled




	setNoclipToggle(_S.noclipEnabled)




	if _S.noclipEnabled then








	else








		-- Restaurer les collisions (sauf HumanoidRootPart)




		local char = player.Character




		if char then




			for _, part in char:GetDescendants() do




				if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then




					part.CanCollide = true




				end




			end




		end




	end




end)




task.spawn(function()




	while task.wait(0.1) do




		if _S.noclipEnabled then




			local char = player.Character




			if char then




				for _, part in char:GetDescendants() do




					if part:IsA("BasePart") then




						part.CanCollide = false




					end




				end




			end




		end




	end




end)




-- Swim reapplication loop
task.spawn(function()
	while task.wait(0.3) do
		local char = player.Character
		if char then
			local hum = char:FindFirstChildOfClass("Humanoid")
			local hrp = char:FindFirstChild("HumanoidRootPart")
			if _S.swimEnabled and hrp then
				if not _S.swimVelocity or not _S.swimVelocity.Parent then
					_S.swimVelocity = Instance.new("BodyVelocity")
					_S.swimVelocity.MaxForce = Vector3.new(400000, 400000, 400000)
					_S.swimVelocity.Velocity = Vector3.new(0, 0, 0)
					_S.swimVelocity.Parent = hrp
				end
				if not _S.swimGyro or not _S.swimGyro.Parent then
					_S.swimGyro = Instance.new("BodyGyro")
					_S.swimGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)
					_S.swimGyro.P = 50000
					_S.swimGyro.D = 400
					_S.swimGyro.CFrame = hrp.CFrame
					_S.swimGyro.Parent = hrp
				end
				if hum then
					hum:SetStateEnabled(Enum.HumanoidStateType.Freefall, false)
					hum:ChangeState(Enum.HumanoidStateType.Swimming)
				end
			end
		end
	end
end)

-- Swim movement (RenderStepped)
RunService.RenderStepped:Connect(function()
	if not _S.swimEnabled or not _S.swimVelocity then return end
	local char = player.Character
	if not char then return end
	local hrp = char:FindFirstChild("HumanoidRootPart")
	if not hrp then return end
	local hum = char:FindFirstChildOfClass("Humanoid")
	local cam = Workspace.CurrentCamera
	local fwd = cam.CFrame.LookVector
	local right = cam.CFrame.RightVector
	local up = Vector3.new(0, 1, 0)
	local move = Vector3.new(0, 0, 0)
	if keys[Enum.KeyCode.W] then move = move + fwd end
	if keys[Enum.KeyCode.S] then move = move - fwd end
	if keys[Enum.KeyCode.A] then move = move - right end
	if keys[Enum.KeyCode.D] then move = move + right end
	if keys[Enum.KeyCode.Space] then move = move + up end
	if keys[Enum.KeyCode.LeftShift] then move = move - up end
	if move.Magnitude > 0 then move = move.Unit * _S.swimSpeed end
	_S.swimVelocity.Velocity = move
	if hum then
		hum:ChangeState(Enum.HumanoidStateType.Swimming)
	end
	if _S.swimGyro and _S.swimGyro.Parent then
		local lookDir = Vector3.new(fwd.X, 0, fwd.Z)
		if lookDir.Magnitude > 0.01 then
			lookDir = lookDir.Unit
			_S.swimGyro.CFrame = CFrame.lookAt(Vector3.new(0, 0, 0), lookDir)
		end
	end
	hrp.AssemblyAngularVelocity = Vector3.new(0, 0, 0)
end)

-- TP JOUEUR




tpPlayerBtn.MouseButton1Click:Connect(function()




	if _S.selectedPlayer and _S.selectedPlayer.Character then




		local targetHRP = _S.selectedPlayer.Character:FindFirstChild("HumanoidRootPart")




		local myChar = player.Character




		local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")




		if targetHRP and myHRP then




			myHRP.CFrame = targetHRP.CFrame * CFrame.new(0, 0, 5)




		end




	end




end)




-- SAVE POSITION




savePosBtn.MouseButton1Click:Connect(function()




	local char = player.Character




	if char then




		local hrp = char:FindFirstChild("HumanoidRootPart")




		if hrp then




			_S.savedPosition = hrp.CFrame




			savePosBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




			task.delay(0.3, function()




				savePosBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




			end)




		end




	end




end)




-- SAVE POSITION JOUEUR SELECT




savePlayerPosBtn.MouseButton1Click:Connect(function()




	if _S.selectedPlayer and _S.selectedPlayer.Character then




		local targetHRP = _S.selectedPlayer.Character:FindFirstChild("HumanoidRootPart")




		if targetHRP then




			_S.savedPlayerPosition = targetHRP.CFrame




			savePlayerPosBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




			task.delay(0.3, function()




				savePlayerPosBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




			end)




		end




	else




		savePlayerPosBtn.Text = "Aucun joueur"




		savePlayerPosBtn.BackgroundColor3 = Color3.fromRGB(150, 50, 50)




		task.delay(1.5, function()




			savePlayerPosBtn.Text = "Save Pos Joueur Select"




			savePlayerPosBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




		end)




	end




end)




-- TP POSITION




tpPosBtn.MouseButton1Click:Connect(function()




	local targetPos = _S.savedPlayerPosition or _S.savedPosition




	if targetPos then




		local char = player.Character




		if char then




			local hrp = char:FindFirstChild("HumanoidRootPart")




			if hrp then




				hrp.CFrame = targetPos




				tpPosBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




				task.delay(0.3, function()




					tpPosBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




				end)




			end




		end




	else




		tpPosBtn.Text = "Aucune save"




		tpPosBtn.BackgroundColor3 = Color3.fromRGB(150, 50, 50)




		task.delay(1, function()




			tpPosBtn.Text = "TP Position"




			tpPosBtn.BackgroundColor3 = _S.customBtnColor or Color3.fromRGB(120, 30, 30)




		end)




	end




end)




-- TP SAVE AUTO (teleporte le joueur a la position sauvegardee par Save Position, en boucle)




tpSavePosBtn.MouseButton1Click:Connect(function()




	_S.tpSavePosEnabled = not _S.tpSavePosEnabled




	setTpSavePosToggle(_S.tpSavePosEnabled)




	if _S.tpSavePosEnabled then








		-- Deuxième save: sauvegarder la position actuelle automatiquement




		local char = player.Character




		if char then




			local hrp = char:FindFirstChild("HumanoidRootPart")




			if hrp then




				_S.tpSaveAutoPosition = hrp.CFrame




			end




		end




	else








		_S.tpSaveAutoPosition = nil




	end




end)




-- TP SAVE AUTO: alterne entre la position sauvegardée (Save Position / Save Pos Joueur)




-- et la deuxième position (_S.tpSaveAutoPosition = position quand le toggle a été activé)




task.spawn(function()




	local toggle = false




	while task.wait(0.1) do




		if _S.tpSavePosEnabled and _S.tpSaveAutoPosition and (_S.savedPlayerPosition or _S.savedPosition) then




			local char = player.Character




			if char then




				local hrp = char:FindFirstChild("HumanoidRootPart")




				local humanoid = char:FindFirstChildOfClass("Humanoid")




				-- Teleporter seulement si le joueur est vivant




				if hrp and humanoid and humanoid.Health > 0 then




					toggle = not toggle




					if toggle then




						hrp.CFrame = _S.savedPlayerPosition or _S.savedPosition




					else




						hrp.CFrame = _S.tpSaveAutoPosition




					end




				end




			end




			task.wait(_S.tpSaveInterval)




		end




	end




end)




-- TP SAVE AUTO SIMPLE (teleporte le joueur a la position sauvegardee en boucle, sans alternance)




tpSaveSimpleBtn.MouseButton1Click:Connect(function()




	_S.tpSaveSimpleEnabled = not _S.tpSaveSimpleEnabled




	setTpSaveSimpleToggle(_S.tpSaveSimpleEnabled)




	if _S.tpSaveSimpleEnabled then








	else








	end




end)




task.spawn(function()




	while task.wait(0.1) do




		if _S.tpSaveSimpleEnabled and (_S.savedPlayerPosition or _S.savedPosition) then




			local char = player.Character




			if char then




				local hrp = char:FindFirstChild("HumanoidRootPart")




				local humanoid = char:FindFirstChildOfClass("Humanoid")




				if hrp and humanoid and humanoid.Health > 0 then




					hrp.CFrame = _S.savedPlayerPosition or _S.savedPosition




				end




			end




			task.wait(_S.tpSaveInterval)




		end




	end




end)




-- Interval controls
local function updateIntervalLabel()
	intervalValueLabel.Text = tostring(_S.tpSaveInterval)
	intervalUpdateSlider(true)
end
intervalDownBtn.MouseButton1Click:Connect(function()
	_S.tpSaveInterval = math.max(0.1, _S.tpSaveInterval - 0.5)
	updateIntervalLabel()
end)
intervalUpBtn.MouseButton1Click:Connect(function()
	_S.tpSaveInterval = _S.tpSaveInterval + 0.5
	updateIntervalLabel()
end)





-- TP ALL (téléporte à chaque joueur pendant 1 seconde en cycle)




tpAllBtn.MouseButton1Click:Connect(function()




	if _S.tpAllActive then




		-- Arrêter le cycle




		_S.tpAllActive = false




		return




	end




	-- Vérifier s'il y a d'autres joueurs




	local playersList = {}




	for _, p in Players:GetPlayers() do




		if p ~= player then




			table.insert(playersList, p)




		end




	end




	if #playersList == 0 then




		-- Aucun autre joueur - feedback visuel




		tpAllBtn.Text = "Aucun joueur"




		tpAllBtn.BackgroundColor3 = Color3.fromRGB(150, 50, 50)




		task.delay(1.5, function()




			tpAllBtn.Text = "TP All"








		end)




		return




	end




	_S.tpAllActive = true




	tpAllBtn.Text = "Arrêter"




	setTpAllToggle(true)








	task.spawn(function()




		while _S.tpAllActive do




			playersList = {}




			for _, p in Players:GetPlayers() do




				if p ~= player then




					table.insert(playersList, p)




				end




			end




			if #playersList == 0 then break end




			for _, targetP in ipairs(playersList) do




				if not _S.tpAllActive then break end




				if targetP.Character and targetP.Character:FindFirstChild("HumanoidRootPart") then




					local targetHRP = targetP.Character.HumanoidRootPart




					local myChar = player.Character




					local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")




					if myHRP then




						myHRP.CFrame = targetHRP.CFrame * CFrame.new(0, 0, 5)




					end




				end




				-- Attendre 1 seconde, vérifier l'arrêt toutes les 0.1s




				local waited = 0




				while waited < 1 and _S.tpAllActive do




					task.wait(0.1)




					waited = waited + 0.1




				end




			end




		end




		-- Réinitialiser le bouton en TP All




		_S.tpAllActive = false




		tpAllBtn.Text = "TP All"




		setTpAllToggle(false)








	end)




end)




-- XRAY (voir à travers les murs) - optimisé pour éviter les bugs avec beaucoup de builds




do




	local xrayConn = nil




	local xrayRemovingConn = nil




	local function isCharacterPart(part)




		local ancestor = part.Parent




		while ancestor and ancestor ~= workspace do




			if ancestor:FindFirstChildOfClass("Humanoid") then return true end




			ancestor = ancestor.Parent




		end




		return false




	end




	local function applyXrayToPart(part)




		if not part:IsA("BasePart") then return end




		if part.Transparency >= 0.5 then return end




		if isCharacterPart(part) then return end




		_S.xraySavedTransparency[part] = part.Transparency




		part.Transparency = 0.7




	end




	xrayBtn.MouseButton1Click:Connect(function()




		_S.xrayEnabled = not _S.xrayEnabled




		setXrayToggle(_S.xrayEnabled)




		if _S.xrayEnabled then




			xrayBtn.Text = "Enlever Xray"








			-- Collecter les parts des personnages joueurs à ne pas rendre transparentes




			local charParts = {}




			for _, p in Players:GetPlayers() do




				if p.Character then




					for _, part in p.Character:GetDescendants() do




						if part:IsA("BasePart") then




							charParts[part] = true




						end




					end




				end




			end




			-- Appliquer Xray en LOTS (chunked) pour éviter de freezer le jeu avec beaucoup de builds




			task.spawn(function()




				local count = 0




				for _, desc in workspace:GetDescendants() do




					if desc:IsA("BasePart") and desc.Transparency < 0.5 and not charParts[desc] then




						_S.xraySavedTransparency[desc] = desc.Transparency




						desc.Transparency = 0.7




					end




					count = count + 1




					if count >= 500 then




						count = 0




						task.wait() -- Laisser le jeu respirer entre les lots




					end




				end




			end)




			-- Gérer les nouvelles parts via événement (pas de polling)




			xrayConn = workspace.DescendantAdded:Connect(function(desc)




				if not _S.xrayEnabled then return end




				applyXrayToPart(desc)




			end)




			-- Nettoyer la table quand des parts sont supprimées (évite fuite mémoire)




			xrayRemovingConn = workspace.DescendantRemoving:Connect(function(desc)




				_S.xraySavedTransparency[desc] = nil




			end)




		else




			xrayBtn.Text = "Xray"








			-- Déconnecter les handlers




			if xrayConn then




				xrayConn:Disconnect()




				xrayConn = nil




			end




			if xrayRemovingConn then




				xrayRemovingConn:Disconnect()




				xrayRemovingConn = nil




			end




			-- Restaurer la transparence en lots aussi (évite de freezer à la désactivation)




			task.spawn(function()




				local count = 0




				for part, transp in pairs(_S.xraySavedTransparency) do




					if part.Parent then




						pcall(function() part.Transparency = transp end)




					end




					count = count + 1




					if count >= 500 then




						count = 0




						task.wait()




					end




				end




				_S.xraySavedTransparency = {}




			end)




		end




	end)




end




-- VOIR DANS LE NOIR (Night Vision)




nightVisionBtn.MouseButton1Click:Connect(function()




	_S.nightVisionEnabled = not _S.nightVisionEnabled




	setNightVisionToggle(_S.nightVisionEnabled)




	if _S.nightVisionEnabled then




		nightVisionBtn.Text = "Ne plus voir dans le noir"








		-- Sauvegarder les valeurs d'éclairage d'origine




		local lighting = game:GetService("Lighting")




		_S.nightVisionSavedLighting.Brightness = lighting.Brightness




		_S.nightVisionSavedLighting.Ambient = lighting.Ambient




		_S.nightVisionSavedLighting.OutdoorAmbient = lighting.OutdoorAmbient




		_S.nightVisionSavedLighting.ExposureCompensation = lighting.ExposureCompensation




		-- Appliquer la vision nocturne




		lighting.Brightness = 3




		lighting.Ambient = Color3.fromRGB(128, 128, 128)




		lighting.OutdoorAmbient = Color3.fromRGB(128, 128, 128)




		lighting.ExposureCompensation = 2




	else




		nightVisionBtn.Text = "Voir dans le noir"








		-- Restaurer les valeurs d'éclairage d'origine




		local lighting = game:GetService("Lighting")




		lighting.Brightness = _S.nightVisionSavedLighting.Brightness or 2




		lighting.Ambient = _S.nightVisionSavedLighting.Ambient or Color3.fromRGB(0, 0, 0)




		lighting.OutdoorAmbient = _S.nightVisionSavedLighting.OutdoorAmbient or Color3.fromRGB(128, 128, 128)




		lighting.ExposureCompensation = _S.nightVisionSavedLighting.ExposureCompensation or 0




		_S.nightVisionSavedLighting = {}




	end




end)

-- Spin toggle click handler
spinBtn.MouseButton1Click:Connect(function()
	_S.spinEnabled = not _S.spinEnabled
	setSpinToggle(_S.spinEnabled)
end)

-- Spin RenderStepped: rotate character each frame
RunService.RenderStepped:Connect(function(dt)
	if not _S.spinEnabled then return end
	local char = player.Character
	if not char then return end
	local hrp = char:FindFirstChild("HumanoidRootPart")
	if not hrp then return end
	hrp.CFrame = hrp.CFrame * CFrame.Angles(0, math.rad(_S.spinSpeed) * dt, 0)
end)

-- AFK ANTI-KICK




local function formatAfkTime(seconds)




	local h = math.floor(seconds / 3600)




	local m = math.floor((seconds % 3600) / 60)




	local s = math.floor(seconds % 60)




	return string.format("AFK: %02d:%02d:%02d", h, m, s)




end




afkBtn.MouseButton1Click:Connect(function()




	_S.afkEnabled = not _S.afkEnabled




	setAfkToggle(_S.afkEnabled)




	if _S.afkEnabled then








		_S.afkStartTime = os.time()




		if _S.afkTimerLabel then




			_S.afkTimerLabel.Text = formatAfkTime(0)




		end




		if _S.afkTimerGui and _S.afkTimerGui:FindFirstChild("Frame") then




			_S.afkTimerGui.Frame.Visible = true




		end




	else








		if _S.afkTimerGui and _S.afkTimerGui:FindFirstChild("Frame") then




			_S.afkTimerGui.Frame.Visible = false




		end




	end




end)




task.spawn(function()




	while task.wait(1) do




		if _S.afkEnabled and _S.afkTimerLabel then




			_S.afkTimerLabel.Text = formatAfkTime(os.time() - _S.afkStartTime)




		end




	end




end)








-- === SPECTATE BUTTONS LOGIC ===




local function getSortedPlayers()




	local list = {}




	for _, p in ipairs(Players:GetPlayers()) do




		if p ~= player then




			table.insert(list, p)




		end




	end




	return list




end




local function spectateNextPlayer()




	local list = getSortedPlayers()




	if #list == 0 then return end




	local currentIdx = 0




	for i, p in ipairs(list) do




		if p == _S.spectatingPlayer then




			currentIdx = i




			break




		end




	end




	local nextIdx = currentIdx + 1




	if nextIdx > #list then nextIdx = 1 end




	startSpectate(list[nextIdx])




	_S.selectedPlayer = list[nextIdx]




	refreshList()




	if updateVolLabel then updateVolLabel() end




end




local function spectatePrevPlayer()




	local list = getSortedPlayers()




	if #list == 0 then return end




	local currentIdx = 0




	for i, p in ipairs(list) do




		if p == _S.spectatingPlayer then




			currentIdx = i




			break




		end




	end




	local prevIdx = currentIdx - 1




	if prevIdx < 1 then prevIdx = #list end




	startSpectate(list[prevIdx])




	_S.selectedPlayer = list[prevIdx]




	refreshList()




	if updateVolLabel then updateVolLabel() end




end




spectateBtn.MouseButton1Click:Connect(function()




	clickSound:Play()




	if _S.selectedPlayer and _S.selectedPlayer.Parent then




		startSpectate(_S.selectedPlayer)




	else




		local list = getSortedPlayers()




		if #list > 0 then




			startSpectate(list[1])




			_S.selectedPlayer = list[1]




			refreshList()




			if updateVolLabel then updateVolLabel() end




		end




	end




end)




stopSpectateBtn.MouseButton1Click:Connect(function()




	clickSound:Play()




	stopSpectate()




end)




prevSpectateBtn.MouseButton1Click:Connect(function()




	clickSound:Play()




	spectatePrevPlayer()




end)




nextSpectateBtn.MouseButton1Click:Connect(function()




	clickSound:Play()




	spectateNextPlayer()




end)




task.spawn(function()




	while task.wait(120) do




		if _S.afkEnabled then




			VirtualUser:CaptureController()




			VirtualUser:ClickButton1(Vector2.new())




		end




	end




end)




RunService:BindToRenderStep("REDTIGERMouse", 999999, function()




	-- Ne forcer la souris en mode Default que quand le panel est visible




	-- Quand le panel est ferm, on laisse Roblox grer normalement (Shift Lock, etc.)




	if panel.Visible then




		if _S.rightMouseHeld then
			UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
			UserInputService.MouseIconEnabled = false
		else
			UserInputService.MouseBehavior = Enum.MouseBehavior.Default
			UserInputService.MouseIconEnabled = true
		end









	end




end)




-- Backup 1: RenderStepped connection (runs after most BindToRenderStep calls)




RunService.RenderStepped:Connect(function()




	if panel.Visible then




		if _S.rightMouseHeld then
			UserInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
			UserInputService.MouseIconEnabled = false
		else
			UserInputService.MouseBehavior = Enum.MouseBehavior.Default
			UserInputService.MouseIconEnabled = true
		end









	end




end)




-- Backup 2: Property change signal (detect and override any lock attempt)




UserInputService:GetPropertyChangedSignal("MouseBehavior"):Connect(function()




	if panel.Visible and not _S.rightMouseHeld and UserInputService.MouseBehavior ~= Enum.MouseBehavior.Default then




		UserInputService.MouseBehavior = Enum.MouseBehavior.Default




	end




end)




RunService.RenderStepped:Connect(function()




	-- Spectate camera management moved to GetPropertyChangedSignal (avoids sync errors)




	if not _S.flyEnabled or not _S.flyVelocity then return end




	local char = player.Character




	if not char then return end




	local hrp = char:FindFirstChild("HumanoidRootPart")




	if not hrp then return end




	local cam = Workspace.CurrentCamera




	local fwd = cam.CFrame.LookVector




	local right = cam.CFrame.RightVector




	local up = Vector3.new(0, 1, 0)




	local move = Vector3.new(0, 0, 0)




	if keys[Enum.KeyCode.W] then move = move + fwd end




	if keys[Enum.KeyCode.S] then move = move - fwd end




	if keys[Enum.KeyCode.A] then move = move - right end




	if keys[Enum.KeyCode.D] then move = move + right end




	if keys[Enum.KeyCode.Space] then move = move + up end




	if keys[Enum.KeyCode.LeftShift] then move = move - up end




	if move.Magnitude > 0 then move = move.Unit * _S.flySpeed end




	_S.flyVelocity.Velocity = move




	-- Garder le personnage droit avec le BodyGyro (empeche de tournoyer contre les murs)



	if _S.flyGyro and _S.flyGyro.Parent then
		local lookDir = Vector3.new(fwd.X, 0, fwd.Z)
		if lookDir.Magnitude > 0.01 then
			lookDir = lookDir.Unit
			_S.flyGyro.CFrame = CFrame.lookAt(Vector3.new(0, 0, 0), lookDir)
		end
	end

	hrp.AssemblyAngularVelocity = Vector3.new(0, 0, 0)




end)




UserInputService.InputBegan:Connect(function(input, gp)




	if gp then return end




	keys[input.KeyCode] = true




end)




UserInputService.InputEnded:Connect(function(input)




	keys[input.KeyCode] = nil




end)




-- AUTO REJOIN




local TeleportService = game:GetService("TeleportService")




autoRejoinBtn.MouseButton1Click:Connect(function()




	autoRejoinBtn.Text = "Rejoin..."




	autoRejoinBtn.BackgroundColor3 = Color3.fromRGB(40, 150, 50)




	local jobId = game.JobId




	local placeId = game.PlaceId




	if jobId ~= "" then




		TeleportService:TeleportToPlaceInstance(placeId, jobId, player)




	else




		TeleportService:Teleport(placeId, player)




	end




end)




-- LOCK JOUEUR (verrouille la camera sur la tete du joueur le plus proche)




lockAllBtn.MouseButton1Click:Connect(function()




	_S.lockAllEnabled = not _S.lockAllEnabled




	setLockAllToggle(_S.lockAllEnabled)




	if _S.lockAllEnabled then




		_S.lockSelectedEnabled = false




		setLockSelToggle(false)








		_S.lockEnemyEnabled = false




		setLockEnemyToggle(false)












	else








	end




end)




-- LOCK SELECT (verrouille la camera sur le joueur selectionne)




lockSelBtn.MouseButton1Click:Connect(function()




	_S.lockSelectedEnabled = not _S.lockSelectedEnabled




	setLockSelToggle(_S.lockSelectedEnabled)




	if _S.lockSelectedEnabled then




		_S.lockAllEnabled = false




		setLockAllToggle(false)








		_S.lockEnemyEnabled = false




		setLockEnemyToggle(false)












	else








	end




end)




-- LOCK EQUIPE ADVERSE (verrouille la camera sur le joueur ennemi le plus proche)




lockEnemyBtn.MouseButton1Click:Connect(function()




	_S.lockEnemyEnabled = not _S.lockEnemyEnabled




	setLockEnemyToggle(_S.lockEnemyEnabled)




	if _S.lockEnemyEnabled then




		_S.lockAllEnabled = false




		setLockAllToggle(false)








		_S.lockSelectedEnabled = false




		setLockSelToggle(false)












	else








	end




end)




-- LOGIQUE LOCK AIM (RenderStep apres la camera Roblox)




do




	local function isAlive(p)




		if not p or not p.Parent then return false end




		local char = p.Character




		if not char then return false end




		local hum = char:FindFirstChildOfClass("Humanoid")




		return hum ~= nil




	end




	-- Le highlight de lock a été supprimé: on garde uniquement l'ESP + HP




	-- Indicateur HP pour le joueur verrouille (affiche les PV sur l'ESP)




	local lockHPBillboard = nil




	local lastLockedChar = nil




	local function hideAllHPLabels()




		for _, p in Players:GetPlayers() do




			if _S.espObjects[p] and _S.espObjects[p].bb then




				local hpLbl = _S.espObjects[p].bb:FindFirstChild("HPLabel")




				if hpLbl then hpLbl.Visible = false end




			end




		end




	end




	local function removeLockHPIndicator()




		hideAllHPLabels()




		if lockHPBillboard then




			pcall(function() lockHPBillboard:Destroy() end)




			lockHPBillboard = nil




		end




		lastLockedChar = nil




	end




	local function updateLockHPIndicator(char)




		if not char then removeLockHPIndicator() return end




		-- Si la cible a change, cacher les anciens labels




		if lastLockedChar ~= char then




			hideAllHPLabels()




			if lockHPBillboard then




				pcall(function() lockHPBillboard:Destroy() end)




				lockHPBillboard = nil




			end




			lastLockedChar = char




		end




		local targetPlayer = nil




		for _, p in Players:GetPlayers() do




			if p.Character == char then




				targetPlayer = p




				break




			end




		end




		local hum = char:FindFirstChildOfClass("Humanoid")




		if not hum then return end




		local hpText = "\u{2764} " .. math.floor(hum.Health) .. "/" .. tostring(hum.MaxHealth)




		local hpPct = hum.Health / hum.MaxHealth




		local hpColor




		if hpPct > 0.5 then




			hpColor = Color3.fromRGB(0, 255, 0)




		elseif hpPct > 0.25 then




			hpColor = Color3.fromRGB(255, 255, 0)




		else




			hpColor = Color3.fromRGB(255, 0, 0)




		end




		-- Utiliser l'ESP BillboardGui existant si disponible




		if targetPlayer and _S.espObjects[targetPlayer] and _S.espObjects[targetPlayer].bb and _S.espObjects[targetPlayer].bb.Parent then




			local bb = _S.espObjects[targetPlayer].bb




			local hpLbl = bb:FindFirstChild("HPLabel")




			if hpLbl then




				hpLbl.Visible = true




				hpLbl.Text = hpText




				hpLbl.TextColor3 = hpColor




			end




			if lockHPBillboard then




				pcall(function() lockHPBillboard:Destroy() end)




				lockHPBillboard = nil




			end




		else




			-- ESP inactif: creer un BillboardGui dedie pour les HP




			if not lockHPBillboard or not lockHPBillboard.Parent or lockHPBillboard.Parent ~= char then




				if lockHPBillboard then




					pcall(function() lockHPBillboard:Destroy() end)




				end




				lockHPBillboard = Instance.new("BillboardGui")




				lockHPBillboard.Name = "LockHP"




				lockHPBillboard.Size = UDim2.new(0, 200, 0, 20)




				lockHPBillboard.StudsOffset = Vector3.new(0, 4, 0)




				lockHPBillboard.AlwaysOnTop = true




				lockHPBillboard.Parent = char




				local hpLbl = Instance.new("TextLabel")




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




				hpLbl.BackgroundTransparency = 1




				hpLbl.Text = ""




				hpLbl.Font = Enum.Font.SourceSansBold




				hpLbl.TextSize = 16




				hpLbl.Parent = lockHPBillboard




			end




			local hpLbl = lockHPBillboard:FindFirstChildOfClass("TextLabel")




			if hpLbl then




				hpLbl.Text = hpText




				hpLbl.TextColor3 = hpColor




			end




		end




	end




	RunService:BindToRenderStep("LockAim", Enum.RenderPriority.Camera.Value + 1, function()




		-- LOCK AIM: verrouille la camera sur la tete d'un joueur




		if (_S.lockAllEnabled or _S.lockSelectedEnabled or _S.lockEnemyEnabled) then




			local char = player.Character




			if char then




				local hrp = char:FindFirstChild("HumanoidRootPart")




				if hrp then




					local targetHead = nil




					local curRange




					if _S.lockSelectedEnabled then




						curRange = _S.lockRanges.sel




					elseif _S.lockAllEnabled then




						curRange = _S.lockRanges.all




					else




						curRange = _S.lockRanges.enemy




					end




					-- Auto-lock par dégâts: si on a pris des dégâts récemment, cibler l'attaquant




					if _S.damageAutoLockTarget and tick() < _S.damageAutoLockExpire then




						if isAlive(_S.damageAutoLockTarget) then




							local head = _S.damageAutoLockTarget.Character:FindFirstChild("Head")




							if head and head.Parent then




								local dist = (head.Position - hrp.Position).Magnitude




								if curRange == math.huge or dist <= curRange then




									targetHead = head




								end




							end




						end




					end




					-- Auto-lock de proximité: si un joueur est très proche, le cibler directement




					if not targetHead then




						local proxNearest = _S.lockProximityRange




						for _, p in Players:GetPlayers() do




							if p ~= player and isAlive(p) then




								if _S.lockEnemyEnabled and p.Team == player.Team then




									continue




								end




								local head = p.Character:FindFirstChild("Head")




								if head and head.Parent then




									local dist = (head.Position - hrp.Position).Magnitude




									if dist < proxNearest then




										proxNearest = dist




										targetHead = head




									end




								end




							end




						end




					end




					if not targetHead then




						if _S.lockSelectedEnabled then




							-- Lock Select: on verrouille uniquement le joueur selectionne s'il est vivant et dans la range




							if _S.selectedPlayer and isAlive(_S.selectedPlayer) then




								local head = _S.selectedPlayer.Character:FindFirstChild("Head")




								if head and head.Parent then




									local dist = (head.Position - hrp.Position).Magnitude




									if curRange == math.huge or dist <= curRange then




										targetHead = head




									end




								end




							end




						elseif _S.lockAllEnabled then




							local nearestDist = math.huge




							for _, p in Players:GetPlayers() do




								if p ~= player and isAlive(p) then




									local head = p.Character:FindFirstChild("Head")




									if head and head.Parent then




										local dist = (head.Position - hrp.Position).Magnitude




										if dist < nearestDist and (curRange == math.huge or dist <= curRange) then




											nearestDist = dist




											targetHead = head




										end




									end




								end




							end




						elseif _S.lockEnemyEnabled then




							local myTeam = player.Team




							local nearestDist = math.huge




							for _, p in Players:GetPlayers() do




								if p ~= player and p.Team ~= myTeam and isAlive(p) then




									local head = p.Character:FindFirstChild("Head")




									if head and head.Parent then




										local dist = (head.Position - hrp.Position).Magnitude




										if dist < nearestDist and (curRange == math.huge or dist <= curRange) then




											nearestDist = dist




											targetHead = head




										end




									end




								end




							end




						end




					end




					if targetHead then




						local camPos = camera.CFrame.Position




						camera.CFrame = CFrame.lookAt(camPos, targetHead.Position)




						-- Mettre a jour l'indicateur HP sur la cible verrouillee (affiche les PV sur l'ESP)




						updateLockHPIndicator(targetHead.Parent)




					else




						removeLockHPIndicator()




					end




				end




			end




		else




			removeLockHPIndicator()




		end




	end)




end




-- Détection de dégâts: auto-lock quand on se fait tirer dessus




task.spawn(function()




	local lastHealth = nil




	while task.wait(0.1) do




		local char = player.Character




		if char then




			local hum = char:FindFirstChildOfClass("Humanoid")




			if hum then




				if lastHealth and hum.Health < lastHealth - 5 then




					-- On a pris des dégâts: trouver l'attaquant le plus proche




					local hrp = char:FindFirstChild("HumanoidRootPart")




					if hrp then




						local nearestDist = math.huge




						local nearestPlayer = nil




						for _, p in Players:GetPlayers() do




							if p ~= player and p.Character then




								local pHum = p.Character:FindFirstChildOfClass("Humanoid")




								if pHum then




									local pHead = p.Character:FindFirstChild("Head")




									if pHead then




										local dist = (pHead.Position - hrp.Position).Magnitude




										if dist < nearestDist then




											nearestDist = dist




											nearestPlayer = p




										end




									end




								end




							end




						end




						if nearestPlayer then




							_S.damageAutoLockTarget = nearestPlayer




							_S.damageAutoLockExpire = tick() + 5 -- Lock pendant 5 secondes




						end




					end




				end




				lastHealth = hum.Health




			else




				lastHealth = nil




			end




		else




			lastHealth = nil




		end




	end




end)




-- JUMP INFINI




jumpInfiniteBtn.MouseButton1Click:Connect(function()




	_S.infiniteJumpEnabled = not _S.infiniteJumpEnabled




	setJumpInfiniteToggle(_S.infiniteJumpEnabled)




	if _S.infiniteJumpEnabled then








	else








	end




end)




UserInputService.JumpRequest:Connect(function()




	if _S.infiniteJumpEnabled then




		local char = player.Character




		if char then




			local hum = char:FindFirstChildOfClass("Humanoid")




			if hum then




				hum:ChangeState(Enum.HumanoidStateType.Jumping)




			end




		end




	end




end)




-- VOICE CHAT VOLUME




do




	local voiceVolume = 1.0




	local function applyVoiceVolume(targetPlayer)




		if not targetPlayer or not targetPlayer.Parent then return end




		local adi = targetPlayer:FindFirstChildOfClass("AudioDeviceInput")




		if adi then




			pcall(function() adi.Volume = voiceVolume end)




		end




		if targetPlayer.Character then




			for _, d in targetPlayer.Character:GetDescendants() do




				if d:IsA("AudioEmitter") then




					pcall(function()




						d:SetDistanceAttenuation({[0] = voiceVolume, [10000] = voiceVolume})




					end)




				end




			end




		end




	end




	function updateVolLabel()




		volLabel.Text = "Vol: " .. math.floor(voiceVolume * 100) .. "%"




	end




	volDownBtn.MouseButton1Click:Connect(function()




		voiceVolume = math.max(0, voiceVolume - 0.1)




		updateVolLabel()




		if _S.selectedPlayer then




			applyVoiceVolume(_S.selectedPlayer)




		end




	end)




	volUpBtn.MouseButton1Click:Connect(function()




		voiceVolume = math.min(10, voiceVolume + 0.1)




		updateVolLabel()




		if _S.selectedPlayer then




			applyVoiceVolume(_S.selectedPlayer)




		end




	end)




	volLabel.FocusLost:Connect(function()




		local text = volLabel.Text




		local num = tonumber(text)




		if not num then




			local pct = string.match(text, "%d+")




			num = pct and tonumber(pct)




		end




		if num then




			voiceVolume = math.clamp(num / 100, 0, 10)




			updateVolLabel()




			if _S.selectedPlayer then




				applyVoiceVolume(_S.selectedPlayer)




			end




		else




			updateVolLabel()




		end




	end)




	task.spawn(function()




		while task.wait(1) do




			if voiceVolume ~= 1.0 and _S.selectedPlayer then




				applyVoiceVolume(_S.selectedPlayer)




			end




		end




	end)




end




-- GIVE ALL TOOLS (cherche dans ReplicatedStorage + Workspace ctclient)




giveToolsBtn.MouseButton1Click:Connect(function()




	local backpack = player:FindFirstChildOfClass("Backpack")




	if not backpack then return end




	local seen = {}




	local function search(container)




		for _, d in container:GetDescendants() do




			if d:IsA("Tool") and not seen[d] then




				seen[d] = true




				pcall(function()




					d:Clone().Parent = backpack




				end)




			end




		end




	end




	pcall(search, ReplicatedStorage)




	pcall(search, Workspace)




end)




-- RESPAWN




respawnBtn.MouseButton1Click:Connect(function()




	local char = player.Character




	if char then




		local hum = char:FindFirstChildOfClass("Humanoid")




		if hum and hum.Health > 0 then




			hum.Health = 0




		end




	end




end)




-- TOOL TÉLÉPORTATION




tpToolBtn.MouseButton1Click:Connect(function()




	local backpack = player:FindFirstChildOfClass("Backpack")




	if not backpack then return end




	for _, c in backpack:GetChildren() do




		if c.Name == "TeleportTool" then c:Destroy() end




	end




	if player.Character then




		for _, c in player.Character:GetChildren() do




			if c.Name == "TeleportTool" then c:Destroy() end




		end




	end




	local tool = Instance.new("Tool")




	tool.Name = "TeleportTool"




	tool.RequiresHandle = false




	tool.ToolTip = "Cliquez pour téléporter"




	tool.Parent = backpack




end)




task.spawn(function()




	while task.wait(0.3) do




		_S.teleportToolEquipped = false




		local char = player.Character




		if char then




			for _, c in char:GetChildren() do




				if c:IsA("Tool") and c.Name == "TeleportTool" then




					_S.teleportToolEquipped = true




					break




				end




			end




		end




	end




end)




mouse.Button1Down:Connect(function()




	if _S.teleportToolEquipped and mouse.Hit then




		local char = player.Character




		if char then




			local hrp = char:FindFirstChild("HumanoidRootPart")




			if hrp then




				hrp.CFrame = CFrame.new(mouse.Hit.Position + Vector3.new(0, 3, 0))




			end




		end




	end




end)




-- VOIR MON SAC (items cliquables pour équiper / déséquiper)




local bagVisible = false




local profileVisible = false




do




	bagBtn.MouseButton1Click:Connect(function()




		bagVisible = not bagVisible




		bagFrame.Visible = bagVisible




		if profileFrame.Visible then profileFrame.Visible = false profileVisible = false end




	end)




	-- Sac: refresh sans flicker (met à jour en place)




	local bagButtons = {}  -- tool -> TextButton




	task.spawn(function()




		while task.wait(0.5) do




			if bagVisible then




				local currentTools = {}




				-- Collecter les tools actuels




				local backpack = player:FindFirstChildOfClass("Backpack")




				if backpack then




					for _, item in backpack:GetChildren() do




						if item:IsA("Tool") then




							currentTools[item] = false  -- non équipé




						end




					end




				end




				local char = player.Character




				if char then




					for _, item in char:GetChildren() do




						if item:IsA("Tool") then




							currentTools[item] = true  -- équipé




						end




					end




				end




				-- Supprimer les boutons des tools qui n'existent plus




				for tool, button in pairs(bagButtons) do




					if not currentTools[tool] or not tool.Parent then




						if button and button.Parent then button:Destroy() end




						bagButtons[tool] = nil




					end




				end




				-- Créer ou mettre à jour les boutons




				for tool, isEquipped in pairs(currentTools) do




					if not bagButtons[tool] then




						-- Créer nouveau bouton




						local item = Instance.new("TextButton")




						item.Size = UDim2.new(1, -8, 0, 22)




						item.BackgroundTransparency = 0.2




						item.Font = Enum.Font.SourceSans




						item.TextSize = 14




						item.TextXAlignment = Enum.TextXAlignment.Left




						item.TextTruncate = Enum.TextTruncate.AtEnd




						item.BorderSizePixel = 0




						item.Parent = bagFrame




						Instance.new("UICorner", item).CornerRadius = UDim.new(0, 3)




						item.MouseButton1Click:Connect(function()




							clickSound:Play()




							local c = player.Character




							if c then




								local hum = c:FindFirstChildOfClass("Humanoid")




								if hum then




									if tool.Parent == c then




										hum:UnequipTools()




									else




										local bp = player:FindFirstChildOfClass("Backpack")




										if bp and tool.Parent == bp then




											hum:EquipTool(tool)




										end




									end




								end




							end




						end)




						bagButtons[tool] = item




					end




					-- Mettre à jour le texte et la couleur en place




					local button = bagButtons[tool]




					local newText = "  " .. tool.Name .. (isEquipped and " (main)" or "")




					local newColor = isEquipped and Color3.fromRGB(40, 150, 50) or (_S.customBtnColor or Color3.fromRGB(120, 30, 30))




					local newTextColor = isEquipped and Color3.fromRGB(255, 255, 255) or Color3.fromRGB(255, 255, 255)




					if button.Text ~= newText then button.Text = newText end




					if button.BackgroundColor3 ~= newColor then button.BackgroundColor3 = newColor end




					if button.TextColor3 ~= newTextColor then button.TextColor3 = newTextColor end




				end




			end




		end




	end)




end




-- PROFIL JOUEUR (refresh en temps réel sans flicker)




do




	local profileLabels = {}




	local profileBuilt = false




	local function buildProfileLabels()




		if profileBuilt then return end




		profileBuilt = true




		local fields = {"Pseudo", "Affichage", "ID", "Équipe", "Âge", "Vie", "Vitesse", "Position", "Tools", "Perso"}




		for _, field in ipairs(fields) do




			local lbl = Instance.new("TextLabel")




			lbl.Size = UDim2.new(1, -8, 0, 20)




			lbl.BackgroundTransparency = 0.3




			lbl.BackgroundColor3 = Color3.fromRGB(25, 25, 40)




			lbl.Text = ""




			lbl.TextColor3 = Color3.fromRGB(255, 255, 255)




			lbl.Font = Enum.Font.SourceSans




			lbl.TextSize = 14




			lbl.TextXAlignment = Enum.TextXAlignment.Left




			lbl.TextTruncate = Enum.TextTruncate.AtEnd




			lbl.BorderSizePixel = 0




			lbl.Parent = profileFrame




			Instance.new("UICorner", lbl).CornerRadius = UDim.new(0, 3)




			profileLabels[field] = lbl




		end




	end




	profileBtn.MouseButton1Click:Connect(function()




		profileVisible = not profileVisible




		profileFrame.Visible = profileVisible




		if bagFrame.Visible then bagFrame.Visible = false bagVisible = false end




		if profileVisible then




			buildProfileLabels()




		end




	end)




	-- Mise à jour profil en temps réel (invisible)




	task.spawn(function()




		while task.wait(0.5) do




			if profileVisible then




				local target = _S.selectedPlayer or player




				if not target or not target.Parent then




					for _, lbl in pairs(profileLabels) do lbl.Text = "" end




				else




					profileLabels["Pseudo"].Text = "  Pseudo: " .. target.Name




					profileLabels["Affichage"].Text = "  Affichage: " .. target.DisplayName




					profileLabels["ID"].Text = "  ID: " .. tostring(target.UserId)




					profileLabels["Équipe"].Text = "  Équipe: " .. (target.Team and target.Team.Name or "Aucune")




					profileLabels["Âge"].Text = "  Âge compte: " .. tostring(target.AccountAge) .. " jours"




					if target.Character then




						local hum = target.Character:FindFirstChildOfClass("Humanoid")




						if hum then




							profileLabels["Vie"].Text = "  Vie: " .. math.floor(hum.Health) .. "/" .. tostring(hum.MaxHealth)




							profileLabels["Vitesse"].Text = "  Vitesse: " .. tostring(hum.WalkSpeed)




						else




							profileLabels["Vie"].Text = "  Vie: N/A"




							profileLabels["Vitesse"].Text = "  Vitesse: N/A"




						end




						local hrp = target.Character:FindFirstChild("HumanoidRootPart")




						if hrp then




							local pos = hrp.Position




							profileLabels["Position"].Text = string.format("  Pos: %.0f, %.0f, %.0f", pos.X, pos.Y, pos.Z)




						else




							profileLabels["Position"].Text = "  Position: N/A"




						end




						local toolCount = 0




						for _, c in target.Character:GetChildren() do




							if c:IsA("Tool") then toolCount = toolCount + 1 end




						end




						local bp = target:FindFirstChildOfClass("Backpack")




						if bp then




							for _, c in bp:GetChildren() do




								if c:IsA("Tool") then toolCount = toolCount + 1 end




							end




						end




						profileLabels["Tools"].Text = "  Tools: " .. tostring(toolCount)




						profileLabels["Perso"].Text = "  Personnage: présent"




					else




						profileLabels["Vie"].Text = ""




						profileLabels["Vitesse"].Text = ""




						profileLabels["Position"].Text = ""




						profileLabels["Tools"].Text = ""




						profileLabels["Perso"].Text = "  Personnage: absent"




					end




				end




			end




		end




	end)




end




-- Réapplication après respawn




player.CharacterAdded:Connect(function()




	-- Libérer la souris immédiatement après le respawn




	UserInputService.MouseBehavior = Enum.MouseBehavior.Default




	UserInputService.MouseIconEnabled = true




	-- Nettoyer l'ancien _S.flyVelocity (lié au personnage mort)




	if _S.flyVelocity then _S.flyVelocity = nil end




	if _S.flyGyro then _S.flyGyro = nil end



	task.wait(0.5)




	if _S.speedEnabled then applySpeed() end




	if _S.flyEnabled then setupFly() end

	if _S.swimEnabled then setupSwim() end




	-- TP SAVE AUTO: teleporter le joueur a la position sauvegardee apres la mort (ALT ou SIMPLE)




	if (_S.tpSavePosEnabled or _S.tpSaveSimpleEnabled) and (_S.savedPlayerPosition or _S.savedPosition) then




		task.spawn(function()




			-- Attendre que le personnage soit bien charge (sans bloquer sur CharacterAdded:Wait)




			local char = player.Character




			if not char then




				for i = 1, 10 do




					task.wait(0.1)




					char = player.Character




					if char then break end




				end




			end




			if not char then return end




			-- Attendre le HumanoidRootPart




			local hrp = char:WaitForChild("HumanoidRootPart", 5)




			if hrp then




				-- Teleporter avec retries (le jeu peut override la position au spawn)




				for i = 1, 10 do




					local c = player.Character




					if c then




						local h = c:FindFirstChild("HumanoidRootPart")




						if h then




							h.CFrame = _S.savedPlayerPosition or _S.savedPosition




						end




					end




					task.wait(0.1)




				end




			end




		end)




	end




	-- AFK: re-capturer le contrôleur immédiatement après le respawn pour rester actif




	if _S.afkEnabled then




		task.spawn(function()




			task.wait(1)




			pcall(function()




				VirtualUser:CaptureController()




				VirtualUser:ClickButton1(Vector2.new())




			end)




		end)




	end




end)




-- SUPPRIMER LE PANEL (kill switch global)




killPanelBtn.MouseButton1Click:Connect(function()




	-- Desactiver toutes les fonctionnalites




	_S.espEnabled = false




	_S.speedEnabled = false




	_S.flyEnabled = false




	_S.noclipEnabled = false




	_S.afkEnabled = false




	_S.infiniteJumpEnabled = false




	_S.xrayEnabled = false




	_S.nightVisionEnabled = false




	_S.lockAllEnabled = false




	_S.lockSelectedEnabled = false




	_S.lockEnemyEnabled = false




	_S.tpAllActive = false




	_S.tpSavePosEnabled = false




	-- Restaurer la vitesse normale




	applySpeed()




	-- Desactiver le fly




	disableFly()

	disableSwim()



	-- Restaurer les collisions (noclip off)




	local char = player.Character




	if char then




		for _, part in char:GetDescendants() do




			if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then




				part.CanCollide = true




			end




		end




	end




	-- Restaurer l'eclairage (night vision off)




	local lighting = game:GetService("Lighting")




	lighting.Brightness = _S.nightVisionSavedLighting.Brightness or 2




	lighting.Ambient = _S.nightVisionSavedLighting.Ambient or Color3.fromRGB(0, 0, 0)




	lighting.OutdoorAmbient = _S.nightVisionSavedLighting.OutdoorAmbient or Color3.fromRGB(128, 128, 128)




	lighting.ExposureCompensation = _S.nightVisionSavedLighting.ExposureCompensation or 0




	_S.nightVisionSavedLighting = {}




	-- Restaurer la transparence (xray off)




	task.spawn(function()




		local count = 0




		for part, transp in pairs(_S.xraySavedTransparency) do




			if part.Parent then




				pcall(function() part.Transparency = transp end)




			end




			count = count + 1




			if count >= 500 then




				count = 0




				task.wait()




			end




		end




		_S.xraySavedTransparency = {}




	end)




	-- Supprimer l'ESP sur tous les joueurs




	for _, p in Players:GetPlayers() do




		removeESP(p)




	end




	-- Restaurer la camera




	-- CameraType not forced to avoid sync errors with custom camera games




	if char then




		local hum = char:FindFirstChildOfClass("Humanoid")




		if hum then




			camera.CameraSubject = hum




		end




	end




	stopSpectate()




	-- Tuer Omega si actif




	if _S.omegaHasExecuted and not _S.omegaKilled then




		_S.omegaKilled = true




		for _, conn in ipairs(_S.omegaConnections) do




			pcall(function() conn:Disconnect() end)




		end




		_S.omegaConnections = {}




		for _, name in ipairs(_S.omegaRenderStepNames) do




			pcall(function() RunService:UnbindFromRenderStep(name) end)




		end




		_S.omegaRenderStepNames = {}




		for _, thread in ipairs(_S.omegaThreads) do




			pcall(function() task.cancel(thread) end)




		end




		_S.omegaThreads = {}




		for _, inst in ipairs(_S.omegaCreatedInstances) do




			pcall(function()




				if inst and inst.Parent then inst:Destroy() end




			end)




		end




		_S.omegaCreatedInstances = {}




	end




	-- Supprimer uniquement les GUI Omega restants (seulement si Omega a ete execute)




	if _S.omegaHasExecuted then




		local playerGui = player:FindFirstChildOfClass("PlayerGui")




		if playerGui then




			for _, child in playerGui:GetChildren() do




				if child.Name ~= "REDTIGER" and child.Name ~= "AFKTimer" and not _S.omegaGuiSnapshot[child] then




					pcall(function() child:Destroy() end)




				end




			end




		end




		pcall(function()




			local coreGui = game:GetService("CoreGui")




			if coreGui then




				for _, child in coreGui:GetChildren() do




					if child.Name ~= "REDTIGER" and child.Name ~= "AFKTimer" and not _S.omegaCoreGuiSnapshot[child] then




						pcall(function() child:Destroy() end)




					end




				end




			end




		end)




	end




	-- Debind les RenderStep de REDTIGER




	pcall(function() RunService:UnbindFromRenderStep("REDTIGERMouse") end)




	pcall(function() RunService:UnbindFromRenderStep("LockAim") end)




	-- Restaurer le comportement de la souris




	UserInputService.MouseBehavior = Enum.MouseBehavior.Default




	UserInputService.MouseIconEnabled = true




	-- Supprimer les GUI REDTIGER




	if _S.afkTimerGui then




		pcall(function() _S.afkTimerGui:Destroy() end)




	end




	if gui then




		gui:Destroy()




	end




end)




print("[REDTIGER] Chargé - " .. player.Name .. " (ID: " .. player.UserId .. ")")




print("[REDTIGER] Appuyez sur K pour ouvrir/fermer le panel")