Limits

How Limits Work

Limits control how many claims, chunks, members, and other resources each player can have. Every player starts with the default values defined in config.yml under players.default.

There are two methods to increase limits beyond the defaults. They cannot be used at the same time — you must choose one or the other for your server.

Important: Permission-based limits and command-based limits are mutually exclusive. If you set limits via permissions, do not also use admin commands to set limits, and vice versa. Using both simultaneously will cause unpredictable behavior.

Method 1: Permission-Based Limits

Use permission nodes to set limits per group or player. This is the recommended method for servers using LuckPerms or similar permission plugins, as it integrates naturally with your rank system.

Permission	Description
`scs.limit.claims.<amount>`	Maximum number of claims the player can create
`scs.limit.chunks.<amount>`	Maximum total number of chunks across all claims
`scs.limit.radius.<amount>`	Maximum radius for `/claim radius`
`scs.limit.cost.<amount>`	Cost per chunk (overrides default)
`scs.limit.cost-multiplier.<amount>`	Cost multiplier per additional chunk
`scs.limit.members.<amount>`	Maximum members per claim
`scs.limit.roles.<amount>`	Maximum custom roles per claim
`scs.limit.distance.<amount>`	Minimum distance (in chunks) between this player's claims and other players' claims
`scs.limit.delay.<amount>`	Teleportation delay in seconds for `/claim tp`
`scs.limit.max-claim-price.<amount>`	Maximum chunk cost cap (0 = no limit, displays as infinity)
`scs.limit.auto-default-timer.<seconds>`	Default `/claim auto-X` timer applied when the player omits `[seconds]`. `0` = no timer (legacy behaviour).
`scs.limit.auto-max-timer.<seconds>`	Hard cap on player-supplied `[seconds]` in `/claim auto-X`. `0` = no cap.

Examples with LuckPerms

# Give VIP players 10 claims and 50 chunks
/lp group vip permission set scs.limit.claims.10
/lp group vip permission set scs.limit.chunks.50

# Give MVP players cheaper chunks
/lp group mvp permission set scs.limit.cost.50
/lp group mvp permission set scs.limit.cost-multiplier.1.0

# Give a specific player a larger radius
/lp user Notch permission set scs.limit.radius.10

# Set teleportation delay to 0 for donors
/lp group donor permission set scs.limit.delay.0

When a player has multiple matching permissions (e.g., from different groups), the highest value is used.

Grant a wildcard such as scs.limit.chunks.* (or any scs.limit.<type>.*) to mean unlimited — equivalent to 0. The concrete scs.limit.chunks.<amount> node still sets an exact cap. Applies to scs.limit.chunks.*, scs.limit.claims.*, scs.limit.radius.*, scs.limit.members.* and scs.limit.roles.*. Before 2.6.6 a wildcard grant was misread and silently fell back to the punitive default (max-chunks: 1), so the permission looked ignored. (Added in 2.6.6)

Method 2: Command-Based Limits

Use admin commands to set or adjust limits per player. This is useful for servers that want direct control without a permissions plugin.

Setting a fixed value

/scs player <player> set-<setting> <amount>

Overrides the default value for that player.

Adding/subtracting from current value

/scs player <player> add-<setting> <amount>

Adds to the player's current limit. Use negative values to decrease.

Available settings

Setting	Description	Supports `add-`
`max-claims`	Maximum claims (0 = unlimited)	Yes
`max-chunks`	Maximum total chunks across all claims (0 = unlimited)	Yes
`max-radius`	Maximum radius for `/claim radius`	Yes
`default-claim-radius`	Default radius the player gets when typing `/claim` alone — capped at `max-radius`	Yes
`chunk-cost`	Per-chunk claim cost	Yes
`cost-multiplier`	Cost multiplier per additional chunk	Yes
`max-claim-price`	Cap on `/claim sell` price (0 = no cap)	Yes
`max-members`	Maximum members per claim	Yes
`max-roles`	Maximum custom roles per claim	Yes
`distance`	Minimum claim distance (in chunks)	Yes
`delay`	Teleportation delay in seconds for `/claim tp`	Yes
`fly`	Remaining claim-fly seconds	Yes
`auto-default-timer`	Default `/claim auto-X` timer applied when the player omits `[seconds]`. `0` = no timer.	Yes
`auto-max-timer`	Hard cap on player-supplied `[seconds]` in `/claim auto-X`. `0` = no cap.	Yes
`auto-purge-bypass`	When `true`, the player is exempt from the auto-purge sweep. Boolean only — use `set-` with `true` or `false`.	No

Examples

# Give a player 20 max claims
/scs player Notch set-max-claims 20

# Add 5 more chunks to a player's limit
/scs player Steve add-max-chunks 5

# Set free chunks for a player
/scs player Alex set-chunk-cost 0

# Reduce teleport delay
/scs player Steve set-delay 0

# Cap a player's /claim auto-X timer at 1 hour
/scs player Steve set-auto-max-timer 3600

# Exempt a player from auto-purge
/scs player Notch set-auto-purge-bypass true

Method 3: Playtime-Based Bonus Limits

On top of the permission and command methods, SimpleClaimSystem can grant players extra claims and/or chunks the longer they have played. It reads the vanilla playtime statistic — so it works retroactively for existing players — and needs no permissions plugin.

The bonus is recomputed when a player joins and, if refresh-interval is above 0, periodically while they are online, so a threshold crossed mid-session applies without a relog. It is added on top of whichever base limit is in effect (permission node or admin-set value) and only ever raises a finite limit: a base of 0 (unlimited — an admin, or scs.limit.claims.*) is left untouched.

How the bonus is computed

bonus           = floor(hoursPlayed / every-hours) × amount   (capped at max-bonus, 0 = uncapped)
effective limit = base limit + bonus                          (only when base > 0)

Example with the default config (every-hours: 25, amount: 1, max-bonus: 5): a player with a base of 3 claims reaches 4 at 25 h played, 5 at 50 h, and tops out at 8 claims (base 3 + max bonus 5) from 125 h onward. The claim menus reflect the increased limit automatically.

Disabled by default. Enable and tune it under players.playtime-limits — see Configuration → Playtime-Based Limits.