Config

General Information

Additional Settings
If there is a feature within the script that you can't find in the script's config, there is a chance that the configuration lies within zyke-lib.

Keymapping
When stated to utilize keymapping, the key can be changed in your GTA / FiveM keybinds.

Prop Models
All prop models can be found here.

#Settings

Groups the main configuration options for this resource. The child sections below document each nested setting.

#debug

Controls debug logging for the resource. When set to true, additional diagnostic output is enabled.

Example:

debug = false

#helpMenu

A table of command strings that open the help menu. The source comment describes this menu as the command for getting players started.

Example:

helpMenu = {"consum:help"}

#promptHelpMenuOnFirstUse

When enabled, the help menu automatically opens the first time a player uses any consumable item. This helps introduce new players to the resource's mechanics. The menu only appears once per player; subsequent uses will not trigger it.

Example:

promptHelpMenuOnFirstUse = true

#pickupDistance

Maximum distance from which a player can pick up a placed item.

Example:

pickupDistance = 1.0

#placeDistance

Maximum distance at which a player can place an item.

Example:

placeDistance = 1.0

#transferDistance

Distance used when transferring items to other players.

Example:

transferDistance = 1.3

#objectInteractionDistance

Distance used to interact with world items, such as pouring a consumable into a glass.

Example:

objectInteractionDistance = 1.0

#itemCloseDistance

The distance threshold used to determine if the player is very close to an item, triggering a quick iteration check for that item.

Example:

itemCloseDistance = 10.0

#itemVicinityDistance

The rough scan distance used to find items in the vicinity.

Example:

itemVicinityDistance = 300.0

#pauseConsumptionOnAnimBreak

Controls whether consumption pauses during an animation break. When disabled, consumption continues despite the animation pause; the source comment also notes that sound playback is tied to the animation and that the choking meter decreases when this setting is true.

Example:

pauseConsumptionOnAnimBreak = true

#forcePropsOnGround

Controls whether placed props are always forced onto a solid surface. The source warns this can cause placement issues on non-solid props; when disabled, items can be placed anywhere.

Example:

forcePropsOnGround = false

#objectPlacementThreshold

Additional object-placement distance threshold used to space placed objects apart.

Example:

objectPlacementThreshold = 0.075

#triggeredTargetSystem

A list of configured target-system command strings. The default entries are "+ox_target" and "+playerTarget".

Example:

triggeredTargetSystem = { "+ox_target", "+playerTarget"}

#fetchOxConversions

Controls whether possible conversions are fetched from ox_inventory.

Example:

fetchOxConversions = true

#worldItems

Controls world item mode, per-player and server-wide item limits, and cleanup behavior for placed world items. The source comments warn that FiveM networked prop restrictions limit dynamic world items to 80 rendered networked objects per client shared across scripts, and recommend static mode for servers with 50+ players, big parties, or many restaurants.

• dynamic: selects dynamic or static world item mode.
• maxPerPlayer: caps how many world items one player can have.
• limit: caps stored world items server-wide, not spawned props.
• cleanup: groups proximity, thread-deletion, and start-up cleanup settings.

Example:

worldItems = {
    dynamic = false,
    maxPerPlayer = 50,
    limit = 3000,
    cleanup = { ... },
}

#worldItems.dynamic

dynamic selects whether world items use dynamic or static mode.

Example:

dynamic = false

#worldItems.maxPerPlayer

maxPerPlayer sets the maximum number of world items a single player can have.

Example:

maxPerPlayer = 50

#worldItems.limit

Maximum number of world items tracked on the server. The source comment notes this is a server limit for stored world items, not the number of spawned props.

Example:

limit = 3000

#worldItems.cleanup

Controls cleanup timing for world items. The source comments explain that last_interaction is updated when world item data changes and by proximity checks; cleanup settings use that timestamp.

• proximity: refreshes last_interaction for nearby world items without deleting them.
• threadDeletion: deletes world items older than the configured lifetime on an interval.
• onStart: deletes world items on script start when they are older than the configured lifetime.

Example:

cleanup = {
    proximity = { ... },
    threadDeletion = { ... },
    onStart = { ... },
}

#worldItems.cleanup.proximity

Proximity will check the proximity of the world item, if any player is within the configured area, we update last_interaction. This is only responsible for updating the last_interaction, not for deleting the item. This setting is meant to allow you placing items around yourself, such as in a bar, that won't disappear if you leave the area for a while, since when you come back it refreshes the timer.

