Haddock - Roblox Library

"make a roblox studio script for a door called "Door Bathroom" teleports the player to a door called "Door Back" Using proximityprompt with key "E", with a timer of 1 second."

"create a "create party" button, then a dropdown tween menu showing all parties in game, if I click it I join the party, it constantly shows how many players are in the party, maximum is 4, a start button that teleports all players in the party away"

-- LocalScript for "Create Party" button 
local button = script.Parent
local dropdown = script.Parent.Parent.DropDown
local player = game.Players.LocalPlayer
local partySystem = game.ReplicatedStorage.PartySystem

button.MouseButton1Click:Connect(function()
    partySystem.CreateParty:InvokeServer(player)
end)

-- LocalScript for dropdown menu 
local dropdown = script.Parent
local player = game.Players.LocalPlayer
local partySystem = game.ReplicatedStorage.PartySystem

local function updateParties()
    local parties = partySystem.GetParties:InvokeServer()
    dropdown:ClearAllChildren()

for _, party in ipairs(parties) do
        local partyButton = Instance.new("TextButton")
        partyButton.Text = "Party (" .. #party.members .. "/4)"
        partyButton.Size = UDim2.new(1, 0, 0, 30)
        partyButton.Parent = dropdown

partyButton.MouseButton1Click:Connect(function()
            if #party.members < 4 then
                partySystem.JoinParty:InvokeServer(player, party.id)
            end
        end)
    end
end

dropdown.MouseButton1Click:Connect(updateParties)

-- ServerScript for party system 
local partySystem = {}
local parties = {}

function partySystem.CreateParty(player)
    local partyId = #parties + 1
    local newParty = {
        id = partyId,
        leader = player,
        members = {player}
    }
    table.insert(parties, newParty)
end

function partySystem.GetParties()
    return parties
end

function partySystem.JoinParty(player, partyId)
    local party = parties[partyId]
    if party and #party.members < 4 then
        table.insert(party.members, player)
    end
end

game.ReplicatedStorage.PartySystem.OnServerInvoke = partySystem

-- LocalScript for "Start" button 
local startButton = script.Parent
local player = game.Players.LocalPlayer
local partySystem = game.ReplicatedStorage.PartySystem
local teleportService = game:GetService("TeleportService")
local gameId = 123456789 -- Replace with the actual game ID

startButton.MouseButton1Click:Connect(function()
    local playerParty = nil
    for _, party in ipairs(partySystem.GetParties:InvokeServer()) do
        if party.leader == player then
            playerParty = party
            break
        end
    end

if playerParty then
        local playerIds = {}
        for _, member in ipairs(playerParty.members) do
            table.insert(playerIds, member.UserId)
        end
        teleportService:TeleportPartyAsync(gameId, playerIds)
    end
end)

"there is a button at the top of the screen when you click it you grow by 1"

"make a shift to sprint"

"fly script"

"create a playerjoined message"

"make a randomroll event system that displays the events using hints where every 10 seconds after the event activates make it select 1 out of 4 other events and here is what they do: 1, part color change, 2, random spin for 10 seconds, 3, part transperancy change, 4, randomly colored sparkles"

"every time someone says in chat "i love you" or "i like you" or "kiss me" you get kicked and this audio plays 798363151"

"make a server script that makes it so whatever player the part the script is located in touches it kicks them and everytime the same player who got kicked join back kick them again for the reason Nope"

"punch system"

"make the part go up and down"

"make a roblox script whenever i hold down right click my mouse locks on to the most close player"

"change value for timeofday when datastore is updated"

"make me a command where if say !speedboost your walk speed is 35. only for rank 247 or above in group"

"Make a roblox killbrick script. The script will be placed in the workspace parented to a part, make the part kill players when players touch the part."

"do you have a idea for a game"

"create a script that puts the roblox chat gui at the buttom right and give instructions on how to set it up"

"make a roblox lua script that puts the player in 3d person view"

"If the player moves kick them where does it go"

"Make a script that spawns in a orb and then deletes it when the player collects it"

"make me a server script where the part named ServantBypass only lets rank 247 or higher go through it. while lower than rank 247 will have collision on. there will be multiple ServantBypass."

"Neo Soccer League Script GUI Hack (AIMBOT, AUTO GOAL, BALL SIZE, AND MORE"

"make a script that freezes my character in place"

"cREATE a server script that tells roblox that the player CortFile has left the game"

"make a script when you say /execute in chat and put a website after with lua code then it runs the lua code if it has it."

"Teleport them a few inches away from the part"

"create a local script inside a tool that plays a idle animation when the player is standing and running while holding the tool"

-- local script inside a tool 
local tool = script.Parent
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local idleAnimation = "http://www.roblox.com/asset/?id=INSERT_IDLE_ANIMATION_ID_HERE"
local runAnimation = "http://www.roblox.com/asset/?id=INSERT_RUN_ANIMATION_ID_HERE"

local idleAnimTrack = humanoid:LoadAnimation(idleAnimation)
local runAnimTrack = humanoid:LoadAnimation(runAnimation)

local function onEquipped()
    idleAnimTrack:Play()
    runAnimTrack:Stop()
end

local function onUnequipped()
    idleAnimTrack:Stop()
    runAnimTrack:Stop()
end

local function onStateChanged(oldState, newState)
    if newState == Enum.HumanoidStateType.Running then
        idleAnimTrack:Stop()
        runAnimTrack:Play()
    elseif newState == Enum.HumanoidStateType.RunningNoPhysics then
        idleAnimTrack:Stop()
        runAnimTrack:Play()
    else
        idleAnimTrack:Play()
        runAnimTrack:Stop()
    end
end

tool.Equipped:Connect(onEquipped)
tool.Unequipped:Connect(onUnequipped)
humanoid.StateChanged:Connect(onStateChanged)

"make a script that makes the player move to the most close player using path finding but if the most close player dies move on to another player"

-- server script 
local pfs = game:GetService("PathfindingService")
local players = game.Players:GetPlayers()

local function moveToNearestPlayer(player)
    local closestPlayer = nil
    local closestDistance = math.huge
    for i, p in ipairs(players) do
        if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
            local dist = (p.Character.HumanoidRootPart.Position - player.Character.HumanoidRootPart.Position).magnitude
            if dist < closestDistance then
                closestPlayer = p
                closestDistance = dist
            end
        end
    end
    if closestPlayer then
        local path = pfs:CreatePath()
        path:ComputeAsync(player.Character.HumanoidRootPart.Position, closestPlayer.Character.HumanoidRootPart.Position)
        for _, waypoint in pairs(path:GetWaypoints()) do
            player.Character.Humanoid:MoveTo(waypoint.Position)
            player.Character.Humanoid.MoveToFinished:Wait()
        end
    end
end

game.Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Connect(function(character)
        while true do
            moveToNearestPlayer(player)
            wait(1)
        end
    end)
end)

"rain red bricks from the air forever super fast that turns black when they touch the ground. 2 seconds after touching the ground it explodes into 6 0.1x0.1 size blocks"

-- server script (ServerScriptService) 
while true do
    local part = Instance.new("Part")
    part.Parent = game.Workspace

part.Position = Vector3.new(math.random(-100, 100), 50, math.random(-100, 100))
    part.Size = Vector3.new(5, 1, 5)
    part.Color = Color3.fromRGB(255, 0, 0)
    part.Anchored = false
    part.BrickColor = BrickColor.new("Bright red")
    part.Material = Enum.Material.Brick

