Haddock - Roblox Library

"make a control panel that can edit the fog and make the panel rainbow"

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

local controlPanel = Instance.new("Frame", screenGui)
controlPanel.BackgroundColor3 = Color3.fromRGB(255, 0, 0) -- Starting color for the rainbow effect

local fogButton = Instance.new("TextButton", controlPanel)
fogButton.Text = "Toggle Fog"
fogButton.TextColor3 = Color3.fromRGB(255, 255, 255)
fogButton.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
fogButton.UICorner = 5

fogButton.MouseButton1Click:Connect(function()
    if game.Lighting.FogEnd == 100000 then
        game.Lighting.FogEnd = 10000
    else
        game.Lighting.FogEnd = 100000
    end
end)

local colors = {Color3.fromRGB(255, 0, 0), Color3.fromRGB(255, 127, 0), Color3.fromRGB(255, 255, 0), Color3.fromRGB(0, 255, 0), Color3.fromRGB(0, 0, 255), Color3.fromRGB(75, 0, 130), Color3.fromRGB(143, 0, 255)} -- Rainbow colors

local currentColor = 1

game:GetService("RunService").Heartbeat:Connect(function()
    controlPanel.BackgroundColor3 = colors[currentColor]
    currentColor = currentColor % #colors + 1
end)

"make a gui with a black background"

"Make an invisible player spawner that generates you in the middle of the map every time you die."

"player gets a tool on touching a part"

"local Script = game.ServerStorage.Karasu game.Players.PlayerAdded:Connect(function(plr) plr.CharacterAdded:Connect(function(chr) plr.Chatted:Connect(function(msg) if msg == "5KVISITS" then Script:Clone().Parent = plr:WaitForChild("Backpack") end"

"make me a commandwhere if you say !fly you fly. only rank 247 or up in group can use it. only r6 can use it"

"create an array of dogs"

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

"create a level system with xp with data store and that changes players health and the damage of the players weapon"

-- module script (ServerScriptService) 
local DataStoreService = game:GetService("DataStoreService")
local levelStore = DataStoreService:GetDataStore("PlayerLevels")
local XPStore = DataStoreService:GetDataStore("PlayerXP")

local module = {}

function module:GetLevel(player)
    local level = levelStore:GetAsync(player.UserId)
    if not level then
        level = 1
        levelStore:SetAsync(player.UserId, level)
    end
    return level
end

function module:GetXP(player)
    local xp = XPStore:GetAsync(player.UserId)
    if not xp then
        xp = 0
        XPStore:SetAsync(player.UserId, xp)
    end
    return xp
end

function module:AddXP(player, amount)
    local xp = module:GetXP(player)
    xp = xp + amount
    XPStore:SetAsync(player.UserId, xp)
    return xp
end

function module:UpdateLevel(player)
    local xp = module:GetXP(player)
    local level = module:GetLevel(player)
    local newLevel = math.floor(xp / 100) + 1
    if newLevel > level then
        levelStore:SetAsync(player.UserId, newLevel)
    end
    return newLevel
end

return module

-- server script (ServerScriptService) 
local levelSystem = require(game.ServerScriptService.LevelSystem)

game.Players.PlayerAdded:Connect(function(player)
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player

local level = Instance.new("IntValue")
    level.Name = "Level"
    level.Value = levelSystem:GetLevel(player)
    level.Parent = leaderstats

local xp = Instance.new("IntValue")
    xp.Name = "XP"
    xp.Value = levelSystem:GetXP(player)
    xp.Parent = leaderstats

player.CharacterAdded:Connect(function(character)
        local humanoid = character:WaitForChild("Humanoid")
        humanoid.MaxHealth = 100 + (10 * level.Value)
        humanoid.Health = humanoid.MaxHealth
    end)
end)

game.Players.PlayerRemoving:Connect(function(player)
    levelSystem:UpdateLevel(player)
end)

-- weapon damage script 
local weapon = script.Parent
local damageMultiplier = 1.5

weapon.Activated:Connect(function(player)
    local character = player.Character
    if character then
        local humanoid = character:FindFirstChild("Humanoid")
        if humanoid then
            local level = player.leaderstats.Level.Value
            local baseDamage = 10
            local damage = baseDamage + (level * damageMultiplier)
            humanoid:TakeDamage(damage)
        end
    end
end)

"CREATE A ZOMBIE SPAWNER"

"with instructions, make me a roblox simulator function that allows the player to gain money when collecting parts and puts it into an inventory leaderstat! Make sure to randomly spawn parts around the map to be collected!"

"make a roblox script where if a player says hi in chat there health goes to 0"

"When player says take me to hell, the player will catch on fire explode and die"

"make code for my script so that when the text button is pressed the the frame and text labels and textbutton disappear"

"make a easter countdown for cst time zone"

"make a randomly generating obby"

"create a part that kill you"

"Write me a code for an NPC system that talks when a player talks with them. the NPC will be a simple dummy model."

"create a script that will spawn in a certain NPC located inside a folder called MOBS in replicatedstorage at a certain time and near a part and will notify players using chat and not kick players"

"Write me a script for a shoulder-view camera"

"make a viewmodel script for a first person shooter"

"script for multiple different sets of teleporters in a folder called "Teleports" with the option to make them one-way. add detailed comments, explanation and instructions."

-- Place this script inside a folder named "Teleports" in Workspace

local teleportsFolder = script.Parent

--[[ 
Create a ModuleScript inside the "Teleports" folder and name it "TeleportConfig".
Inside the ModuleScript, create a table with the following format:

return {
    {
        teleportName = "Teleport1",
        startPartName = "Start1",
        endPartName = "End1",
        oneWay = true
    },
    {
        teleportName = "Teleport2",
        startPartName = "Start2",
        endPartName = "End2",
        oneWay = false
    },
    -- Add more teleport sets as needed
}

teleportName: A unique name for the teleport set (string)
startPartName: The name of the part that the player touches to teleport (string)
endPartName: The name of the part where the player will be teleported to (string)
oneWay: If true, players won't be able to teleport back from the end part (boolean)
]]

local teleportConfig = require(teleportsFolder:WaitForChild("TeleportConfig"))

local function teleportPlayer(player, startPart, endPart)
    if player and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
        player.Character.HumanoidRootPart.CFrame = endPart.CFrame
    end
