Game Systems

Roblox Game Systems

When implementing game systems, follow these patterns for robust and exploiter-resistant mechanics.

Inventory System

Slot-Based Inventory

local InventoryService = {}

local DEFAULT_SLOTS = 20
local MAX_STACK = 99

function InventoryService.create(maxSlots)
    return {
        slots = {},
        maxSlots = maxSlots or DEFAULT_SLOTS
    }
end

function InventoryService.addItem(inventory, itemId, quantity)
    quantity = quantity or 1

    -- Try to stack with existing
    for slotIndex, slot in pairs(inventory.slots) do
        if slot.itemId == itemId and slot.quantity < MAX_STACK then
            local canAdd = math.min(quantity, MAX_STACK - slot.quantity)
            slot.quantity = slot.quantity + canAdd
            quantity = quantity - canAdd

            if quantity <= 0 then
                return true, slotIndex
            end
        end
    end

    -- Find empty slots for remaining
    while quantity > 0 do
        local emptySlot = InventoryService.findEmptySlot(inventory)
        if not emptySlot then
            return false, "Inventory full"
        end

        local stackSize = math.min(quantity, MAX_STACK)
        inventory.slots[emptySlot] = {
            itemId = itemId,
            quantity = stackSize
        }
        quantity = quantity - stackSize
    end

    return true
end

function InventoryService.removeItem(inventory, itemId, quantity)
    quantity = quantity or 1
    local removed = 0

    -- Remove from slots (prefer partial stacks first)
    local slots = {}
    for slotIndex, slot in pairs(inventory.slots) do
        if slot.itemId == itemId then
            table.insert(slots, {index = slotIndex, quantity = slot.quantity})
        end
    end

    table.sort(slots, function(a, b) return a.quantity < b.quantity end)

    for _, slotInfo in ipairs(slots) do
        local slot = inventory.slots[slotInfo.index]
        local toRemove = math.min(quantity - removed, slot.quantity)

        slot.quantity = slot.quantity - toRemove
        removed = removed + toRemove

        if slot.quantity <= 0 then
            inventory.slots[slotInfo.index] = nil
        end

        if removed >= quantity then
            break
        end
    end

    return removed >= quantity, removed
end

function InventoryService.hasItem(inventory, itemId, quantity)
    quantity = quantity or 1
    local total = 0

    for _, slot in pairs(inventory.slots) do
        if slot.itemId == itemId then
            total = total + slot.quantity
            if total >= quantity then
                return true
            end
        end
    end

    return false
end

function InventoryService.getItemCount(inventory, itemId)
    local total = 0
    for _, slot in pairs(inventory.slots) do
        if slot.itemId == itemId then
            total = total + slot.quantity
        end
    end
    return total
end

function InventoryService.findEmptySlot(inventory)
    for i = 1, inventory.maxSlots do
        if not inventory.slots[i] then
            return i
        end
    end
    return nil
end

Shop System

Server-Side Shop with Validation

local ShopService = {}

local ShopItems = {
    sword_basic = {price = 100, currency = "coins", category = "weapons"},
    potion_health = {price = 50, currency = "coins", category = "consumables"},
    vip_pass = {price = 499, currency = "robux", productId = 123456789}
}

function ShopService.canPurchase(player, itemId, quantity)
    quantity = quantity or 1
    local item = ShopItems[itemId]

    if not item then
        return false, "Item not found"
    end

    if item.currency == "robux" then
        -- Robux purchases handled differently
        return true, "Use promptPurchase"
    end

    local playerCurrency = DataManager.get(player, item.currency) or 0
    local totalCost = item.price * quantity

    if playerCurrency < totalCost then
        return false, "Not enough " .. item.currency
    end

    -- Check inventory space
    local inventory = DataManager.get(player, "inventory")
    local emptySlots = InventoryService.countEmptySlots(inventory)

    if emptySlots < math.ceil(quantity / MAX_STACK) then
        return false, "Inventory full"
    end

    return true, totalCost
