Creating a Robust Health, Hunger, and Stamina System in Roblox Lua

Key Highlights of Our Implementation

• Server-side security to prevent exploitation and maintain game integrity
• Interconnected systems where hunger affects health and stamina impacts player movement
• Customizable GUI elements for visual feedback to enhance player experience

System Architecture

To create a reliable health, hunger, and stamina system in Roblox, we need to carefully consider both client and server-side scripting. This ensures security while providing a responsive player experience. Our implementation follows these key principles:

Core Architecture Design

• Server-side management: All critical game state changes happen on the server
• Client-side display: UI updates and input detection happen on the client
• Secure communication: RemoteEvents handle client-server communication

Let's start by setting up the necessary components for our system.

Setting Up RemoteEvents

First, create a RemoteEvent in ReplicatedStorage to handle communication:

-- Place this in a Script inside ServerScriptService
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Create a folder for remotes if it doesn't exist
local remoteFolder = ReplicatedStorage:FindFirstChild("Remotes")
if not remoteFolder then
    remoteFolder = Instance.new("Folder")
    remoteFolder.Name = "Remotes"
    remoteFolder.Parent = ReplicatedStorage
end

-- Create RemoteEvents for our systems
local statsRemote = Instance.new("RemoteEvent")
statsRemote.Name = "StatsUpdate"
statsRemote.Parent = remoteFolder

local actionRemote = Instance.new("RemoteEvent")
actionRemote.Name = "PlayerAction"
actionRemote.Parent = remoteFolder

Server-Side Implementation

The server script handles the core logic for our stat systems. Let's implement it with security in mind:

-- Server Script (place in ServerScriptService)
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Get our remote events
local remotes = ReplicatedStorage:WaitForChild("Remotes")
local statsRemote = remotes:WaitForChild("StatsUpdate")
local actionRemote = remotes:WaitForChild("PlayerAction")

-- Configuration (consider moving to a ModuleScript for easier tuning)
local CONFIG = {
    INITIAL_HEALTH = 100,
    INITIAL_HUNGER = 100,
    INITIAL_STAMINA = 100,
    
    HUNGER_DECREASE_RATE = 1, -- How much hunger decreases per interval
    HUNGER_DECREASE_INTERVAL = 5, -- In seconds
    
    STAMINA_DECREASE_RATE = 5, -- How much stamina decreases per second when sprinting
    STAMINA_REGEN_RATE = 2, -- How much stamina regenerates per second when not sprinting
    
    HEALTH_DECREASE_RATE = 1, -- How much health decreases when hunger is at 0
    HEALTH_DECREASE_INTERVAL = 2, -- In seconds
    
    FOOD_RESTORE_AMOUNT = 25, -- How much hunger is restored by eating food
    
    STAMINA_MIN_TO_SPRINT = 10 -- Minimum stamina required to start sprinting
}

-- Storage for players' sprint states
local playerSprinting = {}

-- Function to initialize player stats
local function setupPlayerStats(player)
    -- Create a stats folder for this player
    local statsFolder = Instance.new("Folder")
    statsFolder.Name = "PlayerStats"
    statsFolder.Parent = player
    
    -- Create the stat values
    local healthValue = Instance.new("NumberValue")
    healthValue.Name = "Health"
    healthValue.Value = CONFIG.INITIAL_HEALTH
    healthValue.Parent = statsFolder
    
    local hungerValue = Instance.new("NumberValue")
    hungerValue.Name = "Hunger"
    hungerValue.Value = CONFIG.INITIAL_HUNGER
    hungerValue.Parent = statsFolder
    
    local staminaValue = Instance.new("NumberValue")
    staminaValue.Name = "Stamina"
    staminaValue.Value = CONFIG.INITIAL_STAMINA
    staminaValue.Parent = statsFolder
    
    -- Initialize sprinting state
    playerSprinting[player.UserId] = false
    
    -- Notify client of initial stats
    statsRemote:FireClient(player, {
        Health = healthValue.Value,
        Hunger = hungerValue.Value,
        Stamina = staminaValue.Value
    })
    
    -- Return the stats for convenience
    return healthValue, hungerValue, staminaValue
end