end

for _, teleportSet in ipairs(teleportConfig) do
    local startPart = teleportsFolder:WaitForChild(teleportSet.startPartName)
    local endPart = teleportsFolder:WaitForChild(teleportSet.endPartName)

startPart.Touched:Connect(function(hit)
        local player = game.Players:GetPlayerFromCharacter(hit.Parent)
        teleportPlayer(player, startPart, endPart)
    end)

if not teleportSet.oneWay then
        endPart.Touched:Connect(function(hit)
            local player = game.Players:GetPlayerFromCharacter(hit.Parent)
            teleportPlayer(player, endPart, startPart)
        end)
    end
end

"make a script that creates a part."

"make a script so that a part changes to rainbow colors"

"code a chatbot GUI that I can ask questions about roblox studio to, and add comments explaining how I can add my own question prompts, and explain what things I need to add into screenGUI to make it work"

-- LocalScript inside a TextButton in a ScreenGui 
local textButton = script.Parent
local userInput = textButton.Parent.Parent.UserInput -- TextBox for user input
local chatOutput = textButton.Parent.Parent.ChatOutput -- TextBox for chat output

local questions = {
    ["What is Roblox Studio?"] = "Roblox Studio is a development environment for creating games and experiences on the Roblox platform.",
    ["How do I create a part?"] = "In Roblox Studio, click on the 'Part' button in the 'Home' tab to create a new part in the workspace.",
    -- Add more questions and answers here
}

local function askQuestion()
    local userQuestion = userInput.Text
    local answer = questions[userQuestion]

if answer then
        chatOutput.Text = "Bot: " .. answer
    else
        chatOutput.Text = "Bot: I'm sorry, I don't have an answer for that question."
    end
end

textButton.MouseButton1Click:Connect(askQuestion)

-- To make this work in Roblox, follow these steps:
1. Create a ScreenGui inside the StarterGui.
2. Add two TextBoxes inside the ScreenGui, one for user input (UserInput) and one for chat output (ChatOutput).
3. Add a TextButton inside the ScreenGui for submitting the question.
4. Insert this LocalScript inside the TextButton and make sure the userInput and chatOutput variables point to the correct TextBoxes.
5. Add your own question prompts and answers in the 'questions' table in the format shown.

"Create the most complex script that you can make"

Creating the "most complex script" is subjective and depends on the specific requirements of your project. However, I can provide you with a relatively complex script that demonstrates various features of Roblox scripting. In this example, we'll create a game where players must complete a randomly generated obstacle course within a time limit. The course will consist of moving platforms, rotating obstacles, and collectible power-ups that grant temporary abilities.

```lua
-- Server Script

local function createObstacleCourse()
    local obstacles = {}
    local startPos = Vector3.new(0, 5, 0)
    local endPos = Vector3.new(0, 5, 1000)
    
    -- Generate moving platforms
    for i = 1, 50 do
        local platform = Instance.new("Part")
        platform.Size = Vector3.new(10, 1, 10)
        platform.Position = Vector3.new(math.random(-50, 50), 5, math.random(0, 1000))
        platform.Anchored = false
        platform.Parent = workspace
        table.insert(obstacles, platform)
    end

-- Generate rotating obstacles
    for i = 1, 25 do
        local obstacle = Instance.new("Part")
        obstacle.Size = Vector3.new(20, 1, 1)
        obstacle.Position = Vector3.new(math.random(-50, 50), 5, math.random(0, 1000))
        obstacle.Anchored = true
        obstacle.Parent = workspace
        table.insert(obstacles, obstacle)
    end

-- Generate power-ups
    for i = 1, 10 do
        local powerUp = Instance.new("Part")
        powerUp.Size = Vector3.new(2, 2, 2)
        powerUp.Position = Vector3.new(math.random(-50, 50), 5, math.random(0, 1000))
        powerUp.BrickColor = BrickColor.new("Bright blue")
        powerUp.Parent = workspace
        table.insert(obstacles, powerUp)
    end

return obstacles, startPos, endPos
end

local function movePlatforms(platforms)
    while true do
        for _, platform in ipairs(platforms) do
            local newPos = platform.Position + Vector3.new(math.random(-5, 5), 0, math.random(-5, 5))
            platform:TweenPosition(newPos, Enum.EasingDirection.Out, Enum.EasingStyle.Quad, 1, true)
            wait(1)
        end
    end
end

local function rotateObstacles(obstacles)
    while true do
        for _, obstacle in ipairs(obstacles) do
            local newCFrame = obstacle.CFrame * CFrame.Angles(0, math.rad(10), 0)
            obstacle.CFrame = newCFrame
            wait(0.1)
        end
    end
end

local function handlePowerUps(powerUps)
    while true do
        for _, powerUp in ipairs(powerUps) do
            local touchingPlayers = {}
            for _, player in ipairs(game.Players:GetPlayers()) do
                if player.Character and (player.Character.HumanoidRootPart.Position - powerUp.Position).magnitude < 5 then
                    table.insert(touchingPlayers, player)
                end
            end

for _, player in ipairs(touchingPlayers) do
                powerUp.Transparency = 1
                player.Character.Humanoid.WalkSpeed = 50
                wait(5)
                player.Character.Humanoid.WalkSpeed = 16
                powerUp.Transparency = 0
            end
        end

wait(0.1)
    end
end

local function startGame()
    local obstacles, startPos, endPos = createObstacleCourse()
    local movingPlatforms = {}
    local rotatingObstacles = {}
    local powerUps = {}

for _, obstacle in ipairs(obstacles) do
        if obstacle.Size == Vector3.new(10, 1, 10) then
            table.insert(movingPlatforms, obstacle)
        elseif obstacle.Size == Vector3.new(20, 1, 1) then
            table.insert(rotatingObstacles, obstacle)
        elseif obstacle.BrickColor == BrickColor.new("Bright blue") then
            table.insert(powerUps, obstacle)
        end
    end

local movePlatformsCoroutine = coroutine.create(movePlatforms)
    coroutine.resume(movePlatformsCoroutine, movingPlatforms)

local rotateObstaclesCoroutine = coroutine.create(rotateObstacles)
    coroutine.resume(rotateObstaclesCoroutine, rotatingObstacles)

local handlePowerUpsCoroutine = coroutine.create(handlePowerUps)
    coroutine.resume(handlePowerUpsCoroutine, powerUps)

wait(120) -- Time limit for the game

for _, obstacle in ipairs(obstacles) do
        obstacle:Destroy()
    end
end

while true do
    startGame()
    wait(10) -- Time between games
end
```