end

function ShopService.purchase(player, itemId, quantity)
    quantity = quantity or 1

    local canBuy, result = ShopService.canPurchase(player, itemId, quantity)
    if not canBuy then
        return false, result
    end

    local item = ShopItems[itemId]

    if item.currency == "robux" then
        -- Prompt Robux purchase
        MarketplaceService:PromptProductPurchase(player, item.productId)
        return true, "Purchase prompted"
    end

    -- Deduct currency (atomic operation)
    local success = DataManager.removeCurrency(player, item.currency, result)
    if not success then
        return false, "Transaction failed"
    end

    -- Add item
    local inventory = DataManager.get(player, "inventory")
    local added = InventoryService.addItem(inventory, itemId, quantity)

    if not added then
        -- Rollback currency
        DataManager.addCurrency(player, item.currency, result)
        return false, "Failed to add item"
    end

    return true, "Purchase successful"
end

-- Handle Robux purchases
MarketplaceService.ProcessReceipt = function(receiptInfo)
    local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
    if not player then
        return Enum.ProductPurchaseDecision.NotProcessedYet
    end

    local productId = receiptInfo.ProductId
    local itemId = getItemByProductId(productId)

    if not itemId then
        return Enum.ProductPurchaseDecision.NotProcessedYet
    end

    local inventory = DataManager.get(player, "inventory")
    local added = InventoryService.addItem(inventory, itemId, 1)

    if added then
        DataManager.save(player)
        return Enum.ProductPurchaseDecision.PurchaseGranted
    end

    return Enum.ProductPurchaseDecision.NotProcessedYet
end

Trading System

Secure Trading

local TradingService = {}
TradingService.activeTrades = {}

function TradingService.requestTrade(player1, player2)
    local tradeId = HttpService:GenerateGUID()

    TradingService.activeTrades[tradeId] = {
        player1 = {
            player = player1,
            items = {},
            confirmed = false
        },
        player2 = {
            player = player2,
            items = {},
            confirmed = false
        },
        status = "pending",
        createdAt = os.clock()
    }

    -- Notify player2
    TradeRequestRemote:FireClient(player2, player1.Name, tradeId)

    return tradeId
end

function TradingService.addItem(tradeId, player, itemSlot)
    local trade = TradingService.activeTrades[tradeId]
    if not trade or trade.status ~= "active" then
        return false, "Invalid trade"
    end

    local side = trade.player1.player == player and trade.player1 or
                 trade.player2.player == player and trade.player2

    if not side then
        return false, "Not in this trade"
    end

    -- Reset confirmations when items change
    trade.player1.confirmed = false
    trade.player2.confirmed = false

    -- Validate player owns the item
    local inventory = DataManager.get(player, "inventory")
    local item = inventory.slots[itemSlot]

    if not item then
        return false, "Item not found"
    end

    -- Check item isn't already in trade
    for _, existingSlot in ipairs(side.items) do
        if existingSlot == itemSlot then
            return false, "Item already in trade"
        end
    end

    table.insert(side.items, itemSlot)

    -- Update both players' UI
    TradeUpdateRemote:FireClient(trade.player1.player, tradeId, trade)
    TradeUpdateRemote:FireClient(trade.player2.player, tradeId, trade)

    return true
end

function TradingService.confirmTrade(tradeId, player)
    local trade = TradingService.activeTrades[tradeId]
    if not trade or trade.status ~= "active" then
        return false
    end

    local side = trade.player1.player == player and trade.player1 or
                 trade.player2.player == player and trade.player2

    if not side then return false end

    side.confirmed = true

    -- Check if both confirmed
    if trade.player1.confirmed and trade.player2.confirmed then
        return TradingService.executeTrade(tradeId)
    end

    -- Update UI
    TradeUpdateRemote:FireClient(trade.player1.player, tradeId, trade)
    TradeUpdateRemote:FireClient(trade.player2.player, tradeId, trade)

    return true