-- Function to manage hunger depletion
local function manageHunger(player, hungerValue, healthValue)
    while player.Parent and player:FindFirstChild("PlayerStats") do
        wait(CONFIG.HUNGER_DECREASE_INTERVAL)
        
        -- Decrease hunger over time
        hungerValue.Value = math.max(0, hungerValue.Value - CONFIG.HUNGER_DECREASE_RATE)
        
        -- If hunger is at 0, start decreasing health
        if hungerValue.Value <= 0 then
            wait(CONFIG.HEALTH_DECREASE_INTERVAL)
            healthValue.Value = math.max(0, healthValue.Value - CONFIG.HEALTH_DECREASE_RATE)
            
            -- Handle player death if health reaches 0
            if healthValue.Value <= 0 then
                local character = player.Character
                if character and character:FindFirstChild("Humanoid") then
                    character.Humanoid.Health = 0
                end
            end
        end
        
        -- Update client with new values
        statsRemote:FireClient(player, {
            Health = healthValue.Value,
            Hunger = hungerValue.Value,
            Stamina = player.PlayerStats.Stamina.Value
        })
    end
end

-- Function to manage stamina
local function manageStamina(player, staminaValue)
    while player.Parent and player:FindFirstChild("PlayerStats") do
        wait(0.1) -- Small interval for responsive stamina updates
        
        if playerSprinting[player.UserId] then
            -- Decrease stamina while sprinting
            local decreaseAmount = CONFIG.STAMINA_DECREASE_RATE * 0.1 -- Adjust for the wait time
            staminaValue.Value = math.max(0, staminaValue.Value - decreaseAmount)
            
            -- If stamina is depleted, stop sprinting
            if staminaValue.Value <= 0 then
                playerSprinting[player.UserId] = false
                actionRemote:FireClient(player, "StopSprint")
            end
        else
            -- Regenerate stamina when not sprinting
            local regenAmount = CONFIG.STAMINA_REGEN_RATE * 0.1 -- Adjust for the wait time
            staminaValue.Value = math.min(CONFIG.INITIAL_STAMINA, staminaValue.Value + regenAmount)
        end
        
        -- Update client with new stamina value
        statsRemote:FireClient(player, {
            Health = player.PlayerStats.Health.Value,
            Hunger = player.PlayerStats.Hunger.Value,
            Stamina = staminaValue.Value
        })
    end
end

-- Handle player actions
actionRemote.OnServerEvent:Connect(function(player, action, ...)
    local args = {...}
    
    if not player:FindFirstChild("PlayerStats") then return end
    
    if action == "Eat" then
        -- Handle eating food
        local hungerValue = player.PlayerStats:FindFirstChild("Hunger")
        if hungerValue then
            hungerValue.Value = math.min(CONFIG.INITIAL_HUNGER, hungerValue.Value + CONFIG.FOOD_RESTORE_AMOUNT)
            
            -- Update client
            statsRemote:FireClient(player, {
                Health = player.PlayerStats.Health.Value,
                Hunger = hungerValue.Value,
                Stamina = player.PlayerStats.Stamina.Value
            })
        end
    elseif action == "StartSprint" then
        -- Handle sprint start
        local staminaValue = player.PlayerStats:FindFirstChild("Stamina")
        if staminaValue and staminaValue.Value >= CONFIG.STAMINA_MIN_TO_SPRINT then
            playerSprinting[player.UserId] = true
            
            -- Apply sprint effect to character
            local character = player.Character
            if character and character:FindFirstChild("Humanoid") then
                character.Humanoid.WalkSpeed = 24 -- Increased walk speed for sprint
            end
        end
    elseif action == "StopSprint" then
        -- Handle sprint stop
        playerSprinting[player.UserId] = false
        
        -- Reset walk speed
        local character = player.Character
        if character and character:FindFirstChild("Humanoid") then
            character.Humanoid.WalkSpeed = 16 -- Default walk speed
        end
    end
end)