part.Touched:Connect(function(hit)
        part.Color = Color3.fromRGB(0, 0, 0)
        wait(2)
        part:Destroy()

for i = 1, 6 do
            local miniPart = Instance.new("Part")
            miniPart.Parent = game.Workspace
            miniPart.Position = part.Position
            miniPart.Size = Vector3.new(0.1, 0.1, 0.1)
            miniPart.BrickColor = BrickColor.new("Bright red")
            miniPart.Material = Enum.Material.Brick
            miniPart.Velocity = Vector3.new(math.random(-10, 10), math.random(5, 10), math.random(-10, 10))
        end
    end)

wait(0.1)
end

"add a customizable height to the script"

"Noclip toggle on"

"make a 3d model"

"when you touch the block you will enter a really random roblox game"

"make chat tags that congratulate players once they have reached certain stage stats"

"Create cutscene script that goes in startergui that will put the players camera on Cam 1 and Cam 2 in workspace and make the Cam1 and Cam 2 parts spin around the sphere then cut out into a Black screen go back to the Players normal camera do this When a ProximityPrompt in Activate part is used"

```lua
-- local script (StarterGUI) 
local proximityPrompt = game.Workspace.ActivatePart:FindFirstChild("ProximityPrompt")
local cam1 = game.Workspace.Cam1
local cam2 = game.Workspace.Cam2
local sphere = game.Workspace.Sphere -- Assuming there's a Sphere part in the Workspace to rotate around
local player = game.Players.LocalPlayer
local camera = game.Workspace.CurrentCamera
local originalCamType = camera.CameraType
local originalCamFocus = camera.CameraSubject

local function onPromptTriggered()
    camera.CameraType = Enum.CameraType.Scriptable
    local camPositions = {cam1, cam2}
    
    for _, camPart in ipairs(camPositions) do
        camera.CFrame = CFrame.new(camPart.Position, sphere.Position)
        for i = 1, 360, 10 do
            camPart.CFrame = camPart.CFrame * CFrame.Angles(0, math.rad(10), 0)
            camera.CFrame = CFrame.new(camPart.Position, sphere.Position)
            wait(0.1)
        end
    end
    
    -- Fade to black then revert to player's camera
    local screenGui = Instance.new("ScreenGui", player.PlayerGui)
    local blackScreen = Instance.new("Frame", screenGui)
    blackScreen.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    blackScreen.Size = UDim2.new(1, 0, 1, 0)
    blackScreen.ZIndex = 10 -- Ensuring it's on top of other GUI elements
    
    wait(2) -- Duration of the black screen
    
    -- Remove the black screen and revert camera
    blackScreen:Destroy()
    camera.CameraType = originalCamType
    camera.CameraSubject = originalCamFocus
end

proximityPrompt.Triggered:Connect(onPromptTriggered)
```

"Please take note of the following text: Develop an optimized leader stats system with currency, rebirths, and gem values. Create a folder containing all the values for each statistic."

"Create a 2D camera that is fixed parallel to the player on the x axis, can still follow the player while they are moving, but disables the ability to zoom in or out"

"make a script that walks my character 3 studs in front of where a close opposite team player will move"

-- local script 
local Players = game:GetService("Players")
local PathfindingService = game:GetService("PathfindingService")

local player = Players.LocalPlayer
local myTeam = player.Team
local myCharacter = player.Character
local myHumanoid = myCharacter:FindFirstChild("Humanoid")

local closestOpponent = nil
local closestDistance = math.huge

for _, otherPlayer in ipairs(Players:GetPlayers()) do
    if otherPlayer.Team ~= myTeam and otherPlayer.Character and otherPlayer.Character:FindFirstChild("Humanoid") then
        local distance = (myCharacter.HumanoidRootPart.Position - otherPlayer.Character.HumanoidRootPart.Position).magnitude
        if distance < closestDistance then
            closestOpponent = otherPlayer
            closestDistance = distance
        end
    end
end

if closestOpponent then
    local path = PathfindingService:CreatePath()
    path:ComputeAsync(myCharacter.HumanoidRootPart.Position, closestOpponent.Character.HumanoidRootPart.Position)

local waypoints = path:GetWaypoints()
    for i, waypoint in ipairs(waypoints) do
        if i == 1 then
            myHumanoid:MoveTo(waypoint.Position + Vector3.new(0, 0, 3)) -- move 3 studs in front
        else
            myHumanoid:MoveTo(waypoint.Position)
        end
        myHumanoid.MoveToFinished:Wait()
    end
end

"Can you make physics based animation system for R15 players using constraints and CFrames to animate arms and legs to move realistically?"

Creating a physics-based animation system for R15 players using constraints and CFrames is a complex task and would require a deep understanding of Roblox constraints, CFrames, and character rigging. However, I can provide you with a basic example of how to use Motor6D and CFrame to animate a character's arm.

This script should be placed in a LocalScript inside the StarterPlayerScripts folder.

```lua
local Players = game:GetService("Players")

local function animateCharacter(character)
    local humanoid = character:WaitForChild("Humanoid")
    local leftArm = character:WaitForChild("Left Arm")
    local rightArm = character:WaitForChild("Right Arm")
    local leftShoulder = character:WaitForChild("Left Shoulder")
    local rightShoulder = character:WaitForChild("Right Shoulder")

local leftShoulderC0 = leftShoulder.C0
    local rightShoulderC0 = rightShoulder.C0

while true do
        -- Animate left arm
        leftShoulder.C0 = leftShoulderC0 * CFrame.Angles(0, 0, math.rad(30))
        rightShoulder.C0 = rightShoulderC0 * CFrame.Angles(0, 0, math.rad(-30))
        wait(0.5)

-- Reset left arm
        leftShoulder.C0 = leftShoulderC0
        rightShoulder.C0 = rightShoulderC0
        wait(0.5)
    end
end

local function onCharacterAdded(character)
    animateCharacter(character)
end

local function onPlayerAdded(player)
    player.CharacterAdded:Connect(onCharacterAdded)
    if player.Character then
        onCharacterAdded(player.Character)
    end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in ipairs(Players:GetPlayers()) do
    onPlayerAdded(player)
end
```

This script will animate the character's arms to move back and forth. You can expand on this concept to create a more realistic animation system using additional constraints and CFrames for other body parts.

Keep in mind that this is just a starting point, and creating a full physics-based animation system will require a lot of experimentation and fine-tuning.

"Create a script that saves players position that won’t make players fall of map"

-- Local script 
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")

local function savePosition()
    local savedPosition = humanoidRootPart.Position
    game:GetService("DataStoreService"):GetDataStore("PlayerPositions"):SetAsync(player.UserId, savedPosition)
end

local function loadPosition()
    local savedPosition = game:GetService("DataStoreService"):GetDataStore("PlayerPositions"):GetAsync(player.UserId)
    if savedPosition then
        local newY = workspace.Baseplate.Size.Y/2 + 5
        if savedPosition.Y < newY then
            savedPosition = Vector3.new(savedPosition.X, newY, savedPosition.Z)
        end
        humanoidRootPart.CFrame = CFrame.new(savedPosition)
    end
end

player.CharacterAdded:Connect(function(character)
    humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    loadPosition()
end)

game:BindToClose(function()
    savePosition()
end)

"Give me a realistic smooth motion blur script that applies blur when the player rotates their camera in first person."