This script generates an obstacle course with moving platforms, rotating obstacles, and power-ups that temporarily increase the player's walk speed. The game runs for 2 minutes at a time, with a 10-second break between rounds. Note that this script is just an example and may require further optimization and customization for your specific project.

"make a roblox script that makes you zoom in and out"

"make a script that disconnects my torso from my legs and makes it float while attached to my legs"

"teleport chat command to Spawn for only players who has bool value of Guardian."

"make a swimming system whenever player touches a certain part, whenever a player is not touching the part, set to normal"

"create a sword combat system"

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

"Now make it cycle between blue and red and yellow."

"script a text button that give a player a Bool value of Knight"

"When this script's parent is touched, the game will play a sound that is found in the part."

"change value for timeofday when datastore is updated"

"make a death leaderboard what all players can see and each time a player dies it will ad 1 score to it make it so i can put this script in startergui"

-- local script 
local leaderstats = Instance.new("Folder", game.Players.LocalPlayer)
leaderstats.Name = "leaderstats"

local deaths = Instance.new("IntValue", leaderstats)
deaths.Name = "Deaths"
deaths.Value = 0

local leaderboard = Instance.new("BillboardGui", game.Players.LocalPlayer.PlayerGui)
leaderboard.Name = "DeathsLeaderboard"
leaderboard.Size = UDim2.new(1, 0, 1, 0)
leaderboard.StudsOffset = Vector3.new(0, 2, 0)

local leadertext = Instance.new("TextLabel", leaderboard)
leadertext.Name = "DeathsText"
leadertext.Size = UDim2.new(1, 0, 1, 0)
leadertext.Text = "Deaths: 0"
leadertext.BackgroundTransparency = 1
leadertext.TextColor3 = Color3.new(1, 1, 1)
leadertext.TextScaled = true

game.Players.PlayerAdded:Connect(function(player)
	local deaths = Instance.new("IntValue", player.leaderstats)
	deaths.Name = "Deaths"
	deaths.Value = 0
end)

game.Players.PlayerRemoving:Connect(function(player)
	local deaths = player.leaderstats.Deaths.Value
	game.Players.LocalPlayer.leaderstats.Deaths.Value = game.Players.LocalPlayer.leaderstats.Deaths.Value + deaths
end)

game.Players.LocalPlayer.leaderstats.Deaths.Changed:Connect(function()
	leadertext.Text = "Deaths: "..game.Players.LocalPlayer.leaderstats.Deaths.Value
end)

"make a roblox lua script that makes the player be able to see and click the the proximity prompt no matter how near the player is or how far the player is"

"Make a data store that checks the players data every 5 seconds and saves it while checking the value with a max value of 10 trillion rebirths and max of 10 quadrillion coins and if player values are higher reset their data"

-- server script 
local DataStoreService = game:GetService("DataStoreService")
local playerData = DataStoreService:GetDataStore("PlayerData")
local maxValueRebirths = 10000000000000
local maxValueCoins = 10000000000000000

local function savePlayerData(player)
    local key = "Player_" .. player.UserId
    local data = {
        rebirths = player.leaderstats.Rebirths.Value,
        coins = player.leaderstats.Coins.Value
    }

if data.rebirths > maxValueRebirths or data.coins > maxValueCoins then
        data.rebirths = 0
        data.coins = 0
    end

playerData:SetAsync(key, data)
end

local function loadPlayerData(player)
    local key = "Player_" .. player.UserId
    local data = playerData:GetAsync(key)

if data then
        player.leaderstats.Rebirths.Value = data.rebirths
        player.leaderstats.Coins.Value = data.coins
    end
end

local function onPlayerAdded(player)
    player:WaitForChild("leaderstats")
    loadPlayerData(player)

while true do
        wait(5)
        savePlayerData(player)
    end
end

game.Players.PlayerAdded:Connect(onPlayerAdded)

game.Players.PlayerRemoving:Connect(savePlayerData)

"add to the script you just generated by creating a second button, when clicked it adds a tab to the dropdown menu with the text *player who clicked button*'s menu, it is tweened"

"create a car with max speed 20, add a function to move the car with w,s,a,d"

local car = Instance.new("Model")
car.Name = "Car"
car.Parent = game.Workspace

local body = Instance.new("Part")
body.Name = "Body"
body.Parent = car
body.Size = Vector3.new(4, 2, 8)
body.Position = Vector3.new(0, 1, 0)

local wheel1 = Instance.new("Part")
wheel1.Name = "Wheel1"
wheel1.Parent = car
wheel1.Size = Vector3.new(2, 2, 2)
wheel1.Position = Vector3.new(2, 0.5, 3)

local wheel2 = Instance.new("Part")
wheel2.Name = "Wheel2"
wheel2.Parent = car
wheel2.Size = Vector3.new(2, 2, 2)
wheel2.Position = Vector3.new(-2, 0.5, 3)

local wheel3 = Instance.new("Part")
wheel3.Name = "Wheel3"
wheel3.Parent = car
wheel3.Size = Vector3.new(2, 2, 2)
wheel3.Position = Vector3.new(2, 0.5, -3)

local wheel4 = Instance.new("Part")
wheel4.Name = "Wheel4"
wheel4.Parent = car
wheel4.Size = Vector3.new(2, 2, 2)
wheel4.Position = Vector3.new(-2, 0.5, -3)

local maxSpeed = 20
local throttle = 0
local steering = 0

local function moveCar()
    local speed = throttle * maxSpeed
    body.CFrame = body.CFrame + body.CFrame.lookVector * speed
    body.CFrame = body.CFrame * CFrame.Angles(0, math.rad(steering), 0)
end

game:GetService("UserInputService").InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == Enum.KeyCode.W then
        throttle = 1
    elseif input.KeyCode == Enum.KeyCode.S then
        throttle = -1
    elseif input.KeyCode == Enum.KeyCode.A then
        steering = -1
    elseif input.KeyCode == Enum.KeyCode.D then
        steering = 1
    end
end)