-- Handle player joining
Players.PlayerAdded:Connect(function(player)
    local healthValue, hungerValue, staminaValue = setupPlayerStats(player)
    
    -- Start the management coroutines
    coroutine.wrap(function() manageHunger(player, hungerValue, healthValue) end)()
    coroutine.wrap(function() manageStamina(player, staminaValue) end)()
    
    -- Handle character spawning
    local function onCharacterAdded(character)
        -- Link health value to character's humanoid
        local humanoid = character:WaitForChild("Humanoid")
        
        -- Set initial walk speed
        humanoid.WalkSpeed = 16
        
        -- Reset sprinting state
        playerSprinting[player.UserId] = false
    end
    
    player.CharacterAdded:Connect(onCharacterAdded)
    if player.Character then
        onCharacterAdded(player.Character)
    end
end)

-- Clean up when players leave
Players.PlayerRemoving:Connect(function(player)
    playerSprinting[player.UserId] = nil
end)

Client-Side Implementation

The client script handles user input and displays the user interface:

-- Client Script (place in StarterPlayerScripts)
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")

-- Get our remote events
local remotes = ReplicatedStorage:WaitForChild("Remotes")
local statsRemote = remotes:WaitForChild("StatsUpdate")
local actionRemote = remotes:WaitForChild("PlayerAction")

-- Configuration
local isSprinting = false
local sprintKeyCode = Enum.KeyCode.LeftShift

-- Create the GUI
local function createStatsGUI()
    local screenGui = Instance.new("ScreenGui")
    screenGui.Name = "StatsGUI"
    screenGui.ResetOnSpawn = false
    screenGui.Parent = player:WaitForChild("PlayerGui")
    
    -- Create a frame to hold our stats
    local mainFrame = Instance.new("Frame")
    mainFrame.Name = "StatsFrame"
    mainFrame.Size = UDim2.new(0, 250, 0, 120)
    mainFrame.Position = UDim2.new(0, 20, 0, 20)
    mainFrame.BackgroundTransparency = 0.5
    mainFrame.BackgroundColor3 = Color3.fromRGB(40, 40, 40)
    mainFrame.BorderSizePixel = 2
    mainFrame.BorderColor3 = Color3.fromRGB(0, 0, 0)
    mainFrame.Parent = screenGui
    
    -- Health Bar
    local healthFrame = Instance.new("Frame")
    healthFrame.Name = "HealthFrame"
    healthFrame.Size = UDim2.new(0.9, 0, 0.2, 0)
    healthFrame.Position = UDim2.new(0.05, 0, 0.15, 0)
    healthFrame.BackgroundColor3 = Color3.fromRGB(200, 200, 200)
    healthFrame.BorderSizePixel = 1
    healthFrame.Parent = mainFrame
    
    local healthBar = Instance.new("Frame")
    healthBar.Name = "HealthBar"
    healthBar.Size = UDim2.new(1, 0, 1, 0)
    healthBar.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
    healthBar.BorderSizePixel = 0
    healthBar.Parent = healthFrame
    
    local healthLabel = Instance.new("TextLabel")
    healthLabel.Name = "HealthLabel"
    healthLabel.Size = UDim2.new(0, 70, 0, 20)
    healthLabel.Position = UDim2.new(0.5, -35, -0.8, 0)
    healthLabel.Text = "Health"
    healthLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    healthLabel.BackgroundTransparency = 1
    healthLabel.Font = Enum.Font.SourceSansBold
    healthLabel.TextSize = 16
    healthLabel.Parent = healthFrame
    
    -- Hunger Bar
    local hungerFrame = Instance.new("Frame")
    hungerFrame.Name = "HungerFrame"
    hungerFrame.Size = UDim2.new(0.9, 0, 0.2, 0)
    hungerFrame.Position = UDim2.new(0.05, 0, 0.45, 0)
    hungerFrame.BackgroundColor3 = Color3.fromRGB(200, 200, 200)
    hungerFrame.BorderSizePixel = 1
    hungerFrame.Parent = mainFrame
    
    local hungerBar = Instance.new("Frame")
    hungerBar.Name = "HungerBar"
    hungerBar.Size = UDim2.new(1, 0, 1, 0)
    hungerBar.BackgroundColor3 = Color3.fromRGB(255, 150, 0)
    hungerBar.BorderSizePixel = 0
    hungerBar.Parent = hungerFrame
    
    local hungerLabel = Instance.new("TextLabel")
    hungerLabel.Name = "HungerLabel"
    hungerLabel.Size = UDim2.new(0, 70, 0, 20)
    hungerLabel.Position = UDim2.new(0.5, -35, -0.8, 0)
    hungerLabel.Text = "Hunger"
    hungerLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    hungerLabel.BackgroundTransparency = 1
    hungerLabel.Font = Enum.Font.SourceSansBold
    hungerLabel.TextSize = 16
    hungerLabel.Parent = hungerFrame
    
    -- Stamina Bar
    local staminaFrame = Instance.new("Frame")
    staminaFrame.Name = "StaminaFrame"
    staminaFrame.Size = UDim2.new(0.9, 0, 0.2, 0)
    staminaFrame.Position = UDim2.new(0.05, 0, 0.75, 0)
    staminaFrame.BackgroundColor3 = Color3.fromRGB(200, 200, 200)
    staminaFrame.BorderSizePixel = 1
    staminaFrame.Parent = mainFrame
    
    local staminaBar = Instance.new("Frame")
    staminaBar.Name = "StaminaBar"
    staminaBar.Size = UDim2.new(1, 0, 1, 0)
    staminaBar.BackgroundColor3 = Color3.fromRGB(0, 150, 255)
    staminaBar.BorderSizePixel = 0
    staminaBar.Parent = staminaFrame
    
    local staminaLabel = Instance.new("TextLabel")
    staminaLabel.Name = "StaminaLabel"
    staminaLabel.Size = UDim2.new(0, 70, 0, 20)
    staminaLabel.Position = UDim2.new(0.5, -35, -0.8, 0)
    staminaLabel.Text = "Stamina"
    staminaLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    staminaLabel.BackgroundTransparency = 1
    staminaLabel.Font = Enum.Font.SourceSansBold
    staminaLabel.TextSize = 16
    staminaLabel.Parent = staminaFrame
    
    return {
        HealthBar = healthBar,
        HungerBar = hungerBar,
        StaminaBar = staminaBar
    }
