Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219-thinking-32k· AnthropicHugging Face LMArena Human Preference 140K

can you make for me an AI Cars like system for Roblox like it need to move smooth on…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    can you make for me an AI Cars like system for Roblox like it need to move smooth on road like i have road folder like you know it's basically Nodes like you know and it need to move smooth on that nodes like rotate slowly if you know it fetches the rotate on next part and it need to stop on like parts like if Part is named "StopArea" then it need to stop like make AI Traffic you know advanced please in Roblox studio

  2. Claude Assistant

    Here's a Roblox script for an advanced AI traffic system that follows road nodes with smooth movement and rotation:

    -- AI Traffic System for Roblox
    local TrafficSystem = {}
    local RunService = game:GetService("RunService")
    
    -- Configuration
    local CONFIG = {
        MOVE_SPEED = 20,               -- Units per second
        ROTATION_SPEED = 2,            -- Lower = faster rotation
        STOP_TIME = 3,                 -- How long to stop at StopAreas
        NODE_REACHED_DISTANCE = 4,     -- Distance to count as reaching a node
        DEBUG_MODE = false             -- Visual debugging
    }
    
    -- Function to create a new AI Car
    function TrafficSystem.CreateCar(carModel, roadFolder)
        local car = {
            Model = carModel,
            CurrentNodeIndex = 1,
            NextNodeIndex = 2,
            Nodes = {},
            IsMoving = true,
            StopTimer = 0,
            Connection = nil
        }
        
        -- Collect all nodes from the road folder
        local nodes = {}
        for _, node in pairs(roadFolder:GetChildren()) do
            if node:IsA("BasePart") then
                table.insert(nodes, node)
            end
        end
        
        -- Sort nodes by name if they have numeric names (Node1, Node2, etc.)
        table.sort(nodes, function(a, b)
            local numA = tonumber(string.match(a.Name, "%d+"))
            local numB = tonumber(string.match(b.Name, "%d+"))
            if numA and numB then
                return numA < numB
            end
            return a.Name < b.Name
        end)
        
        car.Nodes = nodes
        
        -- Function to move to the next node
        local function moveToNextNode()
            car.CurrentNodeIndex = car.NextNodeIndex
            car.NextNodeIndex = car.NextNodeIndex + 1
            
            -- Loop back to the first node if we reached the end
            if car.NextNodeIndex > #car.Nodes then
                car.NextNodeIndex = 1
            end
        end
        
        -- Main update function for car movement
        local function updateCar(deltaTime)
            if #car.Nodes < 2 then
                warn("Not enough nodes for car to follow")
                return
            end
            
            local currentNode = car.Nodes[car.CurrentNodeIndex]
            local nextNode = car.Nodes[car.NextNodeIndex]
            local carPrimary = car.Model.PrimaryPart or car.Model:FindFirstChild("Body") or car.Model:FindFirstChildWhichIsA("BasePart")
            
            if not carPrimary then
                warn("Car model needs a PrimaryPart or a part named 'Body'")
                return
            end
            
            -- Check if we're at a stop area
            if currentNode.Name == "StopArea" and car.IsMoving then
                car.IsMoving = false
                car.StopTimer = CONFIG.STOP_TIME
            end
            
            -- Handle stop timer
            if not car.IsMoving then
                car.StopTimer = car.StopTimer - deltaTime
                if car.StopTimer <= 0 then
                    car.IsMoving = true
                    moveToNextNode() -- Move to the next node after stopping
                end
                return
            end
            
            -- Calculate direction to the current target node
            local targetPosition = currentNode.Position
            local carPosition = carPrimary.Position
            local direction = (targetPosition - carPosition).Unit
            
            -- Calculate distance to current node
            local distance = (targetPosition - carPosition).Magnitude
            
            -- Check if we've reached the current node
            if distance < CONFIG.NODE_REACHED_DISTANCE then
                moveToNextNode()
                return
            end
            
            -- Move the car toward the current node
            local moveStep = direction * CONFIG.MOVE_SPEED * deltaTime
            local newPosition = carPosition + moveStep
            
            -- Calculate the rotation to face the direction of movement
            local lookAtPosition = targetPosition
            
            -- If we're close to the current node, start looking at the next node for smoother turns
            if distance < CONFIG.NODE_REACHED_DISTANCE * 2 then
                lookAtPosition = nextNode.Position
            end
            
            -- Create a CFrame that looks from the car position to the target
            local lookVector = (lookAtPosition - carPosition).Unit
            local rightVector = Vector3.new(0, 1, 0):Cross(lookVector).Unit
            local upVector = lookVector:Cross(rightVector)
            local lookCFrame = CFrame.fromMatrix(carPosition, rightVector, upVector, -lookVector)
            
            -- Smoothly interpolate the car's orientation
            local currentCFrame = carPrimary.CFrame
            local newCFrame = currentCFrame:Lerp(
                CFrame.new(newPosition) * currentCFrame.Rotation:Lerp(lookCFrame.Rotation, deltaTime * CONFIG.ROTATION_SPEED),
                deltaTime * CONFIG.MOVE_SPEED
            )
            
            -- Update the car's CFrame
            car.Model:SetPrimaryPartCFrame(newCFrame)
        end
        
        -- Start the update loop
        car.Connection = RunService.Heartbeat:Connect(function(deltaTime)
            updateCar(deltaTime)
        end)
        
        -- Function to clean up the car
        function car:Destroy()
            if self.Connection then
                self.Connection:Disconnect()
                self.Connection = nil
            end
        end
        
        return car
    end
    
    -- Function to create multiple cars on a road
    function TrafficSystem.CreateTraffic(carTemplate, roadFolder, numCars)
        local cars = {}
        for i = 1, numCars do
            local newCar = carTemplate:Clone()
            newCar.Parent = workspace
            
            -- Stagger starting positions
            local startNodeIndex = ((i - 1) * math.floor(#roadFolder:GetChildren() / numCars)) + 1
            if startNodeIndex > #roadFolder:GetChildren() then
                startNodeIndex = 1
            end
            
            local startNode = roadFolder:GetChildren()[startNodeIndex]
            if startNode and startNode:IsA("BasePart") then
                newCar:SetPrimaryPartCFrame(CFrame.new(startNode.Position + Vector3.new(0, 2, 0)))
            end
            
            local carController = TrafficSystem.CreateCar(newCar, roadFolder)
            carController.CurrentNodeIndex = startNodeIndex
            carController.NextNodeIndex = startNodeIndex + 1
            if carController.NextNodeIndex > #roadFolder:GetChildren() then
                carController.NextNodeIndex = 1
            end
            
            table.insert(cars, carController)
        end
        
        return cars
    end
    
    return TrafficSystem
    

    Here's how to set up and use this system:

    1. Create a folder in workspace named "Road"
    2. Add Parts to this folder that will act as path nodes
    3. Name the parts sequentially (e.g., "Node1", "Node2", etc.)
    4. For stop areas, name the part "StopArea"
    5. Create a car model with a PrimaryPart

    Example usage script:

    -- Place this script in ServerScriptService
    local TrafficSystem = require(script.Parent.TrafficSystem) -- Adjust path as needed
    
    -- Get the road folder
    local roadFolder = workspace:WaitForChild("Road")
    
    -- Get or create your car template
    local carTemplate = workspace:FindFirstChild("CarTemplate")
    if not carTemplate then
        -- Create a simple car template
        carTemplate = Instance.new("Model")
        carTemplate.Name = "CarTemplate"
        
        local body = Instance.new("Part")
        body.Name = "Body"
        body.Size = Vector3.new(4, 1.5, 2)
        body.Anchored = true
        body.Color = Color3.fromRGB(255, 0, 0)
        body.Parent = carTemplate
        
        carTemplate.PrimaryPart = body
        carTemplate.Parent = workspace
    end
    
    -- Create traffic with 5 cars
    local cars = TrafficSystem.CreateTraffic(carTemplate, roadFolder, 5)
    

    Would you like me to explain or break down this code?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.