"create a add friend gui and you make the gui using a script"

"when any player spawns in, give them a tool named "Gura-Gura" . this tool should have a moveset with keybinds Z,X,C,V and the moves should be based on the Gura Gura fruit in one piece"

-- server script 
game.Players.PlayerAdded:Connect(function(player)
	local tool = Instance.new("Tool")
	tool.Name = "Gura-Gura"
	tool.Parent = player.Backpack
	
	local moveSet = tool:FindFirstChild("MoveSet")
	if not moveSet then
		moveSet = Instance.new("MoveSet")
		moveSet.Name = "MoveSet"
		moveSet.Parent = tool
	end
	
	local move1 = moveSet:FindFirstChild("Move1")
	if not move1 then
		move1 = Instance.new("Move")
		move1.Name = "Move1"
		move1.KeyCode = Enum.KeyCode.Z
		move1.Parent = moveSet
	end
	
	local move2 = moveSet:FindFirstChild("Move2")
	if not move2 then
		move2 = Instance.new("Move")
		move2.Name = "Move2"
		move2.KeyCode = Enum.KeyCode.X
		move2.Parent = moveSet
	end
	
	local move3 = moveSet:FindFirstChild("Move3")
	if not move3 then
		move3 = Instance.new("Move")
		move3.Name = "Move3"
		move3.KeyCode = Enum.KeyCode.C
		move3.Parent = moveSet
	end
	
	local move4 = moveSet:FindFirstChild("Move4")
	if not move4 then
		move4 = Instance.new("Move")
		move4.Name = "Move4"
		move4.KeyCode = Enum.KeyCode.V
		move4.Parent = moveSet
	end
end)

"NPC that stalks and kills"

"make a stage and rebirth script with leaderstats and datastores for an obby. Stages are numbered parts in the Checkpoints folder. Rebirth player if stage 65 and they touch the part called Rebirth. add detailed comments, explanation and instructions"

-- main script (ServerScriptService) 
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local StageDataStore = DataStoreService:GetDataStore("StageData")
local Checkpoints = game.Workspace.Checkpoints

function onPlayerAdded(player)
    -- create leaderstats and values
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player
    
    local stage = Instance.new("IntValue")
    stage.Name = "Stage"
    stage.Value = 0
    stage.Parent = leaderstats
    
    local rebirths = Instance.new("IntValue")
    rebirths.Name = "Rebirths"
    rebirths.Value = 0
    rebirths.Parent = leaderstats
    
    -- load player data
    local success, errorMessage = pcall(function()
        local loadedData = StageDataStore:GetAsync(player.UserId .. "-StageData")
        if loadedData then
            stage.Value = loadedData[1]
            rebirths.Value = loadedData[2]
        end
    end)
    if not success then
        print("Error loading data: " .. errorMessage)
    end
end

function onPlayerRemoving(player)
    -- save player data
    local success, errorMessage = pcall(function()
        StageDataStore:SetAsync(player.UserId .. "-StageData", {player.leaderstats.Stage.Value, player.leaderstats.Rebirths.Value})
    end)
    if not success then
        print("Error saving data: " .. errorMessage)
    end
end

Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

-- script for stage checkpoints 
for i, stagePart in ipairs(Checkpoints:GetChildren()) do
    stagePart.Touched:Connect(function(hit)
        local player = game.Players:FindFirstChild(hit.Parent.Name)
        if player and player.leaderstats.Stage.Value < tonumber(stagePart.Name) then
            player.leaderstats.Stage.Value = tonumber(stagePart.Name)
        end
    end)
end

-- script for Rebirth part 
local rebirthPart = game.Workspace.Rebirth

rebirthPart.Touched:Connect(function(hit)
    local player = game.Players:FindFirstChild(hit.Parent.Name)
    if player and player.leaderstats.Stage.Value >= 65 then
        player.leaderstats.Stage.Value = 0
        player.leaderstats.Rebirths.Value = player.leaderstats.Rebirths.Value + 1
        player.Character.HumanoidRootPart.CFrame = Checkpoints["1"].CFrame + Vector3.new(0, 5, 0)
    end
end)

--[[ Instructions:
1. Create a folder named "Checkpoints" in the Workspace.
2. Inside the folder, create numbered parts for each stage (e.g., 1, 2, 3, etc.).
3. Create a part named "Rebirth" in the Workspace for the rebirth location.
4. Place the main script in ServerScriptService.
5. Place the stage checkpoints script and the rebirth script in the same script as the main script.
6. Test the game to ensure stages and rebirths are working as intended.
7. Data is saved and loaded using DataStores, so progress will be saved across sessions.
--]]

"agora faça um sistema de simulador de velocidade no roblox studio. quanto mais tempo o jogador correr, mais rapido ele corre. Leaderboard mostrando a velocidade atual do jogador. script completo, eficaz e complexo."

-- server script
local Players = game:GetService("Players")

local function onPlayerAdded(player)
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player

local jumpPower = Instance.new("IntValue")
    jumpPower.Name = "JumpPower"
    jumpPower.Value = 50
    jumpPower.Parent = leaderstats
end

Players.PlayerAdded:Connect(onPlayerAdded)

-- local script
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local leaderstats = player:WaitForChild("leaderstats")
local jumpPower = leaderstats:WaitForChild("JumpPower")
local jumping = false

local function updateJumpPower()
    while jumping do
        jumpPower.Value = jumpPower.Value   1
        humanoid.JumpPower = jumpPower.Value
        wait(0.5)
  end
end

local function onJumpRequest()
    if not jumping then
        jumping = true
        updateJumpPower()
    end
end

humanoid.JumpRequest:Connect(onJumpRequest)
humanoid.Landed:Connect(function()
    jumping = false
end)

-- TextLabel update script (inside a ScreenGui)
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("leaderstats")
local jumpPower = leaderstats:WaitForChild("JumpPower")
local textLabel = script.Parent

while true do
    textLabel.Text = "Jump Power: " .. jumpPower.Value
    wait(1)
end

"create a text button that shows how many players are playing in a different game place."

"the humanoid rootpart isnt getting anchored,"

-- That's correct. The rootPart is not getting anchored because the PlayerAdded event is fired before the player's character is loaded in the game. Therefore, the humanoid and rootPart do not exist yet when the script tries to access them. Here's a corrected version of the script.

local tweenService = game:GetService('TweenService')
local gui1 = script.Parent.Menu.GameName
local tweenInfo1 = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
local goal1 = {Position = UDim2.new(1, 0, 1, 0)}
local tween1 = tweenService:Create(gui1, tweenInfo1, goal1)
local gui = script.Parent.Menu.Play
local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
local goal = {Position = UDim2.new(1, 0, 1, 0)}
local tween = tweenService:Create(gui, tweenInfo, goal)

local blur = Instance.new("BlurEffect", game.Lighting)
blur.Size = 15

local function start()
	tween:Play()
	tween1:Play()
	blur:Destroy()
end

gui.MouseButton1Click:Connect(start)

game.Players.PlayerAdded:Connect(function(player)
	player.CharacterAdded:Connect(function(character)
		local humanoid = character:WaitForChild('Humanoid')
		local rootPart = humanoid.RootPart
		rootPart.Anchored = true
	end)
end)

"make the model shake, fall, disappear and reset, 2 seconds after the player stands on it. add detailed comments, explanation and instructions."

-- server script 
local model = script.Parent -- reference to the model
local debounce = true -- to prevent multiple triggers