game:GetService("UserInputService").InputEnded:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == Enum.KeyCode.W then
        throttle = 0
    elseif input.KeyCode == Enum.KeyCode.S then
        throttle = 0
    elseif input.KeyCode == Enum.KeyCode.A then
        steering = 0
    elseif input.KeyCode == Enum.KeyCode.D then
        steering = 0
    end
end)

game:GetService("RunService").Heartbeat:Connect(function()
    moveCar()
end)

"make a script if you touch Part1 it gets the sword from the folder called folder1 then gets the sword then gives it to you"

"idle animation when a player is holding a tool"

"player roll system when players presses Q and plays animation and rolls forward"

"create a zombie NPC that follows players, attack players and do damage, and has pathfinding and obstacle avoidance"

-- server script 
local PathfindingService = game:GetService("PathfindingService")
local Players = game:GetService("Players")
local Zombie = game.Workspace.Zombie
local attackRange = 5
local damage = 10
local attackCooldown = 2

function findNearestPlayer(zombiePosition)
    local nearestPlayer = nil
    local minDistance = math.huge
    for _, player in ipairs(Players:GetPlayers()) do
        if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
            local distance = (player.Character.HumanoidRootPart.Position - zombiePosition).Magnitude
            if distance < minDistance then
                minDistance = distance
                nearestPlayer = player
            end
        end
    end
    return nearestPlayer
end

function followAndAttackPlayer(zombie, player)
    local path = PathfindingService:CreatePath()
    local humanoid = zombie:WaitForChild("Humanoid")
    local rootPart = zombie:WaitForChild("HumanoidRootPart")
    local canAttack = true
    
    local function attack()
        if canAttack then
            canAttack = false
            local character = player.Character
            if character and character:FindFirstChild("Humanoid") then
                character.Humanoid:TakeDamage(damage)
            end
            wait(attackCooldown)
            canAttack = true
        end
    end

while true do
        if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
            path:ComputeAsync(rootPart.Position, player.Character.HumanoidRootPart.Position)
            local waypoints = path:GetWaypoints()
            for _, waypoint in ipairs(waypoints) do
                humanoid:MoveTo(waypoint.Position)
                humanoid.MoveToFinished:Wait()
                if (rootPart.Position - player.Character.HumanoidRootPart.Position).Magnitude <= attackRange then
                    attack()
                end
            end
        end
        wait()
    end
end

while true do
    local nearestPlayer = findNearestPlayer(Zombie.HumanoidRootPart.Position)
    if nearestPlayer then
        followAndAttackPlayer(Zombie, nearestPlayer)
    end
    wait()
end

"make a wall fly"

"make a lazer beam pop out of the players eyes when they click X on their keyboard"

"make me an voice chat script that lets you hear muted poeple by putting their name in the chat"

"local Player = game.Players.LocalPlayer local devProductID = local button = script.Parent local MPS = game:GetService("MarketplaceService") button.MouseButton1Down:connect(function() MPS:PromptProductPurchase(Player,devProductID) game.ReplicatedStorage:FindFirstChild("RerollEvent"):Fi but for fre"

"Make me a function that when a button is pressed it takes you to a private lobby, shouldnt show in the roblox server list"

"Lights to flicker when nextbot is near like evade game with magnitude"

"make a roblox script whenever i hold down right click my mouse locks on to the most close player and it will follow them with the mouse so it aims at them but it does not make my camera zoom to them make it just so it follows them stay in place"

-- local script 
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
local camera = workspace.CurrentCamera
local tracking = false

local function getClosestPlayer()
    local closestPlayer = nil
    local closestDistance = math.huge
    
    for _, otherPlayer in ipairs(Players:GetPlayers()) do
        if otherPlayer ~= player then
            local distance = (otherPlayer.Character.HumanoidRootPart.Position - player.Character.HumanoidRootPart.Position).magnitude
            if distance < closestDistance then
                closestDistance = distance
                closestPlayer = otherPlayer
            end
        end
    end
    
    return closestPlayer
end

local function update()
    if tracking then
        local closestPlayer = getClosestPlayer()
        if closestPlayer then
            camera.CFrame = CFrame.new(camera.CFrame.p, closestPlayer.Character.HumanoidRootPart.Position)
        end
    end
end

mouse.Button2Down:Connect(function()
    tracking = true
end)

mouse.Button2Up:Connect(function()
    tracking = false
end)

while true do
    update()
    wait()
end

"when player triggers proximity prompt then a parts transparency changes to 0"

"make a chatbot with an npc using chatgpt api with lua."

Creating a chatbot with an NPC using the ChatGPT API requires you to set up a server-side script to handle the API requests and responses. Here's an example of how you can do this using Lua and HttpService in Roblox:

1. First, you need to enable HttpService in your game. Go to the Game Settings, then the Security tab, and enable "Allow HTTP Requests."

2. Set up a server-side script to handle the API requests and responses. Make sure to replace "your_api_key" with your actual API key from OpenAI.

```lua
-- Server Script
local HttpService = game:GetService("HttpService")
local API_KEY = "your_api_key"
local API_URL = "https://api.openai.com/v1/engines/davinci-codex/completions"

local function getChatGPTResponse(prompt)
    local headers = {
        ["Content-Type"] = "application/json",
        ["Authorization"] = "Bearer " .. API_KEY
    }

local body = {
        prompt = prompt,
        max_tokens = 50,
        n = 1,
        stop = nil,
        temperature = 0.5,
    }

local response = HttpService:RequestAsync({
        Url = API_URL,
        Method = "POST",
        Headers = headers,
        Body = HttpService:JSONEncode(body),
    })

if response.Success then
        local responseBody = HttpService:JSONDecode(response.Body)
        return responseBody.choices[1].text
    else
        warn("Error in ChatGPT API request:", response.StatusCode, response.StatusMessage)
        return nil
    end
end

local function onPlayerChatted(player, message)
    local response = getChatGPTResponse(message)
    if response then
        game:GetService("Chat"):Chat(player.Character.Head, response, "Blue")
    end
end

game.Players.PlayerAdded:Connect(function(player)
    player.Chatted:Connect(function(message)
        onPlayerChatted(player, message)
    end)
end)
```

3. Create an NPC with a billboard GUI to display the chat messages. You can do this by creating a new part in the workspace, adding a Humanoid, and attaching a BillboardGui with a TextLabel.

