How to make your character grow when you eat something in Roblox Studio

Parts scattered around the map. Walk into one, it disappears, your character gets measurably bigger, and a counter on the leaderboard goes up. It is the core loop behind a whole genre on Roblox, and it is about sixty lines.

Everything below goes in a Script in ServerScriptService, not a LocalScript. That is not a style preference. If the client decides how big it is, then a player with an exploit executor decides how big they are, and on a game where size is the score that is the entire game. The server owns the number; the client just sees the result.

It expects a Folder called Food in Workspace with some parts in it. If you do not have one, the second script further down makes one for you.

-- ServerScriptService > EatToGrow  (a Script, NOT a LocalScript)

local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local GROWTH_PER_FOOD = 0.06   -- 6% taller and wider per item eaten
local MAX_SCALE = 4            -- stop growing here. See the note on clipping.
local RESPAWN_AFTER = 8        -- seconds before an eaten item comes back
local SPEED_PER_SCALE = 4      -- extra WalkSpeed per 1.0 of scale

local foodFolder = workspace:WaitForChild("Food")

-- The four scale values live on the Humanoid as NumberValue INSTANCES, not as
-- plain properties, so they are read and written through .Value. They exist on
-- R15 rigs only — see the R6 note below, which is the whole reason this
-- function returns nil instead of assuming.
local function getScales(humanoid)
	local height = humanoid:FindFirstChild("BodyHeightScale")
	local width = humanoid:FindFirstChild("BodyWidthScale")
	local depth = humanoid:FindFirstChild("BodyDepthScale")
	local head = humanoid:FindFirstChild("HeadScale")
	if not (height and width and depth and head) then
		return nil
	end
	return { height = height, width = width, depth = depth, head = head }
end

local function grow(player, character)
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return end

	local scales = getScales(humanoid)
	if not scales then
		-- R6. Nothing to scale. Warn once rather than failing silently, because
		-- "the script runs, no errors, nobody grows" is the hardest version of
		-- this bug to find.
		warn("[EatToGrow] " .. player.Name .. " is on an R6 rig — cannot scale. See the R6 note.")
		return
	end

	local next = math.min(scales.height.Value + GROWTH_PER_FOOD, MAX_SCALE)
	scales.height.Value = next
	scales.width.Value = next
	scales.depth.Value = next
	scales.head.Value = next

	-- A character four times the size moving at the default 16 studs/second
	-- reads as slow motion, because the eye judges speed against body length,
	-- not against studs. Scaling WalkSpeed with size is what makes growth feel
	-- like power instead of like a penalty.
	humanoid.WalkSpeed = 16 + (next - 1) * SPEED_PER_SCALE

	local stats = player:FindFirstChild("leaderstats")
	local eaten = stats and stats:FindFirstChild("Eaten")
	if eaten then
		eaten.Value += 1
	end
end

local function eat(player, food)
	-- THE DEBOUNCE, and it has to be an attribute on the part rather than a
	-- local variable. Touched fires many times for one contact, and the next
	-- one can arrive before Destroy() has finished, so without this a single
	-- item is eaten three or four times.
	if food:GetAttribute("Eaten") then return end
	food:SetAttribute("Eaten", true)

	local position = food.CFrame
	local template = food:Clone()
	food:Destroy()

	grow(player, player.Character)

	task.delay(RESPAWN_AFTER, function()
		template:SetAttribute("Eaten", nil)
		template.CFrame = position
		template.Parent = foodFolder
	end)
end

local function armFood(food)
	if not food:IsA("BasePart") then return end
	food.CanTouch = true
	food.Touched:Connect(function(hit)
		local character = hit:FindFirstAncestorOfClass("Model")
		if not character then return end
		local player = Players:GetPlayerFromCharacter(character)
		if not player then return end
		eat(player, food)
	end)
end

for _, food in ipairs(foodFolder:GetChildren()) do
	armFood(food)
end
foodFolder.ChildAdded:Connect(armFood)

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

	local eaten = Instance.new("IntValue")
	eaten.Name = "Eaten"
	eaten.Parent = stats

	-- Respawning gives you a brand new character at scale 1. Decide on purpose
	-- which game you are making: reset the counter here to make death cost
	-- everything, or re-apply the old scale to make it a save file. This does
	-- the first, because it is the one that makes the loop a game.
	player.CharacterAdded:Connect(function()
		eaten.Value = 0
	end)
end)

Run this once and you have forty glowing spheres to walk into. It creates the Food folder the main script is looking for.

-- ServerScriptService > ScatterFood  (a Script)
-- Optional. Only needed if you do not want to place the parts by hand.

local COUNT = 40
local AREA = 120  -- studs, centred on the origin

local folder = Instance.new("Folder")
folder.Name = "Food"
folder.Parent = workspace

for i = 1, COUNT do
	local food = Instance.new("Part")
	food.Name = "Food"
	food.Shape = Enum.PartType.Ball
	food.Size = Vector3.new(2, 2, 2)
	food.Color = Color3.fromRGB(255, 176, 46)
	food.Material = Enum.Material.Neon
	food.Anchored = true
	food.CanCollide = false
	food.Position = Vector3.new(
		math.random(-AREA, AREA),
		3,
		math.random(-AREA, AREA)
	)
	food.Parent = folder
end

Make them spin and it reads as collectible rather than as scenery — though this one costs you something, which is why it is separate:

-- Put this INSIDE the loop in ScatterFood, just before food.Parent = folder.

local spin = Instance.new("BodyAngularVelocity")
spin.AngularVelocity = Vector3.new(0, 3, 0)
spin.MaxTorque = Vector3.new(0, math.huge, 0)
spin.P = math.huge
spin.Parent = food

-- Anchored parts ignore BodyMovers, so if you want the spin you have to give
-- up Anchored = true and rely on CanCollide = false plus a high position to
-- keep them off the floor. It is a real trade, not a free effect.

The loop above is complete but it is not yet a game, because nothing is at stake. The usual next step is making other players edible: check both characters' scales on contact, and let the larger one absorb the smaller. That is the same Touched handler with a comparison in it, plus a decision about what happens to the loser.

The honest warning about that step, since this page has been honest so far: player-versus-player size logic is where this genre gets genuinely hard. Two characters touch each other simultaneously, both handlers fire, and if you have not decided which one resolves first you get two winners, or two losers, or a size that doubles. Pick one authority — usually the lower UserId, or a single server-side queue — before you write it.

If what you actually wanted was "the character grows over time" rather than on contact, none of the Touched handling above applies and the whole thing is a while loop with a task.wait in it, incrementing the same four scale values. The R6 problem and the clipping ceiling still apply, and they are still the two things that will actually stop you.