Example:

proximity = {
    enabled = true,
    distance = 30.0,
    interval = 120, -- Seconds
}

#worldItems.cleanup.proximity.enabled

enabled turns on proximity checks that update last_interaction when a player is within the configured distance. This setting does not delete items.

Example:

enabled = true

#worldItems.cleanup.proximity.distance

The distance value sets the proximity check radius.

Example:

distance = 30.0

#worldItems.cleanup.proximity.interval

The interval value sets the number of seconds between proximity checks.

Example:

interval = 120

#worldItems.cleanup.threadDeletion

Controls the background thread that manages world item lifetime. The source comments state that it works with proximity because proximity updates last_interaction, and that items older than the configured lifetime are deleted when the interval passes.

• enabled: controls whether the background lifetime-management thread is active.
• interval: sets the number of seconds between deletion checks.
• lifetime: sets how old last_interaction can be before an item is deleted.

Example:

threadDeletion = {
    enabled = false,
    interval = 60, -- Seconds
    lifetime = 172800, -- Seconds
}

#worldItems.cleanup.threadDeletion.enabled

enabled controls whether the background world item lifetime thread runs.

Example:

enabled = false

#worldItems.cleanup.threadDeletion.interval

The interval in seconds between each cleanup cycle. The thread checks all active world items against the configured lifetime and removes any that have expired.

Example:

interval = 60

#worldItems.cleanup.threadDeletion.lifetime

The lifetime value sets the number of seconds after last_interaction before a world item is old enough for thread-based deletion.

Example:

lifetime = 172800

#worldItems.cleanup.onStart

Controls the cleanup check performed when the script starts. The source comments state that world items are deleted on start when their last_interaction value is older than the configured lifetime.

• enabled: controls whether the startup cleanup check runs.
• lifetime: sets the age threshold used by the startup cleanup check.

Example:

onStart = {
    enabled = true,
    lifetime = 172800, -- Seconds
}

#worldItems.cleanup.onStart.enabled

enabled controls whether the script-start world item cleanup check runs. The source comments say world items older than the configured time are deleted.

Example:

enabled = true

#worldItems.cleanup.onStart.lifetime

The lifetime value sets the maximum age, in seconds, checked on script start. If a world item's last_interaction is older than this value, the source comments say it is deleted.

Example:

lifetime = 172800

#defaultProp

Groups the nested defaultProp options. The child sections below document each setting.

Example:

defaultProp = {
    model = "prop_paper_bag_small", -- Default prop for placement when no prop is set
    bone = 18905, -- Default bone for placement when no bone is set (SKEL_L_Hand)
    offset = vec(0.0, 0.0, 0.0), -- Default prop offset for placement when no prop offset is set
    rotation = vec(0.0, 0.0, 0.0), -- Default prop rotation for placement when no prop rotation is set
}

#defaultProp.model

Default prop model used for placement when no prop model is set.

Example:

model = "prop_paper_bag_small"

#defaultProp.bone

Default placement bone used when no bone is set. The source comment identifies this default as SKEL_L_Hand.

Example:

bone = 18905

#defaultProp.offset

Default prop offset vector for placement when no prop offset is set.

Example:

offset = vec(0.0, 0.0, 0.0)

#defaultProp.rotation

Default prop rotation vector for placement when no prop rotation is set.

Example:

rotation = vec(0.0, 0.0, 0.0)

#infiniteItems

With infinite items, you can create any item based on its type. This functionality is only available in modern inventories. Note that managing these items outside of our resources may be challenging unless you are experienced. Enabling this does not restrict the finite items from being created or used.

Example:

infiniteItems = {
    enabled = false, -- You can enable if using ox_inventory
    baseItemPrefix = "base_", -- type is appended, ex. "base_drink"
    defaultImage = "https://r2.fivemanage.com/mS9apQyi6ahmBBRtVnQAv/image/question_mark.png", -- In case no image exists, default to this
}

#infiniteItems.enabled

Controls whether infinite items are enabled. The source comment notes this can be enabled when using ox_inventory.

Example:

enabled = false

#infiniteItems.baseItemPrefix

Prefix used when forming base item names for infinite items. The source comment says the item type is appended, for example "base_drink".

Example:

baseItemPrefix = "base_"

#infiniteItems.defaultImage

Fallback image URL used when no image exists for an infinite item.