local function shakeModel()
    for i = 1, 20 do -- repeat the shake 20 times
        model:SetPrimaryPartCFrame(model.PrimaryPart.CFrame * CFrame.Angles(0, 0, math.rad(5))) -- rotate the model 5 degrees
        wait(0.05) -- wait for 0.05 seconds
        model:SetPrimaryPartCFrame(model.PrimaryPart.CFrame * CFrame.Angles(0, 0, math.rad(-10))) -- rotate the model -10 degrees
        wait(0.05) -- wait for 0.05 seconds
        model:SetPrimaryPartCFrame(model.PrimaryPart.CFrame * CFrame.Angles(0, 0, math.rad(5))) -- rotate the model 5 degrees
    end
end

local function onTouch(hit)
    if debounce then -- check if debounce is true
        debounce = false -- set debounce to false to prevent multiple triggers
        local character = hit.Parent
        local humanoid = character:FindFirstChildWhichIsA("Humanoid")

if humanoid then -- check if a player touched the model
            shakeModel() -- call the shakeModel function to shake the model
            wait(2) -- wait for 2 seconds
            model:BreakJoints() -- break the joints to make the model fall
            wait(2) -- wait for 2 seconds
            model:Destroy() -- destroy the model
            wait(2) -- wait for 2 seconds
            game:GetService("Debris"):AddItem(model, 0) -- remove the model from workspace
            debounce = true -- reset debounce to true
        end
    end
end

model.PrimaryPart.Touched:Connect(onTouch) -- connect the onTouch function to the Touched event of the model's PrimaryPart

-- Instructions:
1. Create a model in the workspace with a PrimaryPart set.
2. Add this script as a child of the model.
3. When a player stands on the model, it will shake, fall, disappear, and reset with the specified delays.

"make a proximityprompt inside of a player and then put sounds that play upon starting the proximity prompt"

"create a local player script for existing leaderboard value that named ["Cubes Collected"] i want you to create GUI that will show same value as on leaderboard, GUI must be on the top of the screen"

"make a script where only a player with the username ijustgothitby_acar can see a gui at the top of the screen when he clicks it it will show this image id on the screen 12412007525 for 3 seconds andfor 3 seconds it will also play this sound 4283208648 make it so the jumpscare fills up the whole screen"

-- This mode only specializes in Module scripts, we recommend using another appropriate mode for getting better responses for this query 
-- local script (StarterGUI) 
local player = game.Players.LocalPlayer
local allowedUsername = "ijustgothitby_acar"

if player.Name == allowedUsername then
    local screenGui = Instance.new("ScreenGui", player.PlayerGui)

local button = Instance.new("TextButton", screenGui)
    button.Text = "Click me"
    button.Size = UDim2.new(0, 100, 0, 50)
    button.Position = UDim2.new(0.5, -50, 0, 0)

local function showJumpscare()
        local jumpscareImage = Instance.new("ImageLabel", screenGui)
        jumpscareImage.Image = "rbxassetid://12412007525"
        jumpscareImage.Size = UDim2.new(1, 0, 1, 0)
        jumpscareImage.BackgroundTransparency = 1

local jumpscareSound = Instance.new("Sound", screenGui)
        jumpscareSound.SoundId = "rbxassetid://4283208648"
        jumpscareSound:Play()

wait(3)

jumpscareImage:Destroy()
        jumpscareSound:Destroy()
    end

button.MouseButton1Click:Connect(showJumpscare)
end

"create a server announcement"

"constantly keep getting touching parts when bool == true"

-- server script 
local part = script.Parent.TriggerMG
local s = script.Parent.TriggerMG.Shoot
local shots = script.Parent.Browning.Gunshots
local bool = script.Parent.Shoot
local seat = script.Parent.Parent.Body.Seatt

local function onPartTouched(otherPart)
	local model = otherPart.Parent
	local humanoid = model:FindFirstChild("Zombie")
	if bool.Value == true then
		local transparencySequence = NumberSequence.new(0)
		shots.FX.Transparency = transparencySequence
		shots.FlashFX.Enabled = true
		s:Play()
		if humanoid then
			humanoid.Health -= 350
			task.wait(1)
		end
	elseif bool.Value == false then
		task.wait(0.6)
		local transparencySequence1 = NumberSequence.new(1)
		shots.FX.Transparency = transparencySequence1
		shots.FlashFX.Enabled = false
		s:Stop()
	end
end

while true do
	if bool.Value == true then
		local partsTouching = part:GetTouchingParts()
		for i, otherPart in ipairs(partsTouching) do
			onPartTouched(otherPart)
		end
		task.wait(1)
	else
		task.wait(0.6)
		local transparencySequence1 = NumberSequence.new(1)
		shots.FX.Transparency = transparencySequence1
		shots.FlashFX.Enabled = false
		s:Stop()
	end
end

"award players a badge if they are in the same game as a player of a specific user id"

"make it so if script.parent mouseclicked and the .text = '>' then make it = '<' and frame visible and tween -10, 0, 0.119, 0. if mouseclicked and = '<' then make it = '>' frame true and tween 0.006, 0, 0.119, 0"

"npc that follows the player"

"no not the money saved, but the purchases which are in game.workspace.Islands.Island.Items, which destroy themselves whenever a player joins, so when a player purchases them, it clones it back to the Items folder from replicated storage, so i need saving so the purchase progress saves"

Sure, you can modify the script to save and load the items that the player has purchased. Here's how you can do it:

```lua
-- script for saving 
game.Players.PlayerRemoving:Connect(function(player)
    local DataStoreService = game:GetService("DataStoreService")
    local myDataStore = DataStoreService:GetDataStore("myDataStore")
    local items = game.Workspace.Islands.Island.Items:GetChildren()
    local purchasedItems = {}
    for i, item in ipairs(items) do
        if item.Owner.Value == player then
            table.insert(purchasedItems, item.Name)
        end
    end
    local success, err = pcall(function()
        myDataStore:SetAsync(tostring(player.UserId), purchasedItems)
    end)
    if success then
        print("Data saved.")
    else
        warn("Failed to save data:", err)
    end
end)

game.Players.PlayerAdded:Connect(function(player)
    local DataStoreService = game:GetService("DataStoreService")
    local myDataStore = DataStoreService:GetDataStore("myDataStore")
    local success, data = pcall(function()
        return myDataStore:GetAsync(tostring(player.UserId))
    end)
    if success and data then
        for i, itemName in ipairs(data) do
            local item = game.ReplicatedStorage.Items:FindFirstChild(itemName):Clone()
            item.Parent = game.Workspace.Islands.Island.Items
            item.Owner.Value = player
        end
    end
end)
```

This script will save the names of the items that the player has purchased when they leave the game and clone them from the ReplicatedStorage when they join. The items are stored based on the player's UserId, so it will be unique to each player. If there is an error with saving or loading the data, it will print a warning in the output with the error message.

"script for a part so when you say "damien" it makes the part disappear with instructions on where to insert the script"

To create a script that makes a part disappear when you say "damien," you can use a `Chatted` event listener on the player. You would place this script in `ServerScriptService` to ensure it runs on the server side. Below is an example of how you would write this script:

```lua
-- Place this script in ServerScriptService

-- Function to handle the chat message
local function onPlayerChatted(player, message)
    if message:lower() == "damien" then -- Check if the message is "damien"
        local part = game.Workspace:FindFirstChild("PartName") -- Replace "PartName" with the actual name of the part
        if part then
            part:Destroy() -- Remove the part from the game
        end
    end
end

-- Connect the function to the Chatted event for each player
game.Players.PlayerAdded:Connect(function(player)
    player.Chatted:Connect(function(message)
        onPlayerChatted(player, message)
    end)
end)
```

Here's a step-by-step guide on where to insert the script:

1. Open Roblox Studio and go to your game.
2. In the Explorer window, find `ServerScriptService`. If you don't see the Explorer window, you can enable it from the View tab.
3. Right-click on `ServerScriptService` and select `Insert Object`.
4. Choose `Script` from the list to create a new script.
5. Copy and paste the code provided above into the new script.
6. Replace `"PartName"` in the script with the actual name of the part you want to disappear.
7. Save the script and run your game to test it.

Make sure that the part you want to disappear is named correctly in the Workspace and that it is not anchored if you want it to disappear immediately. If the part is anchored, it will not fall or be affected by physics, but it will still become invisible and non-interactive.

"Create an artificial intelligence for a model of a creature. She chases and kills nearby players. Plus she dodges and jumps from obstacles! Make a complex, complete and error-free script."

-- This is a complex task, so I'll provide a basic outline of the script. You can expand on it as needed.

-- Server Script
local creature = game.Workspace.Creature
local humanoid = creature.Humanoid
local rootPart = creature.HumanoidRootPart
local pfs = game:GetService("PathfindingService")
local players = game:GetService("Players")

local function findNearestPlayer()
    local nearestPlayer = nil
    local shortestDistance = math.huge

for _, player in pairs(players:GetPlayers()) do
        local character = player.Character
        if character then
            local distance = (character.HumanoidRootPart.Position - rootPart.Position).Magnitude
            if distance < shortestDistance then
                nearestPlayer = character
                shortestDistance = distance
            end
        end
    end

return nearestPlayer
end

local function moveToTarget(target)
    local path = pfs:CreatePath()
    path:ComputeAsync(rootPart.Position, target.Position)

for _, waypoint in pairs(path:GetWaypoints()) do
        humanoid:MoveTo(waypoint.Position)
        humanoid.MoveToFinished:Wait()
        if waypoint.Action == Enum.PathWaypointAction.Jump then
            humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
        end
    end
end

local function attackPlayer(player)
    -- Implement your attack logic here
end

while true do
    local target = findNearestPlayer()
    if target then
        moveToTarget(target.HumanoidRootPart)
        attackPlayer(target)
    end
    wait(1)
end

"make a script for pets that players can unlock when they reach certain stages and rebirths. the pets float and follow behind the player. pets can be selected from a ui add detailed comments, explanation and instructions"

-- server script 
local petsFolder = game.ServerStorage.Pets
local petStats = {
    {name = "Pet1", stage = 1, rebirth = 0},
    {name = "Pet2", stage = 5, rebirth = 0},
    {name = "Pet3", stage = 10, rebirth = 1},
    -- Add more pets here with their corresponding stage and rebirth requirements
}

local function checkPetRequirements(player, petName)
    local petRequirement = nil
    for _, pet in ipairs(petStats) do
        if pet.name == petName then
            petRequirement = pet
            break
        end
    end

if not petRequirement then return false end

local playerStats = player.leaderstats
    return playerStats.Stage.Value >= petRequirement.stage and playerStats.Rebirths.Value >= petRequirement.rebirth
end

local function onPetSelected(player, petName)
    if checkPetRequirements(player, petName) then
        local pet = petsFolder:FindFirstChild(petName):Clone()
        pet.Parent = player.Character
        pet.Disabled = false
    end
end

game.ReplicatedStorage.Events.PetSelected.OnServerEvent:Connect(onPetSelected)

-- local script (inside a ScreenGui) 
local player = game.Players.LocalPlayer
local petsUI = script.Parent.PetsUI
local petButtons = petsUI.PetButtons:GetChildren()

for _, button in ipairs(petButtons) do
    button.MouseButton1Click:Connect(function()
        game.ReplicatedStorage.Events.PetSelected:FireServer(button.Name)
    end
end)

-- pet script (inside a pet model in ServerStorage) 
local pet = script.Parent
local owner = pet.Parent
local distanceThreshold = 10
local followSpeed = 5

while true do
    local distance = (owner.HumanoidRootPart.Position - pet.Position).magnitude
    if distance > distanceThreshold then
        local newPosition = owner.HumanoidRootPart.Position - (owner.HumanoidRootPart.CFrame.lookVector * distanceThreshold)
        pet.Position = pet.Position:Lerp(newPosition, followSpeed * wait())
    else
        wait()
    end
end

-- Instructions 
-- 1. Create a folder named "Pets" inside ServerStorage and put pet models inside it with their corresponding names mentioned in the petStats table.
-- 2. Add a pet script to each pet model and make sure it's disabled by default.
-- 3. Create a ScreenGui with a frame named "PetsUI" containing pet selection buttons. Name each button according to the pet names in the petStats table.
-- 4. Add the local script to the ScreenGui.
-- 5. Create a RemoteEvent named "PetSelected" inside ReplicatedStorage and a folder named "Events".
-- 6. Add the server script to ServerScriptService.

-- Explanation 
-- The server script checks if a player meets the requirements for a pet when they select it from the UI.
-- The local script listens for MouseButton1Click on the pet buttons and fires the PetSelected RemoteEvent.
-- The pet script makes the pet model follow the owner (player) at a certain distance and speed.

"make a script that plays a sound whenever a NPC called Bandit is damaged but only players close enough can hear it"

"a roblox script that prints "Fully loaded" once your game is fully loaded, also tell where to put it"

"make a script for pets that players can unlock when they reach certain stages and rebirths. the pets float and follow behind the player. pets can be selected from a ui add detailed comments, explanation and instructions"

-- server script for pet system

-- Create a folder in ServerStorage named "Pets"
-- Add pet models to the folder, each pet should have a humanoid root part and a humanoid
-- Create a UI for pet selection and place it in StarterGui

local ServerStorage = game:GetService("ServerStorage")
local petsFolder = ServerStorage.Pets

local function spawnPet(player, petName)
    local pet = petsFolder:FindFirstChild(petName):Clone()
    pet.Parent = game.Workspace
    pet.HumanoidRootPart.CFrame = player.Character.HumanoidRootPart.CFrame * CFrame.new(0, 2, -5)
    pet.HumanoidRootPart.Anchored = false
    pet.HumanoidRootPart:SetNetworkOwner(player)
    return pet
end

local function followPlayer(player, pet)
    while pet.Parent == game.Workspace do
        local targetPos = player.Character.HumanoidRootPart.CFrame * CFrame.new(0, 2, -5)
        pet.HumanoidRootPart.CFrame = pet.HumanoidRootPart.CFrame:Lerp(targetPos, 0.1)
        wait()
    end
end

game.Players.PlayerAdded:Connect(function(player)
    local selectedPet = nil
    player.CharacterAdded:Connect(function(character)
        if selectedPet then
            selectedPet:Destroy()
        end
    end)

local gui = game.StarterGui.PetSelectionUI:Clone()
    gui.Parent = player.PlayerGui

for _, button in ipairs(gui.PetList:GetChildren()) do
        if button:IsA("TextButton") then
            button.MouseButton1Click:Connect(function()
                if selectedPet then
                    selectedPet:Destroy()
                end
                selectedPet = spawnPet(player, button.Text)
                followPlayer(player, selectedPet)
            end)
        end
    end
end)