end

-- Create the GUI elements
local statsBars = createStatsGUI()

-- Function to update the GUI based on stats
local function updateStatsGUI(stats)
    -- Create smooth transitions with tweens
    local tweenInfo = TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
    
    -- Update health bar
    local healthTween = TweenService:Create(statsBars.HealthBar, tweenInfo, {
        Size = UDim2.new(stats.Health / 100, 0, 1, 0)
    })
    healthTween:Play()
    
    -- Update hunger bar
    local hungerTween = TweenService:Create(statsBars.HungerBar, tweenInfo, {
        Size = UDim2.new(stats.Hunger / 100, 0, 1, 0)
    })
    hungerTween:Play()
    
    -- Update stamina bar
    local staminaTween = TweenService:Create(statsBars.StaminaBar, tweenInfo, {
        Size = UDim2.new(stats.Stamina / 100, 0, 1, 0)
    })
    staminaTween:Play()
    
    -- Update colors based on values
    -- Health color (green to yellow to red)
    if stats.Health > 50 then
        statsBars.HealthBar.BackgroundColor3 = Color3.fromRGB(
            255, 
            255 - (stats.Health - 50) * 5.1, 
            0
        )
    else
        statsBars.HealthBar.BackgroundColor3 = Color3.fromRGB(
            255, 
            stats.Health * 5.1, 
            0
        )
    end
end

-- Listen for stat updates from the server
statsRemote.OnClientEvent:Connect(function(stats)
    updateStatsGUI(stats)
end)

-- Handle sprint input
local function handleSprintInput(input, gameProcessed)
    if gameProcessed then return end
    
    if input.KeyCode == sprintKeyCode then
        if input.UserInputState == Enum.UserInputState.Begin then
            isSprinting = true
            actionRemote:FireServer("StartSprint")
        elseif input.UserInputState == Enum.UserInputState.End then
            isSprinting = false
            actionRemote:FireServer("StopSprint")
        end
    end
end

-- Listen for remote actions from server
actionRemote.OnClientEvent:Connect(function(action)
    if action == "StopSprint" then
        isSprinting = false
    end
end)

-- Connect input handling
UserInputService.InputBegan:Connect(handleSprintInput)
UserInputService.InputEnded:Connect(handleSprintInput)