Example:

defaultImage = "https://r2.fivemanage.com/mS9apQyi6ahmBBRtVnQAv/image/question_mark.png"

#keys

Defines a keyed collection of keys entries. The child sections below document the fields available for each entry.

Example:

keys = {
    ["use"] = {key = "E", keyType = "keyboard"},
    ...
}

#keys[x].key

The keyboard key assigned to this action. It is used together with keyType to register the full keybind for the action.

Example:

key = "E"

#keys[x].keyType

The input device type for this key binding, such as "keyboard".

Example:

keyType = "keyboard"

#throwing

Groups the nested throwing options. The child sections below document each setting.

Example:

throwing = {
    enabled = true,
    power = 25.0, -- 20 if you want it super realistic
    mass = 300.0, -- ~50 if you want it super realistic
}

#throwing.enabled

enabled controls whether item throwing is enabled.

Example:

enabled = true

#throwing.power

Controls the force applied to thrown items. Higher values result in faster throw speeds. The source comment suggests setting to 20.0 for a more realistic feel.

Example:

power = 25.0

#throwing.mass

The mass value configures item throwing mass. The source comment notes ~50 for a more realistic feel; the default value is 300.0.

Example:

mass = 300.0

#itemTypes

Defines a keyed collection of itemTypes entries. The child sections below document the fields available for each entry.

Example:

itemTypes = {
    ["drink"] = {
        label = "Drink",
        -- This multiplies how fast you consume a category
        -- The base values are rather realistic and slow, you can speed them up if you want to, this only affects how fast you consume it
        consumptionSpeed = 50.0,
    },
    ...
}

#itemTypes[x].label

A human-readable name for this item type, displayed in menus and notifications. This label helps administrators and players identify the category of consumable items.

Example:

label = "Drink"

#itemTypes[x].consumptionSpeed

A multiplier that controls how quickly an item in this category is consumed. The base consumption speeds are designed to be realistic and slow; increasing this value speeds up consumption for the entire category.

Example:

consumptionSpeed = 50.0

#consumptionTick

The interval in milliseconds at which the resource processes consumption effects. Lower values provide more responsive status updates but increase performance usage; higher values feel sluggish but reduce overhead. A range of 250-500 is recommended. This value does not affect core functionality, only the display and processing frequency.

Example:

consumptionTick = 250

#creatorMenu

Groups the nested creatorMenu options. The child sections below document each setting.

Example:

creatorMenu = {
    command = {"consum:creator", "consum:ic"},
    permissions = {
        useMenu = "command", -- Lock to staffs
        createItem = "command", -- Lock to staffs
        ...
    }
}

#creatorMenu.command

The chat commands that open the item creator menu. When a player types one of these commands, the resource checks their permissions and opens the creator interface if they have access.

Example:

command = {"consum:creator", "consum:ic"}

#creatorMenu.permissions

Groups the nested permissions options. The child sections below document each setting.

Example:

permissions = {
    useMenu = "command", -- Lock to staffs
    createItem = "command", -- Lock to staffs
    editItem = "command", -- Lock to trusted people
    deleteItem = "command", -- Lock to trusted people
}

#creatorMenu.permissions.useMenu

Specifies the permission string required to access the creator menu. The value "command" corresponds to an ace permission that restricts use to staff members (as noted in the source comment "Lock to staffs"). Players without this permission will be denied access to the menu.

Example:

useMenu = "command"

#creatorMenu.permissions.createItem

The permission string required to create items through the creator menu. Players must have this permission to access the item creation functionality. The inline comment indicates this is intended to restrict creation to staff members.

Example:

createItem = "command"

#creatorMenu.permissions.editItem

Permission identifier required to edit an existing item through the creator menu. The source marks this action as locked to trusted people, with the default permission value set to "command".

Example:

editItem = "command"

#creatorMenu.permissions.deleteItem

The permission level required to delete items through the creator menu. Set to "command" to restrict deletion to trusted people.

Example:

deleteItem = "command"

#creatorMenu.itemsPerPage

Controls how many items are displayed per page in the creator menu. The source comment recommends leaving this value unchanged unless you need a different page size.

Example:

itemsPerPage = 24

#importMenu

Groups the nested importMenu options. The child sections below document each setting.

Example:

importMenu = {
    command = {"consum:import"},
    permission = "command",
    activateBatchCommand = "consum:activate_batch",
    activateBatchPermission = "command",
}