-- UI script for pet selection (StarterGui -> PetSelectionUI) 
local petList = script.Parent.PetList
local openButton = script.Parent.OpenButton

local function togglePetList()
    petList.Visible = not petList.Visible
end

openButton.MouseButton1Click:Connect(togglePetList)

"gun system"

"can you make me a Sport mode script for my chassis tune and vehicle on roblox?"

"print hello world but don't print hello world"

"Give me a realistic smooth motion blur script that applies blur when the player rotates their camera in first person."

"make me a script where if you press a button a frame appears from starter gui"

"make the decal change on a part from 3"

"Make a part that if a player hits the part it will make them sit for 3 seconds then after they hit the part after 5 second they will instantly die"

"make all letter 'e' change nto the letter 3"

"Create a script where the camera rotates with Player head"

"rain red bricks from the air forever super fast that turns black when they touch the ground. 2 seconds after touching the ground it launches 6 0.1x0.1 size blocks every direction"

-- server script (ServerScriptService) 
while true do
    local part = Instance.new("Part")
    part.Parent = game.Workspace
    part.Size = Vector3.new(4, 1, 2)
    part.Position = Vector3.new(math.random(-100, 100), 50, math.random(-100, 100))
    part.Color = Color3.fromRGB(255, 0, 0)
    part.Anchored = false
    part.BrickColor = BrickColor.new("Bright red")
    part.CanCollide = true

local function onTouched()
        part.Color = Color3.fromRGB(0, 0, 0)
        wait(2)

for i = 1, 6 do
            local smallPart = Instance.new("Part")
            smallPart.Parent = game.Workspace
            smallPart.Size = Vector3.new(0.1, 0.1, 0.1)
            smallPart.Position = part.Position
            smallPart.BrickColor = BrickColor.new("Really black")
            smallPart.CanCollide = true
            smallPart.Velocity = Vector3.new(math.random(-100, 100), math.random(50, 100), math.random(-100, 100))
        end

part:Destroy()
    end

part.Touched:Connect(onTouched)
    wait(0.1)
end

"Please create a script for an image button that, when clicked, will prompt the player to purchase a game pass for the game."

"can you make me a script so when any player types /b it copies a ball and brings it to them and you can have 3 balls allowed copied if 3 balls are copied and a player types /b one of the balls that were copied tps back to them"

"make a script to make chat messages saying "Player has been awarded the _ badge" in different colours when players acquire specific badges."

"make a script that turns all of your hats into blocks"

"create a script that makes the player roll forward when the player press Q and plays a rolling animation."

"When you say "this game sucks" you lose 10 health every 2 seconds. It stops until you say "this game is amazing""

"Make me a Script that Increase the Players Size every time they gain 10 Muscle And adds Muscle Texture to their skin/Avatar and every 10 Muscle they will be able to do 10 More Damage For a Gui with a MAX size of 35 instructions on where to set"

-- server script (ServerScriptService) 
local Players = game:GetService("Players")

local function onCharacterAdded(character)
    local humanoid = character:WaitForChild("Humanoid")
    local player = Players:GetPlayerFromCharacter(character)
    local muscle = player.leaderstats.Muscle
    local damage = player.leaderstats.Damage

local function updateSize()
        local newSize = 1 + (muscle.Value // 10) * 0.1
        newSize = math.min(newSize, 3.5) -- max size of 35 instructions
        humanoid.BodyHeightScale.Value = newSize
        humanoid.BodyWidthScale.Value = newSize
        humanoid.BodyDepthScale.Value = newSize
    end

local function updateDamage()
        damage.Value = 10 + (muscle.Value // 10) * 10
    end

local function updateTexture()
        local texture = Instance.new("Texture")
        texture.Texture = "rbxassetid://muscle_texture_id" -- replace with the actual muscle texture asset ID
        texture.Parent = character.Head
    end

muscle.Changed:Connect(function()
        updateSize()
        updateDamage()
        updateTexture()
    end)
end

Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Connect(onCharacterAdded)
end)

-- local script for GUI 
local player = game.Players.LocalPlayer
local muscle = player.leaderstats.Muscle
local muscleLabel = script.Parent.MuscleLabel

local function updateMuscleLabel()
    muscleLabel.Text = "Muscle: " .. tostring(muscle.Value)
end

muscle.Changed:Connect(updateMuscleLabel)
updateMuscleLabel()

-- Place the local script inside a TextLabel in a ScreenGui in the StarterGui

"create a gui notification with tools name and Image when player receive new tool in the player backpack"

"When they leave the game their data gets saved and when they get an error it will say reload game. do not kick the person"

-- data store script (ServerScriptService) 
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local dataStore = DataStoreService:GetDataStore("PlayerData")

local function saveData(player)
    local success, err = pcall(function()
        local data = {
            Coins = player.leaderstats.Coins.Value,
            Bag = player.leaderstats.Bag.Value
        }
        dataStore:SetAsync(player.UserId, data)
    end)

if not success then
        player:Kick("An error occurred while saving your data. Please reload the game.")
    end
end

local function loadData(player)
    local success, err = pcall(function()
        local data = dataStore:GetAsync(player.UserId)
        if data then
            player.leaderstats.Coins.Value = data.Coins
            player.leaderstats.Bag.Value = data.Bag
        end
    end)

if not success then
        player:Kick("An error occurred while loading your data. Please reload the game.")
    end
end

Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Wait()
    loadData(player)
end)

Players.PlayerRemoving:Connect(function(player)
    saveData(player)
end)

"Create a script that makes an image in a image label in screen gui move"

"make a natural disaster script that either spawns a super long lava spinner or makes random lava balls that move up for 500 studs before getting deleted or makes green pads spawn in a range around the player that when touched heal the player 25 health before deleting the part also make all reddamage"

```lua
-- server script (ServerScriptService) for natural disaster

local disasterType = math.random(1, 3) -- Randomly choose the disaster type

if disasterType == 1 then
    -- Lava Spinner
    local spinner = Instance.new("Part")
    spinner.Parent = game.Workspace
    spinner.Position = Vector3.new(0, 10, 0)
    spinner.Anchored = true
    spinner.Shape = Enum.PartType.Cylinder
    spinner.Size = Vector3.new(500, 1, 500) -- Super long and flat
    spinner.Color = Color3.fromRGB(255, 0, 0)
    spinner.Name = "LavaSpinner"

while true do
        spinner.CFrame = spinner.CFrame * CFrame.Angles(0, math.rad(5), 0) -- Rotate
        wait(0.1)
    end
elseif disasterType == 2 then
    -- Lava Balls
    while true do
        local lavaBall = Instance.new("Part")
        lavaBall.Parent = game.Workspace
        lavaBall.Position = Vector3.new(math.random(-100, 100), 0, math.random(-100, 100))
        lavaBall.Size = Vector3.new(5, 5, 5)
        lavaBall.Shape = Enum.PartType.Ball
        lavaBall.Color = Color3.fromRGB(255, 0, 0)
        lavaBall.Name = "LavaBall"

local bodyVelocity = Instance.new("BodyVelocity")
        bodyVelocity.Parent = lavaBall
        bodyVelocity.Velocity = Vector3.new(0, 100, 0) -- Move up

game.Debris:AddItem(lavaBall, 5) -- Delete after 5 seconds
        wait(1)
    end
elseif disasterType == 3 then
    -- Green Pads
    game.Players.PlayerAdded:Connect(function(player)
        player.CharacterAdded:Connect(function(char)
            while true do
                local greenPad = Instance.new("Part")
                greenPad.Parent = game.Workspace
                greenPad.Position = char.HumanoidRootPart.Position + Vector3.new(math.random(-50, 50), 0, math.random(-50, 50))
                greenPad.Size = Vector3.new(5, 1, 5)
                greenPad.Color = Color3.fromRGB(0, 255, 0)
                greenPad.Name = "GreenPad"

local function heal(otherPart)
                    local player = game.Players:GetPlayerFromCharacter(otherPart.Parent)
                    if player then
                        local humanoid = otherPart.Parent:FindFirstChildWhichIsA("Humanoid")
                        if humanoid then
                            humanoid.Health = humanoid.Health + 25
                            greenPad:Destroy()
                        end
                    end
                end

greenPad.Touched:Connect(heal)
                wait(10)
            end
        end)
    end)
end
```