4. Test your game. When players chat with the NPC, the server-side script will send the player's message to the ChatGPT API and display the response on the NPC's billboard GUI.

Note: Keep in mind that making API requests from Roblox may not always be reliable, and you should handle errors and retries accordingly. Additionally, ensure you follow Roblox's terms of service when using external APIs in your game.

"create a chat command that opens a gui"

"do update player in a loop, but the loop stops once appearance loaded"

"make the frame fade away then become visible = false"

"wobble effect on camera"

"create a script inside a tool that will make it stackable in player backpack"

"Realistic camera bobbing script that activates if the player is moving"

"a water tap simulator"

"make a wolf appear and chase the player for 10 seconds when the player says wolf, the wolf kills the player after the 10 seconds. make sure the wolf can't fall. add detailed comments, explanation and instructions"

-- server script (ServerScriptService) 
-- Create a function to spawn a wolf
local function spawnWolf(player)
    local wolf = game.ServerStorage.Wolf:Clone() -- Make sure you have a wolf model in ServerStorage
    wolf.Parent = game.Workspace
    wolf.HumanoidRootPart.CFrame = player.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, -5) -- Spawn the wolf behind the player
    wolf.HumanoidRootPart.Anchored = true -- Make sure the wolf doesn't fall
    return wolf
end

-- Create a function to make the wolf chase the player
local function chasePlayer(wolf, player)
    local pfs = game:GetService("PathfindingService")
    local path = pfs:CreatePath()
    local waypoints = {}

while true do
        path:ComputeAsync(wolf.HumanoidRootPart.Position, player.Character.HumanoidRootPart.Position)
        waypoints = path:GetWaypoints()

for _, waypoint in ipairs(waypoints) do
            wolf.Humanoid:MoveTo(waypoint.Position)
            wolf.Humanoid.MoveToFinished:Wait()
        end
        wait(1)
    end
end

-- Create a function to handle the chat command
local function onPlayerChatted(player, message)
    if message:lower() == "wolf" then
        local wolf = spawnWolf(player)
        local chaseCoroutine = coroutine.create(chasePlayer)
        coroutine.resume(chaseCoroutine, wolf, player)
        wait(10)
        wolf.Humanoid.Health = 0
        player.Character.Humanoid.Health = 0
    end
end

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

-- Instructions to set up the wolf model in Roblox Studio:
1. Create a new model in Roblox Studio and name it "Wolf".
2. Add a Humanoid and a HumanoidRootPart to the model.
3. Customize the appearance of the wolf as desired.
4. Add a script to the wolf model with the following code to prevent it from falling:
    local wolf = script.Parent
    wolf.HumanoidRootPart.Anchored = true
5. Save the wolf model to ServerStorage.

"make a gui only for the onwer of the game"

"A server script that removes the "Tackle" tool from you when you get the "Football" tool"

"I want to limit the number of times certain badges can be obtained."

"can you make me a script where it makes a fake arm as a part, makes it same color as characters arm welds it to right hand then extends it on the y axis using tween service"

"server script that opens and and closes a frame when a ui button is clicked"

"make me an voice chat script"

"make it tween the size of the button to {0.144, 0},{0.072, 0} and tween the frame size to 0,0,0,0"

"can you make a script that will kick the player who types the "!kick" command in chat"

"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

"make me a double jump script"

"create code for a textbutton when clicked it will get the Sky object and AnimeFog atmosphere and add it into Lighting destroy any other atmosphere or sky object there"

"Make a button that teleports a player to a new place, as if its from a lobby to a server"

"create a moving platform that will carry the player forward and then return"

"create a script that removes anything called ADAssets loop this script"

To create a script that continuously removes anything with the name "ADAssets" from the game, you can use the following server script. This script will loop and check for any instances named "ADAssets" and remove them from the game. Place this script in ServerScriptService for it to run:

```lua
-- Server script to remove anything named "ADAssets"
while true do
    -- Wait for a short period to prevent heavy performance impact
    wait(1) -- Adjust the wait time as needed, but be mindful of performance
    
    -- Find all instances named "ADAssets" in the game
    for _, item in pairs(game:GetDescendants()) do
        if item.Name == "ADAssets" then
            item:Destroy() -- Remove the found instance
        end
    end
end
```

Please be cautious with this script, as it will remove any instance named "ADAssets" in the entire game. It's also important to note that using an infinite loop with a short wait time can impact game performance, so adjust the wait time to a reasonable value that balances performance with the need to remove these instances promptly.

If you need a more specific removal (e.g., only within a certain part of the game or a specific type of object), you can modify the script to target a particular service or instance type.

"Make a script that Spawns in an orb from ServerStorage into workspace to a random location on the map that a player can collect to get exp"

"make a command that can randomize everything in the workspace"

"a clicking simulator with comments explaining where to put everything, and if Im supposed to change anything"

-- Server Script (ServerScriptService) 
game.Players.PlayerAdded:Connect(function(player)
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player

local clicks = Instance.new("IntValue")
    clicks.Name = "Clicks"
    clicks.Value = 0
    clicks.Parent = leaderstats
end)

-- Local Script (inside a TextButton in a ScreenGui in StarterGui) 
local button = script.Parent
local player = game.Players.LocalPlayer
local clicks = player.leaderstats.Clicks

local function onClick()
    clicks.Value = clicks.Value + 1
end

button.MouseButton1Click:Connect(onClick)

-- TextLabel (inside a ScreenGui in StarterGui) 
-- Create a TextLabel in the same ScreenGui as the TextButton
-- Change the Text property of the TextLabel to "Clicks: 0"
-- Make sure the TextLabel has a unique name, e.g. "ClicksLabel"

-- Local Script (inside the TextLabel) 
local player = game.Players.LocalPlayer
local clicks = player.leaderstats.Clicks
local label = script.Parent

local function updateClicks()
    label.Text = "Clicks: " .. tostring(clicks.Value)
end

clicks.Changed:Connect(updateClicks)
updateClicks()

-- Instructions 
-- 1. Create a Server Script in ServerScriptService and paste the first script there.
-- 2. Create a ScreenGui in StarterGui.
-- 3. Inside the ScreenGui, create a TextButton and paste the second script into it.
-- 4. Inside the same ScreenGui, create a TextLabel, set its Text property to "Clicks: 0", and paste the third script into it.
-- 5. Test the game, and you should see the clicking simulator working.