#importMenu.command

The chat command that opens the item import menu. The resource checks the player's permission (see importMenu.permission) and presents the import interface.

Example:

command = {"consum:import"}

#importMenu.permission

The permission required to use the import menu. This is checked before allowing a player to import items from raw text input. The default value "command" refers to a permission defined elsewhere in the configuration.

Example:

permission = "command"

#importMenu.activateBatchCommand

The command string configured for activating an import batch.

Example:

activateBatchCommand = "consum:activate_batch"

#importMenu.activateBatchPermission

The permission required to activate a batch of imported items. This permission is checked when a player runs the batch activation command, and players without it receive a "no permission" notification.

Example:

activateBatchPermission = "command"

#ingredientMenu

Groups the nested ingredientMenu options. The child sections below document each setting.

Example:

ingredientMenu = {
    command = {"consum:ingredient"},
    permission = {
        useMenu = "command", -- Lock to staffs
        createIngredient = "command", -- Lock to staffs
        ...
    }
}

#ingredientMenu.command

Defines the chat command(s) that open the ingredient menu.

Example:

command = {"consum:ingredient"}

#ingredientMenu.permission

Groups the nested permission options. The child sections below document each setting.

Example:

permission = {
    useMenu = "command", -- Lock to staffs
    createIngredient = "command", -- Lock to staffs
    editIngredient = "command", -- Lock to trusted people
    deleteIngredient = "command", -- Lock to trusted people
}

#ingredientMenu.permission.useMenu

The permission required to open the ingredient menu. Set to "command" to restrict access to staff members.

Example:

useMenu = "command"

#ingredientMenu.permission.createIngredient

Permission identifier required to create an ingredient. The source marks this action as locked to staff members, with the default permission value set to "command".

Example:

createIngredient = "command"

#ingredientMenu.permission.editIngredient

Permission identifier required to edit an existing ingredient. The source marks this action as locked to trusted people, with the default permission value set to "command".

Example:

editIngredient = "command"

#ingredientMenu.permission.deleteIngredient

The permission required to delete an ingredient from the menu. Set this to a permission string to restrict deletion to trusted players.

Example:

deleteIngredient = "command"

#ingredientMenu.itemsPerPage

Controls how many ingredient items are displayed per page in the ingredient selection menu. The inline comment recommends against changing this value.

Example:

itemsPerPage = 24

#whitelistedItems

Groups the nested whitelistedItems options. The child sections below document each setting.

Example:

whitelistedItems = {
    command = {"consum:witems"},
    permission = {
        useMenu = "command", -- Lock to developers
    },
}

#whitelistedItems.command

The chat command(s) that open the whitelisted items management menu. Each entry in this table is a command string that players can type to trigger the menu.

Example:

command = {"consum:witems"}

#whitelistedItems.permission

Groups the nested permission options. The child sections below document each setting.

Example:

permission = {
    useMenu = "command", -- Lock to developers
}

#whitelistedItems.permission.useMenu

The permission identifier required to access the whitelisted items management menu. The default value "command" locks this menu to developers.

Example:

useMenu = "command"

#allowedJobs

Defines the jobs allowed to make usable items. Each entry identifies an allowed job and the minimum grade required.

Example:

allowedJobs = {
    {label = "Police", name = "police", minGrade = 1},
    ...
}

#allowedJobs[x].label

Human-readable label for this allowed job entry, such as "Police". Use it to identify the job entry alongside its job name and minGrade.

Example:

label = "Police"

#allowedJobs[x].name

Job name for this allowed job entry.

Example:

name = "police"

#allowedJobs[x].minGrade

The minimum job grade required for this job entry to have access. Players must hold at least this grade level in the specified job to use the resource's features.

Example:

minGrade = 1

#qualityLabels

Defines quality label identifiers for numeric quality thresholds. A quality value must be equal to or above a threshold to use that label; use locale entries prefixed with quality:, and the last label covers the remaining lower values.

Example:

qualityLabels = {
    -- Quality labels to display your quality in a user-friendly manner
    -- The quality has to be equal to or above the number to be recognized as such
    -- You can freely add more in here along with translations in your locale file, it will automatically detect it, don't forget to prefix your translation with "quality:"
    -- Note that the last quality in this list will be spread across the rest of the bottom ones to avoid non-existent translations
    ...
}

#qualityLabels.90

Maps quality threshold 90 to the label "very_high".