"Make a sandwich that when touched will float and spin around for 5 seconds in different directions with instructions where to put the code"

To create a sandwich that floats and spins when touched, follow these steps:

1. Create a part in Roblox Studio and name it "Sandwich".
2. Add a script to the "Sandwich" part.
3. Paste the following code into the script:

```lua
local sandwich = script.Parent

local function onTouch(hit)
    local originalPosition = sandwich.Position
    local originalOrientation = sandwich.Orientation

sandwich.Anchored = true
    for i = 1, 5 do
        sandwich.Position = sandwich.Position + Vector3.new(0, 0.1, 0)
        sandwich.Orientation = sandwich.Orientation + Vector3.new(0, 10, 0)
        wait(1)
    end

for i = 1, 5 do
        sandwich.Position = sandwich.Position - Vector3.new(0, 0.1, 0)
        sandwich.Orientation = sandwich.Orientation - Vector3.new(0, 10, 0)
        wait(1)
    end

sandwich.Position = originalPosition
    sandwich.Orientation = originalOrientation
    sandwich.Anchored = false
end

sandwich.Touched:Connect(onTouch)
```

This script will make the sandwich float and spin when touched. It will float up and spin for 5 seconds and then float back down to its original position.

"create a script that makes the player roll forward when the player press Q"

"a roblox script that when you step on a part named LightChanger it will smoothly change the tintcolor in ColorCorrection to "0, 208, 3""

"Please make a script that places a certain decal over all the items in my hotbar, giving them a border of sort."

"make a free camera floating above the humanoid at cameraPart.Orientation = Vector3.new(-60, 0, 0) then make it so when y is pressed it enables free camera that has edge scrolling. Make sure edge scrolling is only for free camera"

-- Local script 
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local cameraPart = Instance.new("Part", workspace)
local freeCamEnabled = false

cameraPart.Anchored = true
cameraPart.Transparency = 1
cameraPart.CanCollide = false
cameraPart.Size = Vector3.new(1, 1, 1)
cameraPart.Orientation = Vector3.new(-60, 0, 0)

local function updateCamera()
    while not freeCamEnabled do
        cameraPart.Position = humanoid.RootPart.Position + Vector3.new(0, 10, 0)
        workspace.CurrentCamera.CameraSubject = cameraPart
        wait()
    end
end

local function enableFreeCam()
    freeCamEnabled = true
    workspace.CurrentCamera.CameraSubject = nil
    workspace.CurrentCamera.CameraType = Enum.CameraType.Scriptable
end

local function disableFreeCam()
    freeCamEnabled = false
    workspace.CurrentCamera.CameraType = Enum.CameraType.Custom
    updateCamera()
end

local function onInput(input, gameProcessed)
    if input.KeyCode == Enum.KeyCode.Y and not gameProcessed then
        if not freeCamEnabled then
            enableFreeCam()
        else
            disableFreeCam()
        end
    end
end

UserInputService.InputBegan:Connect(onInput)
updateCamera()

-- Edge scrolling for free camera 
local function edgeScroll()
    local mouse = player:GetMouse()
    local scrollSpeed = 1

while freeCamEnabled do
        local mousePos = mouse.ViewportSize
        local edgeDist = 30

if mousePos.X < edgeDist then
            workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * CFrame.new(scrollSpeed, 0, 0)
        elseif mousePos.X > mouse.ViewportSize.X - edgeDist then
            workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * CFrame.new(-scrollSpeed, 0, 0)
        end

if mousePos.Y < edgeDist then
            workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * CFrame.new(0, scrollSpeed, 0)
        elseif mousePos.Y > mouse.ViewportSize.Y - edgeDist then
            workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * CFrame.new(0, -scrollSpeed, 0)
        end

wait()
    end
end

edgeScroll()

"make me a fly script so when i press E in my keyboard i will fly , and if i press e again i will stop flying"

"create code for a textbutton that will fire a remotevent named ClanEvent in replicated storage when pressed add a cooldown so the textbutton cant be spam clicked"

-- This mode only specializes in Module scripts, we recommend using another appropriate mode for getting better responses for this query 
-- local script (StarterGUI) 
local player = game.Players.LocalPlayer
local screenGui = player:WaitForChild("PlayerGui"):WaitForChild("ScreenGui")
local replicatedStorage = game:GetService("ReplicatedStorage")
local clanEvent = replicatedStorage:WaitForChild("ClanEvent")

local button = Instance.new("TextButton", screenGui)
button.Text = "Clan Event"
button.Size = UDim2.new(0, 200, 0, 50)
button.Position = UDim2.new(0.5, -100, 0.5, -25) -- Center the button
button.TextColor3 = Color3.fromRGB(255, 255, 255)
button.BackgroundColor3 = Color3.fromRGB(0, 0, 0)

local cooldown = false
local cooldownTime = 5 -- seconds

button.MouseButton1Click:Connect(function()
    if not cooldown then
        cooldown = true
        clanEvent:FireServer() -- Assuming it's a RemoteEvent
        button.Text = "Please wait..."
        
        -- Cooldown logic
        wait(cooldownTime)
        cooldown = false
        button.Text = "Clan Event"
    end
end)

"create a script that makes the player roll forward when the player press Q and plays a rolling animation."

"create a player save system and when a player clicks a text button called New data they will reset their tools and leadertstats and when player click on a text button called load they will load in their old leaderstats and Tools."

-- Local Script for New Data button 
local newDataButton = script.Parent.NewData
local player = game.Players.LocalPlayer

local function resetData()
    player.leaderstats:ClearAllChildren()
    player.Backpack:ClearAllChildren()
    -- Add leaderstats and tools initialization here if needed
end

newDataButton.MouseButton1Click:Connect(resetData)

-- Local Script for Load button 
local loadDataButton = script.Parent.Load
local dataStoreService = game:GetService("DataStoreService")
local playerDataStore = dataStoreService:GetDataStore("PlayerData")

local function loadData()
    local success, data = pcall(playerDataStore.GetAsync, playerDataStore, player.UserId)
    if success and data then
        -- Load leaderstats
        for statName, statValue in pairs(data.leaderstats) do
            local stat = Instance.new("IntValue")
            stat.Name = statName
            stat.Value = statValue
            stat.Parent = player.leaderstats
        end

-- Load tools
        for _, toolName in ipairs(data.tools) do
            local tool = game.ServerStorage.Tools:FindFirstChild(toolName)
            if tool then
                tool:Clone().Parent = player.Backpack
            end
        end
    end
