How to make a tycoon in Roblox Studio: dropper, conveyor, collector and buttons

local Players = game:GetService("Players")

local STARTING_CASH = 0

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- must be exactly this name, all lowercase

	local cash = Instance.new("IntValue")
	cash.Name = "Cash"
	cash.Value = STARTING_CASH
	cash.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- In Studio you can join before this script runs, so set up anyone already here
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

If your game already has a leaderstats script, add the Cash value to it instead. Two scripts that each make a leaderstats folder is a common reason a stat never changes on screen.

local Players = game:GetService("Players")

local tycoons = workspace:WaitForChild("Tycoons")

local function ownerIdOf(tycoon: Instance): number
	local id = tycoon:GetAttribute("OwnerId")
	return if typeof(id) == "number" then id else 0
end

-- The living player whose character touched the part, or nil for anything else
local function playerFromHit(hit: BasePart): Player?
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then
		return nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then
		return nil
	end
	return Players:GetPlayerFromCharacter(character)
end

local function ownedTycoon(player: Player): Model?
	for _, tycoon in tycoons:GetChildren() do
		if tycoon:IsA("Model") and ownerIdOf(tycoon) == player.UserId then
			return tycoon
		end
	end
	return nil
end

-- The sign above the pad, created the first time it is needed
local function signLabel(pad: BasePart): TextLabel
	local existing = pad:FindFirstChild("OwnerLabel", true)
	if existing and existing:IsA("TextLabel") then
		return existing
	end
	local billboard = Instance.new("BillboardGui")
	billboard.Size = UDim2.fromOffset(240, 50)
	billboard.StudsOffset = Vector3.new(0, 4, 0)
	billboard.MaxDistance = 80

	local label = Instance.new("TextLabel")
	label.Name = "OwnerLabel"
	label.Size = UDim2.fromScale(1, 1)
	label.BackgroundTransparency = 1
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextStrokeTransparency = 0.4
	label.TextScaled = true
	label.Parent = billboard
	billboard.Parent = pad
	return label
end

local function release(tycoon: Model, pad: BasePart)
	tycoon:SetAttribute("OwnerId", 0)
	pad.Transparency = 0
	signLabel(pad).Text = "Free tycoon: step here to claim"
end

local function claim(tycoon: Model, pad: BasePart, player: Player)
	tycoon:SetAttribute("OwnerId", player.UserId)
	pad.Transparency = 0.7
	signLabel(pad).Text = `{player.DisplayName}'s tycoon`
end

local function setUpPad(tycoon: Model, pad: BasePart)
	release(tycoon, pad) -- every plot starts free
	pad.Touched:Connect(function(hit: BasePart)
		if ownerIdOf(tycoon) ~= 0 then
			return -- someone owns it already
		end
		local player = playerFromHit(hit)
		if player and not ownedTycoon(player) then -- one tycoon per player
			claim(tycoon, pad, player)
		end
	end)
end

for _, tycoon in tycoons:GetChildren() do
	local pad = tycoon:FindFirstChild("ClaimPad")
	if tycoon:IsA("Model") and pad and pad:IsA("BasePart") then
		setUpPad(tycoon, pad)
	else
		warn(`{tycoon:GetFullName()} needs to be a Model with a Part named ClaimPad`)
	end
end

-- Free the plot when its owner leaves, so the next player can claim it
Players.PlayerRemoving:Connect(function(player: Player)
	local tycoon = ownedTycoon(player)
	local pad = tycoon and tycoon:FindFirstChild("ClaimPad")
	if tycoon and pad and pad:IsA("BasePart") then
		release(tycoon, pad)
	end
end)

Touched can fire many times while a character stands on the pad. That is harmless here: after the first touch the plot is owned, and every later touch returns at the first check.

local Debris = game:GetService("Debris")

local tycoons = workspace:WaitForChild("Tycoons")

local MAX_DROPS_PER_TYCOON = 50 -- live drops at once; a dropper skips its turn at the cap
local DROP_LIFETIME = 30 -- seconds; removes drops that fall off or get stuck
local TICK = 0.2 -- how often the loop checks the droppers

-- When each dropper may drop next. Bought droppers are hidden, never destroyed,
-- so these entries stay valid for the life of the server.
local nextDropAt: { [BasePart]: number } = {}