Example:

[90] = "very_high"

#qualityLabels.80

Maps quality threshold 80 to the label "good".

Example:

[80] = "good"

#qualityLabels.70

Maps quality threshold 70 to the label "okay".

Example:

[70] = "okay"

#qualityLabels.50

Maps quality threshold 50 to the label "bad".

Example:

[50] = "bad"

#qualityLabels.40

Maps quality threshold 40 to the label "terrible".

Example:

[40] = "terrible"

#qualityLabels.30

Maps quality threshold 30 to the label "moldy".

Example:

[30] = "moldy"

#discardBelowQuality

Items with a quality value below this threshold are automatically discarded when interacting with a trash can.

Example:

discardBelowQuality = 30

#qualityDisplay

Controls how quality information is displayed for items and ingredients. The child settings choose whether to display an average quality value and whether to label each ingredient's quality.

Example:

qualityDisplay = {
    displayAverage = true, -- Average for ingredients, or the entire item if not ingredient-based
    displayIngredient = true -- Specifically labeling each ingredient's quality
}

#qualityDisplay.displayAverage

Controls whether quality display uses the average quality for ingredient-based items, or the entire item quality when the item is not ingredient-based.

Example:

displayAverage = true

#qualityDisplay.displayIngredient

Controls whether each ingredient's individual quality level is shown in the item description. When set to true, the quality of each ingredient is labeled separately alongside the ingredient name. When false, only the ingredient name is displayed without its quality.

Example:

displayIngredient = true

#qualityDecay

Controls item quality decay over time, including the global enable switch, decay processing timers, and container-specific decay multipliers. The source comments caution that very long or very short timer intervals can create precision or performance problems.

Example:

qualityDecay = {
    -- TLDR: Don't change timers
    -- Note that dealing with long intervals (10+ days to decay 100.0 quality), the calculation when processing will be so small there will be hardware-related computational issues
    -- Unless you know what you are doing, we recommend you do not change the configuration below
    -- We have restrictions in place to avoid these issues, but having intervals running too quickly will just waste performance as we skip the requests
    ...
}

#qualityDecay.enabled

Global switch that enables or disables the quality decay system. When set to false, the resource skips all quality decay processing entirely.

Example:

enabled = true

#qualityDecay.processThreshold

The interval, in seconds, between quality decay processing cycles. The source comments recommend leaving this timer at its default unless you understand the decay timing tradeoff: very low intervals waste processing, while very high intervals can prevent small decay changes from registering reliably.

Example:

processThreshold = 60

#qualityDecay.threadInterval

Controls how often the background thread processes quality decay updates, in seconds. Set to 0 to disable decay processing entirely. The recommended interval is 60 seconds.

Example:

threadInterval = 180

#qualityDecay.containerMultiplier

Maps container types to quality decay multipliers. The default fridge value is 0.3 and the default freezer value is 0.1, matching the source comments for 30% and 10% decay rates.

Example:

containerMultiplier = {
    -- WIP
    ["fridge"] = 0.3, -- 30% decay rate
    ["freezer"] = 0.1, -- 10% decay rate
}

#qualityDecay.containerMultiplier.fridge

Multiplier applied to the quality decay rate for items stored in a fridge container. A value of 0.3 means items decay at 30% of the normal rate, effectively slowing spoilage. This key is a work in progress.

Example:

fridge = 0.3

#qualityDecay.containerMultiplier.freezer

The decay rate multiplier applied to items stored in a freezer container. A value of 0.1 means items decay at 10% of the normal rate, significantly slowing spoilage.

Example:

freezer = 0.1

#sounds

Defines a list of sounds entries. The child sections below document the fields available for each entry.

Example:

sounds = {
    {label = "Eating Normal", file = "eating_normal.ogg"},
    ...
}

#sounds[x].label

A human-readable name for this sound entry.

Example:

label = "Eating Normal"

#sounds[x].file

The filename of the sound file to play. The file should be located in the resource's sound assets directory.

Example:

file = "eating_normal.ogg"

#developmentCommands

Groups developer command settings for this resource. The current child settings configure the clear-world-items developer command and its permission.

Example:

developmentCommands = {
    clearWorldItems = {
        command = {"consum:clear_world"},
        -- The server console can also run this command
        permission = "command", -- Lock to developers
    }
}

#developmentCommands.clearWorldItems

Contains the command and permission settings for the clear-world-items developer command. The source notes that the server console can also run this command.