end

loadDataButton.MouseButton1Click:Connect(loadData)

-- Server Script for saving player data 
local dataStoreService = game:GetService("DataStoreService")
local playerDataStore = dataStoreService:GetDataStore("PlayerData")

local function savePlayerData(player)
    local data = {
        leaderstats = {},
        tools = {}
    }

-- Save leaderstats
    for _, stat in ipairs(player.leaderstats:GetChildren()) do
        if stat:IsA("IntValue") then
            data.leaderstats[stat.Name] = stat.Value
        end
    end

-- Save tools
    for _, tool in ipairs(player.Backpack:GetChildren()) do
        if tool:IsA("Tool") then
            table.insert(data.tools, tool.Name)
        end
    end

playerDataStore:SetAsync(player.UserId, data)
end

game.Players.PlayerRemoving:Connect(savePlayerData)

"Invisible wall"

"make a script that creates a build tool and allows 6 choices of blocks that are matereals also make it work in 1 script"

-- local script (StarterGUI) 
local player = game.Players.LocalPlayer
local screenGui = Instance.new("ScreenGui", player.PlayerGui)

local buildTool = Instance.new("Tool", player.Backpack)
buildTool.Name = "Build Tool"

local blockTypes = {"Wood", "Metal", "Concrete", "Brick", "Glass", "Plastic"}

local function createBlock(material, parent)
    local block = Instance.new("Part", parent)
    block.Material = Enum.Material[material]
    block.BrickColor = BrickColor.Random()
    return block
end

local function onToolActivated()
    local blockType = blockTypes[math.random(#blockTypes)]
    createBlock(blockType, workspace)
end

buildTool.Activated:Connect(onToolActivated)

for i, blockType in ipairs(blockTypes) do
    local button = Instance.new("TextButton", screenGui)
    button.Text = blockType
    button.TextColor3 = Color3.fromRGB(255, 255, 255)
    button.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    button.UICorner = 5
    button.MouseButton1Click:Connect(function()
        createBlock(blockType, workspace)
    end)
end

"create a script that gives a slime popping particle when NPC is dead. use a random slime popping particle ID."

"make a roblox script where you will move to the most close person using path finding then once your near them you will click left click auto automatically but if they get too far stop but if you get close continue"

-- server script 
local PathfindingService = game:GetService("PathfindingService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local function getClosestPlayer(character)
	local closestPlayer = nil
	local closestDistance = math.huge

for _, player in ipairs(Players:GetPlayers()) do
		if player.Character and player.Character ~= character then
			local distance = (character.HumanoidRootPart.Position - player.Character.HumanoidRootPart.Position).magnitude
			if distance < closestDistance then
				closestPlayer = player
				closestDistance = distance
			end
		end
	end

return closestPlayer
end

local function moveToClosestPlayer(character)
	local path = PathfindingService:CreatePath()
	local closestPlayer = getClosestPlayer(character)

while true do
		closestPlayer = getClosestPlayer(character)
		if closestPlayer then
			path:ComputeAsync(character.HumanoidRootPart.Position, closestPlayer.Character.HumanoidRootPart.Position)
			local waypoints = path:GetWaypoints()

for _, waypoint in ipairs(waypoints) do
				character.Humanoid:MoveTo(waypoint.Position)
				character.Humanoid.MoveToFinished:Wait()

local distance = (character.HumanoidRootPart.Position - closestPlayer.Character.HumanoidRootPart.Position).magnitude
				if distance <= 10 then -- Change this value to the desired distance to start clicking
					-- Add code to simulate left-click
				elseif distance > 20 then -- Change this value to the desired distance to stop clicking
					-- Add code to stop left-click
					break
				end
			end
		end

RunService.Heartbeat:Wait()
	end
end

game.Players.PlayerAdded:Connect(function(player)
	player.CharacterAdded:Connect(function(character)
		moveToClosestPlayer(character)
	end)
end)

"make print hello world"

"Write me the most complex script for time"

-- script for a complex time system in Roblox 
local TimeSystem = {}
TimeSystem.__index = TimeSystem

local function lerp(a, b, t)
    return a + (b - a) * t
end

function TimeSystem.new()
    local self = setmetatable({}, TimeSystem)
    self.TimeOfDay = 0
    self.Speed = 1
    self.Running = false
    self.Lighting = game:GetService("Lighting")
    self.Lighting.ClockTime = 0
    return self
end

function TimeSystem:SetTime(newTime)
    self.TimeOfDay = newTime % 24
    self.Lighting.ClockTime = self.TimeOfDay
end

function TimeSystem:SetSpeed(speed)
    self.Speed = speed
end

function TimeSystem:Start()
    self.Running = true
    while self.Running do
        self.TimeOfDay = (self.TimeOfDay + self.Speed / 60) % 24
        self.Lighting.ClockTime = self.TimeOfDay
        local t = (math.sin(math.pi * self.TimeOfDay / 12) + 1) / 2
        local newAmbient = Color3.fromRGB(lerp(0, 128, t), lerp(0, 128, t), lerp(0, 255, t))
        local newOutdoorAmbient = Color3.fromRGB(lerp(0, 128, t), lerp(0, 128, t), lerp(0, 255, t))
        local newFogColor = Color3.fromRGB(lerp(0, 192, t), lerp(0, 192, t), lerp(0, 255, t))
        self.Lighting.Ambient = newAmbient
        self.Lighting.OutdoorAmbient = newOutdoorAmbient
        self.Lighting.FogColor = newFogColor
        wait(1)
    end
end

function TimeSystem:Stop()
    self.Running = false
end

local timeSystem = TimeSystem.new()
timeSystem:SetTime(12)
timeSystem:SetSpeed(1)
timeSystem:Start()

"can you make a dialogue box that says "wawaw" that appears when the player presses Q"

To create a dialogue box that appears when the player presses the "Q" key, you can use a LocalScript. This script should be placed in a GUI object within the player's PlayerGui. Here's how you can do it:

1. First, create a ScreenGui element inside the PlayerGui of the player.
2. Inside this ScreenGui, create a TextLabel for the dialogue box. Customize it as needed (size, position, color, etc.).
3. Then, create a LocalScript inside the ScreenGui to handle the key press event and display the dialogue.

Here's an example script:

```lua
-- LocalScript inside ScreenGui

local player = game.Players.LocalPlayer
local gui = script.Parent
local textLabel = gui.TextLabel -- Assuming you have a TextLabel named TextLabel

-- Initially, we don't want to show the dialogue
textLabel.Visible = false

-- Function to show the dialogue
local function showDialogue()
    textLabel.Visible = true
    wait(2) -- Wait for 2 seconds
    textLabel.Visible = false
end

-- Function to handle key press
local function onKeyPress(input)
    if input.KeyCode == Enum.KeyCode.Q then
        showDialogue()
    end
end

-- Connect the function to the InputBegan event
game:GetService("UserInputService").InputBegan:Connect(onKeyPress)
```

This script listens for when the player presses the "Q" key. When that happens, it makes the TextLabel visible, effectively showing the dialogue "wawaw" (or whatever text you set the TextLabel to display). After 2 seconds, the dialogue automatically disappears.

Remember to customize the TextLabel to display the text "wawaw" and adjust its properties according to your GUI design preferences.

"Create a script that generates a timer at the top of the screen"