end

function TradingService.executeTrade(tradeId)
    local trade = TradingService.activeTrades[tradeId]
    trade.status = "executing"

    local p1 = trade.player1.player
    local p2 = trade.player2.player
    local inv1 = DataManager.get(p1, "inventory")
    local inv2 = DataManager.get(p2, "inventory")

    -- Validate both players still have the items
    for _, slot in ipairs(trade.player1.items) do
        if not inv1.slots[slot] then
            TradingService.cancelTrade(tradeId, "Item no longer available")
            return false
        end
    end

    for _, slot in ipairs(trade.player2.items) do
        if not inv2.slots[slot] then
            TradingService.cancelTrade(tradeId, "Item no longer available")
            return false
        end
    end

    -- Execute swap atomically
    local p1Items = {}
    local p2Items = {}

    -- Remove items from player 1
    for _, slot in ipairs(trade.player1.items) do
        table.insert(p1Items, inv1.slots[slot])
        inv1.slots[slot] = nil
    end

    -- Remove items from player 2
    for _, slot in ipairs(trade.player2.items) do
        table.insert(p2Items, inv2.slots[slot])
        inv2.slots[slot] = nil
    end

    -- Add player 1's items to player 2
    for _, item in ipairs(p1Items) do
        InventoryService.addItem(inv2, item.itemId, item.quantity)
    end

    -- Add player 2's items to player 1
    for _, item in ipairs(p2Items) do
        InventoryService.addItem(inv1, item.itemId, item.quantity)
    end

    -- Save both players
    DataManager.save(p1)
    DataManager.save(p2)

    -- Complete trade
    trade.status = "completed"
    TradingService.activeTrades[tradeId] = nil

    TradeCompleteRemote:FireClient(p1, tradeId, true)
    TradeCompleteRemote:FireClient(p2, tradeId, true)

    return true
end

Quest System

Quest Manager

local QuestService = {}

local QuestDefinitions = {
    kill_enemies_1 = {
        title = "Enemy Slayer",
        description = "Defeat 10 enemies",
        objectives = {
            {type = "kill", target = "enemy", count = 10}
        },
        rewards = {
            {type = "currency", currency = "coins", amount = 100},
            {type = "experience", amount = 50}
        }
    },
    collect_items_1 = {
        title = "Collector",
        description = "Collect 5 gems",
        objectives = {
            {type = "collect", item = "gem", count = 5}
        },
        rewards = {
            {type = "currency", currency = "coins", amount = 200}
        }
    }
}

function QuestService.startQuest(player, questId)
    local quest = QuestDefinitions[questId]
    if not quest then return false end

    local playerQuests = DataManager.get(player, "activeQuests") or {}

    -- Check not already active
    if playerQuests[questId] then
        return false, "Quest already active"
    end

    -- Initialize progress
    playerQuests[questId] = {
        startedAt = os.time(),
        progress = {}
    }

    for i, objective in ipairs(quest.objectives) do
        playerQuests[questId].progress[i] = 0
    end

    DataManager.set(player, "activeQuests", playerQuests)
    return true
end

function QuestService.updateProgress(player, eventType, eventData)
    local playerQuests = DataManager.get(player, "activeQuests") or {}
    local updated = false

    for questId, questProgress in pairs(playerQuests) do
        local quest = QuestDefinitions[questId]
        if not quest then continue end

        for i, objective in ipairs(quest.objectives) do
            if objective.type == eventType then
                local matches = true

                -- Check target matches
                if objective.target and eventData.target ~= objective.target then
                    matches = false
                end
                if objective.item and eventData.item ~= objective.item then
                    matches = false
                end

                if matches and questProgress.progress[i] < objective.count then
                    questProgress.progress[i] = questProgress.progress[i] + (eventData.amount or 1)
                    updated = true

                    -- Check if quest completed
                    if QuestService.isQuestComplete(questId, questProgress) then
                        QuestService.completeQuest(player, questId)
                    end
                end
            end
        end
    end

    if updated then
        DataManager.set(player, "activeQuests", playerQuests)
    end