local function positiveNumber(instance: Instance, name: string, default: number): number
	local value = instance:GetAttribute(name)
	if typeof(value) == "number" and value > 0 then
		return value
	end
	return default
end

local function ownerIdOf(tycoon: Instance): number
	local id = tycoon:GetAttribute("OwnerId")
	return if typeof(id) == "number" then id else 0
end

-- Each plot keeps its drops in its own folder. The collector pays only for drops in it.
local function dropsFolder(tycoon: Model): Folder
	local existing = tycoon:FindFirstChild("Drops")
	if existing and existing:IsA("Folder") then
		return existing
	end
	local folder = Instance.new("Folder")
	folder.Name = "Drops"
	folder.Parent = tycoon
	return folder
end

local function spawnDrop(tycoon: Model, dropper: BasePart)
	local drops = dropsFolder(tycoon)
	if #drops:GetChildren() >= MAX_DROPS_PER_TYCOON then
		return
	end

	local drop = Instance.new("Part")
	drop.Name = "Drop"
	drop.Size = Vector3.new(1, 1, 1)
	drop.Color = dropper.Color
	drop.Material = Enum.Material.SmoothPlastic
	drop.CFrame = dropper.CFrame * CFrame.new(0, -(dropper.Size.Y / 2 + 0.6), 0) -- just under the dropper
	drop:SetAttribute("Value", positiveNumber(dropper, "DropValue", 1))
	drop.Parent = drops

	-- The server simulates the drop, so no player's device can move it or fake its touches
	if drop:CanSetNetworkOwnership() then
		drop:SetNetworkOwner(nil)
	end
	Debris:AddItem(drop, DROP_LIFETIME)
end

-- Clear a plot's drops when its owner leaves
local function watchOwner(tycoon: Model)
	tycoon:GetAttributeChangedSignal("OwnerId"):Connect(function()
		if ownerIdOf(tycoon) == 0 then
			dropsFolder(tycoon):ClearAllChildren()
		end
	end)
end

for _, tycoon in tycoons:GetChildren() do
	if tycoon:IsA("Model") then
		watchOwner(tycoon)
	end
end

while true do
	local now = os.clock()
	for _, tycoon in tycoons:GetChildren() do
		local droppers = tycoon:FindFirstChild("Droppers")
		if tycoon:IsA("Model") and droppers and ownerIdOf(tycoon) ~= 0 then
			for _, dropper in droppers:GetChildren() do
				if dropper:IsA("BasePart") and now >= (nextDropAt[dropper] or 0) then
					nextDropAt[dropper] = now + positiveNumber(dropper, "Interval", 2)
					spawnDrop(tycoon, dropper)
				end
			end
		end
	end
	task.wait(TICK)
end

The loop checks five times a second, so an Interval below 0.2 behaves like 0.2. Only droppers inside the Droppers folder run: an unbought Dropper2 is in ServerStorage until its button is bought, so the loop never sees it.

local tycoons = workspace:WaitForChild("Tycoons")

local DEFAULT_SPEED = 8 -- studs per second

-- An anchored part never moves, but a velocity on it carries whatever rests on top
local function startConveyor(part: BasePart)
	local speed = part:GetAttribute("Speed")
	local studsPerSecond = if typeof(speed) == "number" then speed else DEFAULT_SPEED
	part.Anchored = true
	part.AssemblyLinearVelocity = part.CFrame.LookVector * studsPerSecond
end

local function onDescendant(instance: Instance)
	if instance.Name == "Conveyor" and instance:IsA("BasePart") then
		startConveyor(instance)
	end
end

for _, instance in tycoons:GetDescendants() do
	onDescendant(instance)
end

-- A conveyor sold by a button comes back into its plot later, so watch for it too
tycoons.DescendantAdded:Connect(onDescendant)

LookVector is the direction of the part's front face, so the belt runs the way the part faces. If drops travel the wrong way, rotate the conveyor 180 degrees or make its Speed negative.

local Players = game:GetService("Players")

local tycoons = workspace:WaitForChild("Tycoons")

local function ownerIdOf(tycoon: Instance): number
	local id = tycoon:GetAttribute("OwnerId")
	return if typeof(id) == "number" then id else 0
end

local function cashOf(player: Player): IntValue?
	local leaderstats = player:FindFirstChild("leaderstats")
	local cash = leaderstats and leaderstats:FindFirstChild("Cash")
	if cash and cash:IsA("IntValue") then
		return cash
	end
	return nil