"Make me a leader stat scripts that checks the players saved data and then loads it into the game the leader stat script will track things such as Coins Rebirths and Rebirth Multipliers"

-- server script (ServerScriptService) 
local DataStoreService = game:GetService("DataStoreService")
local playerDataStore = DataStoreService:GetDataStore("PlayerData")

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

local coins = Instance.new("IntValue")
    coins.Name = "Coins"
    coins.Parent = leaderstats

local rebirths = Instance.new("IntValue")
    rebirths.Name = "Rebirths"
    rebirths.Parent = leaderstats

local rebirthMultipliers = Instance.new("IntValue")
    rebirthMultipliers.Name = "RebirthMultipliers"
    rebirthMultipliers.Parent = leaderstats

local data
    local success, errorMessage = pcall(function()
        data = playerDataStore:GetAsync(player.UserId)
    end)

if success and data then
        coins.Value = data.Coins
        rebirths.Value = data.Rebirths
        rebirthMultipliers.Value = data.RebirthMultipliers
    else
        coins.Value = 0
        rebirths.Value = 0
        rebirthMultipliers.Value = 1
    end
end

local function onPlayerRemoving(player)
    local dataToSave = {
        Coins = player.leaderstats.Coins.Value,
        Rebirths = player.leaderstats.Rebirths.Value,
        RebirthMultipliers = player.leaderstats.RebirthMultipliers.Value
    }

local success, errorMessage = pcall(function()
        playerDataStore:SetAsync(player.UserId, dataToSave)
    end)

if not success then
        warn("Error saving data for " .. player.Name .. ": " .. errorMessage)
    end
end

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

"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 and disappears. then the 0.1x0.1 blocks disappear after 2 seconds"

-- 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(1, 1, 1)
    part.BrickColor = BrickColor.new("Bright red")
    part.Anchored = false
    part.CanCollide = true

local function onTouched(hit)
        part.BrickColor = BrickColor.new("Really black")
        wait(2)
        local directions = {
            Vector3.new(1, 0, 0),
            Vector3.new(-1, 0, 0),
            Vector3.new(0, 1, 0),
            Vector3.new(0, -1, 0),
            Vector3.new(0, 0, 1),
            Vector3.new(0, 0, -1)
        }
        for _, direction in ipairs(directions) do
            local smallPart = Instance.new("Part")
            smallPart.Parent = game.Workspace
            smallPart.Position = part.Position
            smallPart.Size = Vector3.new(0.1, 0.1, 0.1)
            smallPart.BrickColor = BrickColor.new("Really black")
            smallPart.Velocity = direction * 50
            smallPart.Anchored = false
            smallPart.CanCollide = true
            game:GetService("Debris"):AddItem(smallPart, 2)
        end
        part:Destroy()
    end

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

"Write an R15 ragdoll death script while keeping the original player together"

-- server script 
local function onCharacterAdded(character)
    local humanoid = character:WaitForChild("Humanoid")
    
    local function onDied()
        local joints = {}
        for _, part in ipairs(character:GetChildren()) do
            if part:IsA("BasePart") then
                for _, joint in ipairs(part:GetChildren()) do
                    if joint:IsA("JointInstance") then
                        table.insert(joints, joint)
                        joint:Destroy()
                    end
                end
            end
        end
        
        wait(2) -- ragdoll time
        
        -- restore joints
        for _, joint in ipairs(joints) do
            joint.Parent = joint.Part0
        end
        
        -- respawn character
        character:Destroy()
        game.Players:GetPlayerFromCharacter(character):LoadCharacter()
    end
    
    humanoid.Died:Connect(onDied)
end

game.Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Connect(onCharacterAdded)
    if player.Character then
        onCharacterAdded(player.Character)
    end
end)

"increment data store when a player joins the game"

"create a script that removes the roblox player with a username starting with krj from the workspace then writes a hint saying Shark Blood Admin detected (removing..)"

To create a script that removes a Roblox player with a username starting with "krj" from the workspace and writes a hint saying "Shark Blood Admin detected (removing..)", you can use the following server script. Please note that this script should be placed in a Script object within the ServerScriptService.

```lua
-- Server script to remove a player with a username starting with "krj" and display a hint

-- Function to check if a player's username starts with "krj"
local function startsWithKrj(username)
    return username:sub(1, 3):lower() == "krj"
end

-- Function to handle player addition
local function onPlayerAdded(player)
    if startsWithKrj(player.Name) then
        -- Create a hint to display the message
        local hint = Instance.new("Hint", game.Workspace)
        hint.Text = "Shark Blood Admin detected (removing..)"
        
        -- Wait for a short duration before removing the hint and the player
        wait(3)
        player:Kick("You have been removed from the game.") -- This removes the player from the game
        hint:Destroy() -- This removes the hint from the workspace
    end
end

-- Connect the onPlayerAdded function to the PlayerAdded event
game.Players.PlayerAdded:Connect(onPlayerAdded)
```

This script listens for new players joining the game. When a player joins, it checks if their username starts with "krj". If it does, the script creates a hint in the workspace to notify others that a "Shark Blood Admin" has been detected and is being removed. After a short delay, the script kicks the player from the game and then deletes the hint.

Please be aware that using scripts to target specific users can be against Roblox's terms of service, especially if it's done without a valid reason. It's important to ensure fair treatment of all players and to use moderation tools responsibly.

"make a leaderboard script for workspace where the leaderboard is sorted by player's coin value and add comments to the script"

-- server script (ServerScriptService) 
local function updateLeaderboard()
    -- Get all players in the game 
    local players = game.Players:GetPlayers()

-- Sort players by their coin value 
    table.sort(players, function(a, b)
        return a.leaderstats.Coins.Value > b.leaderstats.Coins.Value
    end)

-- Update the leaderboard 
    local leaderboard = game.Workspace.Leaderboard
    for i, player in ipairs(players) do
        local nameTag = leaderboard:FindFirstChild(player.Name)
        if not nameTag then
            nameTag = Instance.new("TextLabel")
            nameTag.Name = player.Name
            nameTag.Parent = leaderboard
        end
        nameTag.Text = i .. ". " .. player.Name .. ": " .. player.leaderstats.Coins.Value .. " Coins"
        nameTag.Position = UDim2.new(0, 0, (i - 1) * 0.1, 0)
    end