end

function QuestService.isQuestComplete(questId, progress)
    local quest = QuestDefinitions[questId]

    for i, objective in ipairs(quest.objectives) do
        if progress.progress[i] < objective.count then
            return false
        end
    end

    return true
end

function QuestService.completeQuest(player, questId)
    local quest = QuestDefinitions[questId]
    local playerQuests = DataManager.get(player, "activeQuests")

    -- Remove from active
    playerQuests[questId] = nil
    DataManager.set(player, "activeQuests", playerQuests)

    -- Add to completed
    local completedQuests = DataManager.get(player, "completedQuests") or {}
    completedQuests[questId] = os.time()
    DataManager.set(player, "completedQuests", completedQuests)

    -- Grant rewards
    for _, reward in ipairs(quest.rewards) do
        if reward.type == "currency" then
            DataManager.addCurrency(player, reward.currency, reward.amount)
        elseif reward.type == "experience" then
            LevelingService.addExperience(player, reward.amount)
        elseif reward.type == "item" then
            local inventory = DataManager.get(player, "inventory")
            InventoryService.addItem(inventory, reward.item, reward.quantity or 1)
        end
    end

    QuestCompleteRemote:FireClient(player, questId, quest.rewards)
end

Pet System

Pet Manager

local PetService = {}

local PetDefinitions = {
    cat_basic = {name = "Cat", rarity = "common", bonuses = {luck = 5}},
    dog_basic = {name = "Dog", rarity = "common", bonuses = {speed = 5}},
    dragon_epic = {name = "Dragon", rarity = "epic", bonuses = {damage = 20, luck = 10}}
}

function PetService.createPet(petType)
    local def = PetDefinitions[petType]
    if not def then return nil end

    return {
        id = HttpService:GenerateGUID(),
        type = petType,
        name = def.name,
        level = 1,
        experience = 0,
        equipped = false
    }
end

function PetService.equipPet(player, petId)
    local pets = DataManager.get(player, "pets") or {}

    -- Find the pet
    local targetPet
    for _, pet in ipairs(pets) do
        if pet.id == petId then
            targetPet = pet
        else
            pet.equipped = false  -- Unequip others
        end
    end

    if not targetPet then
        return false, "Pet not found"
    end

    targetPet.equipped = true
    DataManager.set(player, "pets", pets)

    -- Apply bonuses
    PetService.applyBonuses(player, targetPet)

    -- Spawn visual pet
    PetService.spawnPetVisual(player, targetPet)

    return true
end

function PetService.applyBonuses(player, pet)
    local def = PetDefinitions[pet.type]
    if not def then return end

    local levelMultiplier = 1 + (pet.level - 1) * 0.1  -- 10% per level

    for stat, value in pairs(def.bonuses) do
        local bonus = math.floor(value * levelMultiplier)
        player:SetAttribute("PetBonus_" .. stat, bonus)
    end
end

function PetService.spawnPetVisual(player, pet)
    local character = player.Character
    if not character then return end

    -- Remove existing pet visual
    local existing = character:FindFirstChild("PetModel")
    if existing then existing:Destroy() end

    local def = PetDefinitions[pet.type]
    local petModel = ReplicatedStorage.Pets[pet.type]:Clone()
    petModel.Name = "PetModel"
    petModel.Parent = character

    -- Pet following behavior
    task.spawn(function()
        local hrp = character:FindFirstChild("HumanoidRootPart")
        while petModel.Parent and hrp do
            local targetPos = hrp.Position + hrp.CFrame.RightVector * 3 + Vector3.new(0, 2, 0)
            local currentPos = petModel.PrimaryPart.Position

            local direction = (targetPos - currentPos)
            if direction.Magnitude > 0.5 then
                local newPos = currentPos + direction.Unit * math.min(direction.Magnitude, 0.5)
                petModel:PivotTo(CFrame.lookAt(newPos, hrp.Position))
            end

            task.wait()
        end
    end)