Example:

clearWorldItems = {
    command = {"consum:clear_world"},
    -- The server console can also run this command
    permission = "command", -- Lock to developers
}

#developmentCommands.clearWorldItems.command

The command string table for the clear-world-items developer action. The default configured command is "consum:clear_world".

Example:

command = {"consum:clear_world"}

#developmentCommands.clearWorldItems.permission

The ACE permission required to run the clear world items command. The server console can also execute this command. When set to "command", the command is locked to developers with the appropriate ACE permission.

Example:

permission = "command"

#consumptionHaste

Controls consumption haste, which lets consumption speed increase through mouse-wheel scrolling up to the configured maximum multiplier. The child settings also configure the related choking mechanics.

Example:

consumptionHaste = {
    enabled = true, -- Enable/disable consumption haste
    max = 2.0, -- Multiplier, 2.0 = 2x consumption speed, one scroll adds 20% of the configured value
    choking = {
        enabled = true, -- Enable/disable choking, most functionality won't work unless you have consumption haste enabled
        ...
    }
}

#consumptionHaste.enabled

enabled toggles the consumption haste feature on or off.

Example:

enabled = true

#consumptionHaste.max

The maximum consumption speed multiplier when haste is active. A value of 2.0 means items are consumed at twice the normal speed. Each scroll of the mouse wheel adds 20% of this configured value toward the player's current haste level.

Example:

max = 2.0

#consumptionHaste.choking

Groups the nested choking options. The child sections below document each setting.

Example:

choking = {
    enabled = true, -- Enable/disable choking, most functionality won't work unless you have consumption haste enabled
    -- Tolerance goes from 0.0-100.0 with one decimal
    -- If you exceed the maxTolerance, you will have a chance of choking
    -- We have blue progressbar at low tolerance, orange when you are at 75% of the max and red when you are at 100% of the max and exceeding it, do some nice lerping maybe? Or only do drastic changes? See what fits
    ...
}

#consumptionHaste.choking.enabled

Toggles the choking mechanic. When enabled, players who exceed the configured tolerance threshold have a chance of choking while consuming items. Most choking-related functionality depends on consumptionHaste being enabled to function correctly.

Example:

enabled = true

#consumptionHaste.choking.maxTolerance

The choke tolerance threshold, using the source-defined 0.0 to 100.0 range with one decimal place. When current tolerance exceeds this value, the player has a chance of choking.

Example:

maxTolerance = 60.0

#consumptionHaste.choking.chokeChance

The percentage chance (0.0-100.0) that the player will choke each second when their consumption haste tolerance exceeds maxTolerance. This check runs once per second.

Example:

chokeChance = 20.0

#consumptionHaste.choking.toleranceDecay

Controls how quickly the choking tolerance value decreases each second when the player is not consuming. A higher number means tolerance drops faster, reducing the risk of choking since tolerance is lower.

Example:

toleranceDecay = 4.0

#consumptionHaste.choking.toleranceDecayDuringConsumption

Controls the rate at which choking tolerance decays while the player is actively consuming. During consumption, tolerance decays at a much slower rate than normal, allowing players to manage tolerance at low speeds while still recovering quickly when consumption stops.

Example:

toleranceDecayDuringConsumption = 1.0

#consumptionHaste.choking.hasteToTolernace

Maps consumption haste levels to the tolerance amount added at each level. The table contains six values for levels 0 through 5, with the first value used for level 0.

Example:

hasteToTolernace = {4.0, 9.0, 14.0, 19.0, 24.0, 29.0}

#consumptionHaste.choking.alertHighRisk

Controls whether a one-time notification is sent when the player exceeds the maxTolerance value for choking. This alert is only triggered once per exceedance event.

Example:

alertHighRisk = true

#consumptionHaste.choking.casualRisk

The percentage chance every second while consuming for the player to choke regardless of current choke tolerance. Set this to 0.0 to disable the casual choking risk.

Example:

casualRisk = 0.1

#consumptionHaste.choking.casualChokeDifficulty

A two-element table defining the minimum and maximum random difficulty threshold for casual choking events. The value is randomly selected between these bounds each time a casual choke occurs. Valid range for each element is 0.1 to 100.0. This represents how much the player must clear before they stop choking, functioning similarly to maxTolerance exceeding but with additional variance since casual choking can occur at any time.

Example:

casualChokeDifficulty = {10.0, 20.0}