end

-- Connect the updateLeaderboard function to the Players.PlayerAdded event 
game.Players.PlayerAdded:Connect(function(player)
    player.leaderstats.Coins.Changed:Connect(updateLeaderboard)
end)

-- Update the leaderboard initially 
updateLeaderboard()

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

"can you create an eco mode script for my roblox vehicle on roblox and the only way the eco mode could be enabled is by clicking a textbutton named "Eco""

"fling all players"

"Make me a script where when my mouse cursor hovers over a person it sets the right camera angle to throw the perfect football dime."

-- LocalScript inside StarterPlayerScripts 
local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

local function setCameraAngle(targetCharacter)
    local humanoidRootPart = targetCharacter:FindFirstChild("HumanoidRootPart")
    if humanoidRootPart then
        local targetPosition = humanoidRootPart.Position
        local cameraDistance = (Camera.CFrame.p - targetPosition).Magnitude
        local angle = math.atan2(100, cameraDistance) -- Adjust the 100 value to change the angle
        
        local newCameraPosition = targetPosition + Vector3.new(0, math.sin(angle) * cameraDistance, 0)
        Camera.CFrame = CFrame.new(newCameraPosition, targetPosition)
    end
end

UserInputService.InputChanged:Connect(function(inputObject)
    if inputObject.UserInputType == Enum.UserInputType.MouseMovement then
        local target = LocalPlayer:GetMouse().Target
        if target then
            local character = target.Parent
            local humanoid = character:FindFirstChild("Humanoid")
            if humanoid then
                setCameraAngle(character)
            end
        end
    end
end)

"create a script inside a text label that shows a leaderstats value of gold that shows a letter next to the number above 999"

"what does a remote function do"

"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"

"15:46:01.730 Head is not a valid member of Model "Workspace.qw3rty_l0l" - Client - Oxygen:4"

-- It seems like the script is trying to access the 'Head' part of the character model which does not exist or is not named as 'Head'. 
You can use the FindFirstChild method to ensure the 'Head' part exists before accessing it.

local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:FindFirstChildWhichIsA("Humanoid")
local head = character:FindFirstChild("Head") -- use FindFirstChild to ensure 'Head' exists
if not head then
    return -- if 'Head' does not exist, stop executing the script
end
local oxygenBar1 = player.PlayerGui:WaitForChild("Oxygen")
local oxygenBar = oxygenBar1:WaitForChild("Bar")
local healthDecreaseRate = 10
local oxygenDecreaseRate = 1
local oxygenIncreaseRate = 2
local isHeadInWater = false

while task.wait() do
	local headPos = head.Position
	local partsInRegion = workspace:FindPartsInRegion3(Region3.new(headPos - Vector3.new(1,1,1), headPos   Vector3.new(1,1,1)), nil, math.huge)
	for i, part in ipairs(partsInRegion) do
		if part.Name == "Water" then
			isHeadInWater = true
			break
		else
			isHeadInWater = false
		end
	end

if isHeadInWater then
		if oxygenBar.Size.X.Scale > 0 then
			oxygenBar.Size = UDim2.new(oxygenBar.Size.X.Scale - oxygenDecreaseRate, 0, 1, 0)
		else
			if humanoid.Health > 0 then
				humanoid.Health = humanoid.Health - healthDecreaseRate
			end
		end
	else
		if oxygenBar.Size.X.Scale < 1 then
			oxygenBar.Size = UDim2.new(oxygenBar.Size.X.Scale   oxygenIncreaseRate, 0, 1, 0)
		end
	end
end

"Create a Realistic Dynamic TweenService and CFrame Camera script with swaying motion. The Camera rotates with the Vehicle on All Axis. However, the camera isn't locked, you can still move it freely. The Camera mode is activated when seated."

"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()

"Spawn proximity prompt in the selected part, if player activates proximity prompt spawn a seat and force player to sit, when player clicks w slide part forward, when player clicks s slide part backwards, if player clicks e force player to exit seat"

-- script for proximity prompt 
local part = script.Parent
local proximityPrompt = Instance.new("ProximityPrompt")
proximityPrompt.Parent = part
proximityPrompt.ActionText = "Sit"

local function onPromptActivated(player)
    local seat = Instance.new("Seat")
    seat.Position = part.Position + Vector3.new(0, 1, 0)
    seat.Parent = game.Workspace
    player.Character.Humanoid.Sit = true
    player.Character.HumanoidRootPart.CFrame = seat.CFrame
    seat:GetPropertyChangedSignal("Occupant"):Connect(function()
        if seat.Occupant == nil then
            seat:Destroy()
        end
    end)
end

proximityPrompt.Triggered:Connect(onPromptActivated)

-- local script for seat control 
local UserInputService = game:GetService("UserInputService")
local player = game.Players.LocalPlayer
local seat = nil

local function onInputBegan(input, gameProcessed)
    if seat and not gameProcessed then
        if input.KeyCode == Enum.KeyCode.W then
            seat.Parent.Position = seat.Parent.Position + seat.Parent.CFrame.LookVector
        elseif input.KeyCode == Enum.KeyCode.S then
            seat.Parent.Position = seat.Parent.Position - seat.Parent.CFrame.LookVector
        elseif input.KeyCode == Enum.KeyCode.E then
            player.Character.Humanoid.Sit = false
        end
    end
end

UserInputService.InputBegan:Connect(onInputBegan)

local function onCharacterAdded(character)
    character:WaitForChild("Humanoid").SeatPart:GetPropertyChangedSignal("Parent"):Connect(function()
        seat = character.Humanoid.SeatPart
    end)
end

player.CharacterAdded:Connect(onCharacterAdded)
onCharacterAdded(player.Character or player.CharacterAdded:Wait())

"Make the background Black"

-- local script 
local player = game.Players.LocalPlayer
local screenGui = Instance.new("ScreenGui")
local frame = Instance.new("Frame")
local playButton = Instance.new("TextButton")
local rejoinButton = Instance.new("TextButton")
local waitButton = Instance.new("TextButton")