end

Leveling System

Experience & Leveling

local LevelingService = {}

-- XP required for each level: level^2 * 100
local function getRequiredXP(level)
    return level * level * 100
end

function LevelingService.addExperience(player, amount)
    local currentLevel = DataManager.get(player, "level") or 1
    local currentXP = DataManager.get(player, "experience") or 0

    currentXP = currentXP + amount

    -- Check for level ups
    local levelsGained = 0
    while currentXP >= getRequiredXP(currentLevel) do
        currentXP = currentXP - getRequiredXP(currentLevel)
        currentLevel = currentLevel + 1
        levelsGained = levelsGained + 1
    end

    DataManager.set(player, "level", currentLevel)
    DataManager.set(player, "experience", currentXP)

    if levelsGained > 0 then
        LevelingService.onLevelUp(player, currentLevel, levelsGained)
    end

    return currentLevel, currentXP, levelsGained
end

function LevelingService.onLevelUp(player, newLevel, levelsGained)
    -- Heal to full
    local character = player.Character
    if character then
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        if humanoid then
            humanoid.Health = humanoid.MaxHealth
        end
    end

    -- Grant stat points
    local statPoints = DataManager.get(player, "statPoints") or 0
    DataManager.set(player, "statPoints", statPoints + levelsGained * 3)

    -- Unlock abilities
    local unlocks = AbilityUnlocks[newLevel]
    if unlocks then
        for _, abilityId in ipairs(unlocks) do
            AbilityService.unlock(player, abilityId)
        end
    end

    -- Visual/audio feedback
    LevelUpRemote:FireClient(player, newLevel)
end

function LevelingService.getProgress(player)
    local level = DataManager.get(player, "level") or 1
    local xp = DataManager.get(player, "experience") or 0
    local required = getRequiredXP(level)

    return {
        level = level,
        currentXP = xp,
        requiredXP = required,
        progress = xp / required
    }
end

Daily Rewards

Daily Login System

local DailyRewardService = {}

local DAILY_REWARDS = {
    {type = "coins", amount = 100},
    {type = "coins", amount = 150},
    {type = "coins", amount = 200},
    {type = "gems", amount = 5},
    {type = "coins", amount = 300},
    {type = "gems", amount = 10},
    {type = "item", itemId = "rare_chest", amount = 1}
}

function DailyRewardService.checkDailyReward(player)
    local lastLogin = DataManager.get(player, "lastLoginTime") or 0
    local loginStreak = DataManager.get(player, "loginStreak") or 0

    local now = os.time()
    local lastLoginDate = os.date("*t", lastLogin)
    local currentDate = os.date("*t", now)

    -- Check if it's a new day
    local isNewDay = lastLoginDate.yday ~= currentDate.yday or
                     lastLoginDate.year ~= currentDate.year

    if not isNewDay then
        return nil, "Already claimed today"
    end

    -- Check if streak continues or resets
    local hoursSinceLastLogin = (now - lastLogin) / 3600
    if hoursSinceLastLogin > 48 then
        loginStreak = 0  -- Reset streak
    end

    loginStreak = loginStreak + 1
    local rewardIndex = ((loginStreak - 1) % #DAILY_REWARDS) + 1
    local reward = DAILY_REWARDS[rewardIndex]

    -- Update data
    DataManager.set(player, "lastLoginTime", now)
    DataManager.set(player, "loginStreak", loginStreak)

    -- Grant reward
    if reward.type == "coins" or reward.type == "gems" then
        DataManager.addCurrency(player, reward.type, reward.amount)
    elseif reward.type == "item" then
        local inventory = DataManager.get(player, "inventory")
        InventoryService.addItem(inventory, reward.itemId, reward.amount)
    end

    return {
        day = loginStreak,
        reward = reward
    }
end