-- Handle character respawning
player.CharacterAdded:Connect(function(newCharacter)
    character = newCharacter
    humanoid = character:WaitForChild("Humanoid")
    
    -- Reset sprint state
    isSprinting = false
end)

-- Example food item handling
local function createFoodToolExample()
    local tool = Instance.new("Tool")
    tool.Name = "Apple"
    tool.RequiresHandle = true
    tool.Parent = player.Backpack
    
    local handle = Instance.new("Part")
    handle.Name = "Handle"
    handle.Size = Vector3.new(1, 1, 1)
    handle.BrickColor = BrickColor.new("Bright red")
    handle.Parent = tool
    
    -- Add a mesh to make it look like an apple
    local mesh = Instance.new("SpecialMesh")
    mesh.MeshType = Enum.MeshType.Sphere
    mesh.Scale = Vector3.new(0.7, 0.8, 0.7)
    mesh.Parent = handle
    
    -- When the tool is activated (clicked), eat the food
    tool.Activated:Connect(function()
        actionRemote:FireServer("Eat")
        
        -- Optional: destroy the tool after use
        tool:Destroy()
    end)
end

-- Create a food item for testing
createFoodToolExample()

Visual Enhancements: Radar Chart Comparison

Below is a radar chart comparing the impact of different activities on player stats. This can help you understand how to balance your game mechanics:

This radar chart illustrates how different player states affect various gameplay aspects. When players are well-fed and rested, they perform optimally across all metrics. However, as their stats decline, different aspects of gameplay are affected at different rates.

Gameplay Impact and Balancing

When implementing health, hunger, and stamina systems, it's important to balance them for optimal gameplay. Here's a table showing how different values impact gameplay:

System Mindmap

Below is a mindmap showing how these three systems interact with each other and with other game mechanics:

This mindmap illustrates the interconnected nature of health, hunger, and stamina systems and their integration with other game mechanics. Each system impacts the others, creating a dynamic gameplay experience.

Video Tutorial

Below is a helpful video tutorial that demonstrates how to implement a hunger bar system in Roblox. This covers many of the same concepts we've discussed in our code:

This tutorial by CovertCode walks you through creating a hunger system in Roblox, which can be extended to include health and stamina as well. It covers the basics of creating the GUI elements and handling the server-side logic necessary for a secure implementation.

Visual Examples

Here are some examples of health, hunger, and stamina bar UI designs that can be implemented in your game:

Example of a health and stamina UI design with a circular layout.

A traditional horizontal stamina bar implementation in Roblox Studio.

Screenshot from a tutorial showing a hunger bar implementation.

Advanced Implementation Considerations

Data Persistence

To save player stats between game sessions, implement data storage:

-- Add this to your server script
local DataStoreService = game:GetService("DataStoreService")
local playerStatsStore = DataStoreService:GetDataStore("PlayerStats")

-- When player joins
local function loadPlayerData(player)
    local success, playerData = pcall(function()
        return playerStatsStore:GetAsync(player.UserId)
    end)
    
    if success and playerData then
        -- Player has existing data
        player.PlayerStats.Health.Value = playerData.Health
        player.PlayerStats.Hunger.Value = playerData.Hunger
        player.PlayerStats.Stamina.Value = playerData.Stamina
    end
end

-- When player leaves
local function savePlayerData(player)
    if player:FindFirstChild("PlayerStats") then
        local dataToSave = {
            Health = player.PlayerStats.Health.Value,
            Hunger = player.PlayerStats.Hunger.Value,
            Stamina = player.PlayerStats.Stamina.Value
        }
        
        pcall(function()
            playerStatsStore:SetAsync(player.UserId, dataToSave)
        end)
    end
end

Players.PlayerAdded:Connect(loadPlayerData)
Players.PlayerRemoving:Connect(savePlayerData)

-- Also save periodically
while wait(60) do -- Save every minute
    for _, player in ipairs(Players:GetPlayers()) do
        savePlayerData(player)
    end
end

Events and Effects

You can create special events that affect player stats:

-- Example of a weather effect
local function simulateRainStorm()
    -- Broadcast to all players
    for _, player in ipairs(Players:GetPlayers()) do
        -- Increase hunger depletion during storm
        local hungerValue = player.PlayerStats:FindFirstChild("Hunger")
        if hungerValue then
            hungerValue.Value = math.max(0, hungerValue.Value - 5)
        end
        
        -- Notify player
        statsRemote:FireClient(player, {
            Health = player.PlayerStats.Health.Value,
            Hunger = hungerValue.Value,
            Stamina = player.PlayerStats.Stamina.Value,
            Message = "A cold rain is falling. You feel hungrier."
        })
    end
end

-- Call this function periodically or based on game events

Frequently Asked Questions

-- Add this to your client script
local function updateVisualEffects(stats)
    local effectsGui = player:WaitForChild("PlayerGui"):FindFirstChild("EffectsGui") or Instance.new("ScreenGui")
    effectsGui.Name = "EffectsGui"
    effectsGui.ResetOnSpawn = false
    effectsGui.Parent = player.PlayerGui
    
    -- Health vignette effect
    local vignette = effectsGui:FindFirstChild("Vignette") or Instance.new("Frame")
    vignette.Name = "Vignette"
    vignette.Size = UDim2.new(1, 0, 1, 0)
    vignette.BorderSizePixel = 0
    vignette.BackgroundTransparency = 0.5
    vignette.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
    vignette.Visible = false
    vignette.Parent = effectsGui
    
    -- Show vignette when health is low
    if stats.Health < 30 then
        vignette.Visible = true
        vignette.BackgroundTransparency = 0.8 - ((30 - stats.Health) / 100)
    else
        vignette.Visible = false
    end
end

-- Call this function whenever stats update
statsRemote.OnClientEvent:Connect(function(stats)
    updateStatsGUI(stats)
    updateVisualEffects(stats)
end)

-- Add this to your server script
local statusEffects = {}

-- Apply a status effect to a player
local function applyStatusEffect(player, effectType, duration)
    -- Create or get player's status effect table
    if not statusEffects[player.UserId] then
        statusEffects[player.UserId] = {}
    end
    
    -- Add the effect
    statusEffects[player.UserId][effectType] = {
        EndTime = tick() + duration,
        Applied = false
    }
    
    -- Notify client
    statsRemote:FireClient(player, {
        Health = player.PlayerStats.Health.Value,
        Hunger = player.PlayerStats.Hunger.Value,
        Stamina = player.PlayerStats.Stamina.Value,
        StatusEffect = effectType
    })
end

-- Process status effects
spawn(function()
    while wait(1) do
        for userId, effects in pairs(statusEffects) do
            local player = Players:GetPlayerByUserId(userId)
            if player then
                for effectType, effectData in pairs(effects) do
                    -- Check if effect has expired
                    if tick() > effectData.EndTime then
                        effects[effectType] = nil
                        
                        -- Notify client
                        statsRemote:FireClient(player, {
                            Health = player.PlayerStats.Health.Value,
                            Hunger = player.PlayerStats.Hunger.Value,
                            Stamina = player.PlayerStats.Stamina.Value,
                            StatusEffectRemoved = effectType
                        })
                    else
                        -- Apply effect logic
                        if effectType == "Poisoned" then
                            -- Decrease health slowly
                            player.PlayerStats.Health.Value = math.max(0, player.PlayerStats.Health.Value - 1)
                        elseif effectType == "Exhausted" then
                            -- Prevent stamina regeneration
                            -- This is handled in the stamina management function
                        end
                    end
                end
            end
        end
    end
end)

-- Add status effect checks in your other functions
local function manageStamina(player, staminaValue)
    while player.Parent and player:FindFirstChild("PlayerStats") do
        wait(0.1)
        
        if playerSprinting[player.UserId] then
            -- Decrease stamina while sprinting
            local decreaseAmount = CONFIG.STAMINA_DECREASE_RATE * 0.1
            staminaValue.Value = math.max(0, staminaValue.Value - decreaseAmount)
        else
            -- Check for exhaustion effect before regenerating
            local playerEffects = statusEffects[player.UserId]
            local exhausted = playerEffects and playerEffects["Exhausted"]
            
            if not exhausted then
                -- Normal regeneration
                local regenAmount = CONFIG.STAMINA_REGEN_RATE * 0.1
                staminaValue.Value = math.min(CONFIG.INITIAL_STAMINA, staminaValue.Value + regenAmount)
            end
        end
        
        -- Update client
        statsRemote:FireClient(player, {
            Health = player.PlayerStats.Health.Value,
            Hunger = player.PlayerStats.Hunger.Value,
            Stamina = staminaValue.Value
        })
    end