end

local function setUpCollector(tycoon: Model, collector: BasePart)
	collector.Touched:Connect(function(hit: BasePart)
		-- Only drops made by this plot's droppers count. Characters, tools and
		-- drops from a neighbour's plot are ignored.
		local drops = tycoon:FindFirstChild("Drops")
		if drops == nil or hit.Parent ~= drops then
			return
		end

		local value = hit:GetAttribute("Value")
		-- Destroy sets Parent to nil, so a second touch from the same drop fails the check above
		hit:Destroy()

		local owner = Players:GetPlayerByUserId(ownerIdOf(tycoon))
		local cash = owner and cashOf(owner)
		if cash and typeof(value) == "number" then
			cash.Value += math.floor(value)
		end
	end)
end

for _, tycoon in tycoons:GetChildren() do
	local collector = tycoon:FindFirstChild("Collector")
	if tycoon:IsA("Model") and collector and collector:IsA("BasePart") then
		setUpCollector(tycoon, collector)
	else
		warn(`{tycoon:GetFullName()} needs a Part named Collector`)
	end
end

Touched only fires when at least one of the two parts is not anchored. The collector is anchored, so this works only because drops are not. An anchored drop never fires Touched on the collector, and never rides the conveyor either.

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

local tycoons = workspace:WaitForChild("Tycoons")

type Button = {
	part: BasePart,
	price: number,
	requires: string?,
	item: Instance,
	itemHome: Instance?,
	bought: boolean,
}

type Tycoon = {
	model: Model,
	buttonsFolder: Instance,
	stash: Folder,
	buttons: { [string]: Button },
}

-- Unbought items and hidden buttons wait here, out of the world
local stashRoot = Instance.new("Folder")
stashRoot.Name = "TycoonStash"
stashRoot.Parent = ServerStorage

local function ownerIdOf(model: Instance): number
	local id = model:GetAttribute("OwnerId")
	return if typeof(id) == "number" then id else 0
end

local function playerFromHit(hit: BasePart): Player?
	local character = hit:FindFirstAncestorOfClass("Model")
	if not character then
		return nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then
		return nil
	end
	return Players:GetPlayerFromCharacter(character)
end

local function cashOf(player: Player): IntValue?
	local leaderstats = player:FindFirstChild("leaderstats")
	local cash = leaderstats and leaderstats:FindFirstChild("Cash")
	if cash and cash:IsA("IntValue") then
		return cash
	end
	return nil
end

local function readString(instance: Instance, name: string): string?
	local value = instance:GetAttribute(name)
	return if typeof(value) == "string" and value ~= "" then value else nil
end

local function moveTo(instance: Instance, parent: Instance?)
	if instance.Parent ~= parent then
		instance.Parent = parent
	end
end

local function addPriceLabel(part: BasePart, text: string)
	local billboard = Instance.new("BillboardGui")
	billboard.Size = UDim2.fromOffset(220, 50)
	billboard.StudsOffset = Vector3.new(0, 3, 0)
	billboard.MaxDistance = 60

	local label = Instance.new("TextLabel")
	label.Size = UDim2.fromScale(1, 1)
	label.BackgroundTransparency = 1
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextStrokeTransparency = 0.4
	label.TextScaled = true
	label.Text = text
	label.Parent = billboard
	billboard.Parent = part
end

-- A button shows when the plot has an owner, it is not bought yet, and the button
-- it requires (if any) is bought. An item shows once its button is bought.
local function refresh(tycoon: Tycoon)
	local owned = ownerIdOf(tycoon.model) ~= 0
	for _, button in tycoon.buttons do
		local requiredName = button.requires
		local required = if requiredName then tycoon.buttons[requiredName] else nil
		local unlocked = requiredName == nil or (required ~= nil and required.bought)
		local show = owned and unlocked and not button.bought
		moveTo(button.part, if show then tycoon.buttonsFolder else tycoon.stash)
		moveTo(button.item, if button.bought then button.itemHome else tycoon.stash)
	end
end