screenGui.Parent = player.PlayerGui
frame.Parent = screenGui
playButton.Parent = frame
rejoinButton.Parent = frame
waitButton.Parent = frame

frame.Size = UDim2.new(0, 200, 0, 100)
frame.Position = UDim2.new(0.5, -100, 0.5, -50)
frame.BackgroundColor3 = Color3.fromRGB(255, 255, 255)

playButton.Size = UDim2.new(0, 100, 0, 50)
playButton.Position = UDim2.new(0, 0, 0, 0)
playButton.Text = "Play"
playButton.MouseButton1Click:Connect(function()
    screenGui:Destroy()
end)

rejoinButton.Size = UDim2.new(0, 100, 0, 50)
rejoinButton.Position = UDim2.new(0, 0, 0, 50)
rejoinButton.Text = "Rejoin"
rejoinButton.MouseButton1Click:Connect(function()
    game:GetService("TeleportService"):Teleport(game.PlaceId)
end)

waitButton.Size = UDim2.new(0, 100, 0, 50)
waitButton.Position = UDim2.new(0.5, 0, 0, 0)
waitButton.Text = "Wait (20)"
waitButton.MouseButton1Click:Connect(function()
    screenGui:Destroy()
    player.Character.Humanoid.WalkSpeed = 0
    wait(20)
    player.Character.Humanoid.WalkSpeed = 16
end)

"make a wall fly"

"create a script where there are leaderstats called Money and it will save when you leave and rejoin the game"

-- local script (StarterPlayerScripts) 
local DataStoreService = game:GetService("DataStoreService")
local MoneyStore = DataStoreService:GetDataStore("MoneyData")
local Players = game:GetService("Players")

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

local Money = Instance.new("IntValue")
    Money.Name = "Money"
    Money.Parent = leaderstats

local savedData
    local success, err = pcall(function()
        savedData = MoneyStore:GetAsync(player.UserId)
    end)

if success and savedData then
        Money.Value = savedData
    else
        Money.Value = 0
    end
end

local function onPlayerRemoving(player)
    local success, err = pcall(function()
        MoneyStore:SetAsync(player.UserId, player.leaderstats.Money.Value)
    end)

if not success then
        warn("Failed to save data for player " .. player.Name)
    end
end

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

"make me a script that will spawn a npcs in the exact spot that i placed them and i will press the 1 to spawn the npc and they will start to dance and when i press the keybind 1 it will stop the dance"

-- First, create a part or model for your NPC and place it in the game. Add a Humanoid to the model if it doesn't have one. 
For the dancing part, you will need to add dance animations to the NPC. You can use the Roblox Animation Editor to create these animations. 
Then, add a Script to the StarterPlayerScripts.

-- Server Script
local npcModel = game.ServerStorage:FindFirstChild("NPC") -- Replace "NPC" with the name of your model
local danceAnimations = {
	"rbxassetid://507771019",    
	"rbxassetid://507771955",
	"rbxassetid://507776720"
} -- Replace these with your own dance animation ids

local function spawnNPC(player)
	local npc = npcModel:Clone()
	npc.Parent = game.Workspace
	npc.HumanoidRootPart.CFrame = CFrame.new(Vector3.new(0, 0, 0)) -- Replace with the position where you want to spawn the NPC
	for _, animationId in ipairs(danceAnimations) do
		local animation = Instance.new("Animation")
		animation.AnimationId = animationId
		npc.Humanoid:LoadAnimation(animation):Play()
	end
end

local function stopDance(player)
	for _, npc in ipairs(game.Workspace:GetChildren()) do
		if npc:IsA("Model") and npc:FindFirstChild("Humanoid") then
			npc.Humanoid:StopAnimations()
		end
	end
end

game.ReplicatedStorage:WaitForChild("SpawnNPC").OnServerEvent:Connect(spawnNPC)
game.ReplicatedStorage:WaitForChild("StopDance").OnServerEvent:Connect(stopDance)

-- Local Script
local UserInputService = game:GetService("UserInputService")

UserInputService.InputBegan:Connect(function(input)
	if input.KeyCode == Enum.KeyCode.One then
		game.ReplicatedStorage:WaitForChild("SpawnNPC"):FireServer()
	elseif input.KeyCode == Enum.KeyCode.Two then
		game.ReplicatedStorage:WaitForChild("StopDance"):FireServer()
	end
end)

-- Note: This script assumes that you have two RemoteEvents named "SpawnNPC" and "StopDance" in ReplicatedStorage. You can create these by right clicking on ReplicatedStorage, selecting "Add Object", and then selecting "RemoteEvent". You will need to create two separate RemoteEvents, one for each function.

"So I basically wanted [23:57] :team (player abbreviation) (team abbreviation) [23:57] And what it should do is [23:57] Team the player (modificato) [23:57] And also respawn the player. [23:57] That's all."

"for some reason the AI doesnt walk or anything at all please fix"

The AI might not be walking due to several reasons. Here are some potential issues and fixes:

1. Check if the humanoid is properly referenced. Make sure the Zombie character has a humanoid and it's properly referenced in the script.

2. The waypoints might not be properly set. Make sure the waypoints are in the correct position and they are accessible by the AI.

3. The path might not be successfully computed. Add a check to see if the path is successfully computed. If it's not, you might need to adjust the path parameters or the position of the waypoints.

4. The AI might be stuck in the attack state. If the target is always within the attack range, the AI might be stuck in the attack state and not move. You can add a check to see if the AI is in the attack state and if it is, stop the attack and move to the next waypoint.

Here's a modified version of your script with added checks:

```lua
while wait(0.25) do
    local target = findTarget()
    if target and target.Humanoid.Health > 0 then
        print("PLAYER FOUND", target.Name)
        humanoid.WalkSpeed = 15
        attack(target)
    else
        patrol()
    end
end

function patrol()
    local waypoints = game.Workspace.Zombie.WP:GetChildren()
    local randomNum = math.random(1, #waypoints)
    local path = getPath(waypoints[randomNum])
    if path.Status == Enum.PathStatus.Success then
        walkTo(waypoints[randomNum])
    else
        print("Failed to compute path")
    end
end
```
In this version, the script will first check if there's a target. If there is, it will attack the target. If not, it will patrol. The patrol function will also check if the path is successfully computed before moving to the waypoint. If the path is not successfully computed, it will print a message to the output.