#consumptionHaste.choking.chokeRelieveAmount

A two-element table defining the minimum and maximum random amount of choking tolerance removed each time a task is completed. Values range from 0.0 to 100.0. Once the tolerance reaches 0.0, the player is no longer at risk of choking.

Example:

chokeRelieveAmount = {12.0, 50.0}

#consumptionHaste.choking.damagePerSecond

The amount of damage applied each second while the player is choking. This value is used when the player exceeds the choking tolerance threshold and enters the choking state.

Example:

damagePerSecond = 2

#consumptionHaste.choking.chokeToleranceMuiltipliers

A table of client-side functions that are iterated and executed every interval to calculate multipliers that increase the choke risk. Each function returns a multiplier applied to the base chokeTolerance value. For example, if the base tolerance is 5.0 and two functions return 0.2 each, the effective tolerance becomes 5.0 + (5.0 * 0.2) + (5.0 * 0.2) = 6.0. The default functions return 0.5 when the player is running or sprinting, and return the player's stress level from the zyke_status resource divided by 200.0.

Example:

chokeToleranceMuiltipliers = { function() local ply = PlayerPedId() return (IsPedRunning(ply) or IsPedSprinting(ply)) and 0.5 or 0.0 end, function() return exports["zyke_status"]:GetStress() / 200.0 end }

#consumptionHaste.choking.chokeChanceMultipliers

Defines client functions that increase the base choke chance by adding baseChance * returnedMultiplier for each function. It uses the same additive multiplier pattern as the tolerance multiplier table, but applies it to choke chance; for example, the source comment says a stress level of 24.0 applies orgValue + (orgValue * 0.12).

Example:

chokeChanceMultipliers = { function() local ply = PlayerPedId() return (IsPedRunning(ply) or IsPedSprinting(ply)) and 0.5 or 0.0 end, function() return exports["zyke_status"]:GetStress() / 200.0 end }

#consumptionHaste.choking.chokingSound

Groups the nested chokingSound options. The child sections below document each setting.

Example:

chokingSound = {
    volume = 0.2,
    distance = 2.0,
    files = {
        ["male"] = {"cough_m1.wav", "cough_m2.ogg", "cough_m3.ogg", "cough_m4.ogg", "cough_m5.ogg"},
        ...
    }
}

#consumptionHaste.choking.chokingSound.volume

Controls the volume level for the choking sound effect. The default value is 0.2.

Example:

volume = 0.2

#consumptionHaste.choking.chokingSound.distance

Maximum distance at which the choking sound is audible to other players.

Example:

distance = 2.0

#consumptionHaste.choking.chokingSound.files

Groups the nested files options. The child sections below document each setting.

Example:

files = {
    ["male"] = {"cough_m1.wav", "cough_m2.ogg", "cough_m3.ogg", "cough_m4.ogg", "cough_m5.ogg"},
    ["female"] = {"cough_f1.wav", "cough_f2.wav", "cough_f3.wav", "cough_f4.wav", "cough_f5.wav", "cough_f6.wav"},
}

#consumptionHaste.choking.chokingSound.files.male

A table of audio file names used for the male choking sound effect.

Example:

male = {"cough_m1.wav", "cough_m2.ogg", "cough_m3.ogg", "cough_m4.ogg", "cough_m5.ogg"}

#consumptionHaste.choking.chokingSound.files.female

A table of audio file names used for female choking sounds. Each entry is a string referencing a sound file that the resource will play when a female character is choking.

Example:

female = {"cough_f1.wav", "cough_f2.wav", "cough_f3.wav", "cough_f4.wav", "cough_f5.wav", "cough_f6.wav"}

#personalSettings

Groups the nested personalSettings options. The child sections below document each setting.

Example:

personalSettings = {
    command = {"consum:settings"},
    kvp = "consum:settings", -- KVP to store the settings in, has to be unique
    settings = {
        {
            ...
        }
    }
}

#personalSettings.command

The chat command used to open the personal settings menu. This is a table containing a single string value that defines the command players type to access their personal settings interface.

Example:

command = {"consum:settings"}

#personalSettings.kvp

The KVP (key-value pair) storage key used to persist personal settings across sessions. This value must be unique to avoid conflicts with other resources or settings systems.

Example:

kvp = "consum:settings"

#personalSettings.settings

Defines a list of settings entries. The child sections below document the fields available for each entry.

Example:

settings = {
    {
        -- Displays the exact amount left in your item
        -- We allow a default value, this is ensured the first time someone runs our script, and can be changed in the menu
        -- `force` will force the default value, if set to true, the user can't change it in the menu, and will override previous configuration

        name = "displayAmount",
        values = {false, "basic", "contained"}, -- false | "basic" | "contained"
        default = false,
        force = false,
    },
    ...
}

#personalSettings.settings[x].name

The unique identifier for a personal setting entry. This string is used to reference the setting within the settings table.

Example:

name = "displayAmount"

#personalSettings.settings[x].values

Allowed values for this personal setting, such as false, "basic", and "contained".

Example:

values = {false, "basic", "contained"}

#personalSettings.settings[x].default

Initial default value for this personal setting.

Example:

default = false

#personalSettings.settings[x].force

When set to true, this setting's default value is forced and the user cannot change it through the personal settings menu.

Example:

force = false

#pouring

Groups the nested pouring options. The child sections below document each setting.

Example:

pouring = {
    sound = {
        name = "pouring.ogg",
        volume = 0.2,
        distance = 2.0,
    }
}

#pouring.sound

Groups the nested sound options. The child sections below document each setting.

Example:

sound = {
    name = "pouring.ogg",
    volume = 0.2,
    distance = 2.0,
}

#pouring.sound.name

The audio file name for the pouring sound effect. This sound plays when a player is actively pouring liquid from a container.

Example:

name = "pouring.ogg"

#pouring.sound.volume

Controls the volume level of the pouring sound effect. The value is a float between 0.0 (silent) and 1.0 (full volume).

Example:

volume = 0.2

#pouring.sound.distance

Maximum distance from the pouring source at which the sound remains audible.

Example:

distance = 2.0

#colors

Groups the nested colors options. The child sections below document each setting.

Example:

colors = {
    -- All colors are in css format, meaning you can access our css variables that we use for consistency throughout the UI
    -- RGB/RGBA is required
    progressBar = "rgb(var(--blue1))",
    progressBarChoking = "rgb(var(--red2))",
}

#colors.progressBar

Sets the color of the progress bar UI element using CSS format. The value must use rgb() or rgba() syntax and can reference CSS variables defined in the resource's UI for consistent theming.

Example:

progressBar = "rgb(var(--blue1))"

#colors.progressBarChoking

The CSS color value used for the progress bar when the player is choking. Accepts RGB or RGBA format, and supports the resource's CSS variables for UI consistency.

Example:

progressBarChoking = "rgb(var(--red2))"

#packs

Groups pack spawning, permission, placement, cleanup, and admin debug settings. The spawn command is primarily needed when using a generic item; unique items populate the command data automatically.

• spawnCommand: command table used for spawning packs, primarily when using a generic item.
• permission: permission required to use the spawn command.
• genericItem: item name for the generic pack item.
• maxPlacedPerPlayer: maximum number of packs one player can place.
• cleanupInterval: cleanup timing for placed pack props.
• adminDebugPermission: permission for the admin debug target option.

Example:

packs = {
    spawnCommand = {"spawn_pack"},
    permission = "command",
    genericItem = "pack_generic",
    maxPlacedPerPlayer = 10,
    cleanupInterval = 43200,
    adminDebugPermission = "command",
}

#packs.spawnCommand

The chat command used to spawn a pack. When a player runs this command with an item name as the argument, the resource attempts to spawn the corresponding pack. This is primarily useful when using a generic pack item, as unique items already populate the necessary data automatically.

Example:

spawnCommand = {"spawn_pack"}

#packs.permission

The permission identifier required for a player to use the spawn command. Players must have this permission assigned to be able to spawn pack items.

Example:

permission = "command"

#packs.genericItem

The genericItem value is the item name for the generic pack item.

Example:

genericItem = "pack_generic"

#packs.maxPlacedPerPlayer

Maximum number of packs a single player can have placed at one time.

Example:

maxPlacedPerPlayer = 10

#packs.cleanupInterval

The time in seconds after a placed prop's last use before it is automatically cleaned up. The cleanup check runs every minute, and the default value of 43200 corresponds to 12 hours.

Example:

cleanupInterval = 43200

#packs.adminDebugPermission

The permission required to see an "admin debug" option in the target menu. Players holding this permission will have additional debug functionality available when interacting with pack entities.

Example:

adminDebugPermission = "command"