-- A touch only asks to buy. Every check happens here, on the server.
local function tryBuy(tycoon: Tycoon, button: Button, player: Player)
	if ownerIdOf(tycoon.model) ~= player.UserId then
		return -- not this player's plot
	end
	if button.bought or button.part.Parent ~= tycoon.buttonsFolder then
		return -- already bought, or still hidden
	end
	local cash = cashOf(player)
	if not cash or cash.Value < button.price then
		return -- not enough Cash
	end
	cash.Value -= button.price
	button.bought = true
	refresh(tycoon)
end

local function addButton(tycoon: Tycoon, part: BasePart)
	local price = part:GetAttribute("Price")
	local itemName = readString(part, "Unlocks")
	local item = if itemName then tycoon.model:FindFirstChild(itemName, true) else nil
	if typeof(price) ~= "number" or price < 0 or item == nil then
		warn(`{part:GetFullName()} needs a Price number and an Unlocks name that exists in {tycoon.model.Name}`)
		return
	end

	local button: Button = {
		part = part,
		price = math.floor(price),
		requires = readString(part, "Requires"),
		item = item,
		itemHome = item.Parent,
		bought = false,
	}
	tycoon.buttons[part.Name] = button
	addPriceLabel(part, `{itemName}: {button.price} Cash`)

	part.Touched:Connect(function(hit: BasePart)
		local player = playerFromHit(hit)
		if player then
			tryBuy(tycoon, button, player)
		end
	end)
end

local function setUpTycoon(model: Model, buttonsFolder: Instance)
	local stash = Instance.new("Folder")
	stash.Name = model.Name
	stash.Parent = stashRoot

	local tycoon: Tycoon = { model = model, buttonsFolder = buttonsFolder, stash = stash, buttons = {} }
	for _, part in buttonsFolder:GetChildren() do
		if part:IsA("BasePart") then
			addButton(tycoon, part)
		end
	end
	for name, button in tycoon.buttons do
		local requiredName = button.requires
		if requiredName and tycoon.buttons[requiredName] == nil then
			warn(`{name} requires {requiredName}, which is not a button in {model.Name}`)
		end
	end

	-- A new owner starts from nothing; when the owner leaves, everything goes back
	model:GetAttributeChangedSignal("OwnerId"):Connect(function()
		if ownerIdOf(model) == 0 then
			for _, button in tycoon.buttons do
				button.bought = false
			end
		end
		refresh(tycoon)
	end)
	refresh(tycoon)
end

for _, model in tycoons:GetChildren() do
	local buttonsFolder = model:FindFirstChild("Buttons")
	if model:IsA("Model") and buttonsFolder then
		setUpTycoon(model, buttonsFolder)
	end
end

Each button reads its price on the server, from an attribute the server can see. The touch carries no price or amount, so there is nothing for a client to change.

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

local cashStore = DataStoreService:GetDataStore("TycoonCash_v1")

-- Players whose Cash loaded. Anyone missing from here is never saved,
-- so a failed load cannot overwrite their real Cash with 0.
local loaded: { [Player]: boolean } = {}
local savesInProgress = 0

local function keyFor(player: Player): string
	return "player_" .. player.UserId
end

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

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

	local ok, saved = pcall(function()
		return cashStore:GetAsync(keyFor(player))
	end)
	if player.Parent ~= Players then
		return -- they left while their Cash was loading
	end
	if ok then
		cash.Value = if typeof(saved) == "number" then math.floor(saved) else 0
		loaded[player] = true
	else
		warn(`Could not load Cash for {player.Name}: {saved}`)
	end
	leaderstats.Parent = player
end

local function save(player: Player)
	if not loaded[player] then
		return
	end
	loaded[player] = nil -- save once, whether leaving or shutdown comes first

	local leaderstats = player:FindFirstChild("leaderstats")
	local cash = leaderstats and leaderstats:FindFirstChild("Cash")
	if not (cash and cash:IsA("IntValue")) then
		return
	end
	local amount = cash.Value

	savesInProgress += 1
	local ok, err = pcall(function()
		cashStore:SetAsync(keyFor(player), amount)
	end)
	savesInProgress -= 1
	if not ok then
		warn(`Could not save Cash for {player.Name}: {err}`)
	end
end

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

Players.PlayerRemoving:Connect(save)

-- When the server shuts down, save everyone still here and wait for every save to finish
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while savesInProgress > 0 do
		task.wait()
	end
end)

If a load fails, the player keeps playing with 0 Cash that is never saved. In a real game, tell them, as the DataStore tutorial shows, so they can rejoin before they spend time earning.