end

References

• How to Create an RPG Hunger System - Roblox Developer Forum
• How to Make a Secure Hunger/Thirst System - Roblox Developer Forum
• How to Make a Stamina Bar That Works With My Sprint Script - Roblox Developer Forum
• Making a Stamina System - Roblox Developer Forum
• How to Make an Advanced Health Bar - Roblox Developer Forum
• Humanoid.Health - Roblox Developer Documentation
• How Can I Script a Hunger/Thirst System for a Survival Game - Scripting Helpers

Recommended

How to implement custom animations in Roblox for player actions like eating and drinking

Creating a day-night cycle in Roblox that affects player stats and game mechanics

Building an inventory system in Roblox that integrates with health and hunger mechanics

How to create status effects like poisoned, frozen, or exhausted in Roblox games

devforum.roblox.com

How can I make a stamina bar that works with my sprint script? ...

devforum.roblox.com

How to create a RPG Hunger System - Community Tutorials - Developer ...

devforum.roblox.com

How to give a model health? - Scripting Support - Roblox

devforum.roblox.com

Limb health system - Scripting Support - Developer Forum | Roblox

github.com

Roblox/Health-Bar-3D/Health-Bar-3D.lua at master - GitHub

devforum.roblox.com

Am I doing a hunger and thirst system right? - Scripting Support ...

github.com

Anomic-Stuff/Inf Stamina.lua at main - GitHub

codepal.ai

Lua Function: Character Stats - CodePal

github.com

Core-Scripts/CoreScriptsRoot/CoreScripts/HealthScript.lua at master · Roblox/Core-Scripts

devforum.roblox.com

Stamina System Script Help - Scripting Support - Developer Forum ...

devforum.roblox.com

Making a stamina system - Scripting Support - Developer Forum | Roblox

reddit.com

Infinite stamina script and anti damage for a dusty trip - Reddit

devforum.roblox.com

Custom health regeneration script - Community Tutorials - Roblox

create.roblox.com

Humanoid.Health | Documentation - Roblox Creator Hub

codepal.ai

Lua Stamina System for Roblox - CodePal

devforum.roblox.com

How to make own health system - Developer Forum | Roblox

devforum.roblox.com

How would you make a *secure* hunger/thirst system? - Scripting ...

codepal.ai

Create a Health Bar System in Lua for Roblox - CodePal

github.com

roblox-scripts-public/health regen script.lua at main - GitHub

devforum.roblox.com

Stamina system code issues - Scripting Support - Developer Forum | Roblox

stackoverflow.com

Lua Roblox How to set spicific players health to 0 - Stack Overflow

devforum.roblox.com

Simple Health - A more efficient alternative to the default ... - Roblox

scriptinghelpers.org

How can I script a Hunger/Thirst/Temperature and Inventory System for a Survival game? [closed] - Scripting Helpers

devforum.roblox.com

Creating a hunger bar throws an error - Scripting Support - Developer ...

devforum.roblox.com

Changing health of person - Scripting Support - Developer Forum

devforum.roblox.com

Help with Stamina Script - Scripting Support - Developer Forum ...

devforum.roblox.com

Stamina server handling - Scripting Support - Developer Forum

create.roblox.com

Create a health pickup | Documentation - Roblox Creator Hub

reddit.com

Energy, hygiene, health, and hunger bar : r/robloxgamedev - Reddit

worldof-pcgames.net

The New Frontier Inf Stamina Inf Warmth Inf Hunger Insta Interact ...

devforum.roblox.com

Best place to create a script for player hunger/thirst management?

devforum.roblox.com

How to get stamina script to work - Scripting Support - Developer ...

devforum.roblox.com

What is the best approach to making a player statistics / health system

devforum.roblox.com

How do I make an exploiter-proof custom health system?

devforum.roblox.com

Roblox Thirst System - Scripting Support - Developer Forum