/cmd group management

Overview 🚀

Command groups let you save one or more Rust Console server commands under a reusable name.

After a command group is created, you can:

• Run it manually with /cmd execute
• Attach it to an in-game bind with /bind add-cmd
• Reuse it for kits, spawns, events, wipe setup, or admin workflows
• Point an existing bind to a different group with /bind edit-cmd

Command groups hold the actual commands Helios runs. Binds, timed commands, and manual execution are different ways to trigger those saved commands.

Example:

Group name: spawn_rowboat
Command: spawn rowboat {PlayerPositionX}+2,{PlayerPositionY}+1,{PlayerPositionZ}

If that group is attached to a bind, a player can say the bind phrase in game and Helios runs the saved command near that player.

---

Setup Order ⚙️

Build and test the command group first, then attach it to anything player-facing.

1. Create a command group with /cmd group add
2. Add one or more server commands with /cmd add
3. Review the saved group with /cmd list
4. Test the group with /cmd execute
5. Attach the group to a bind with /bind add-cmd if players should trigger it
6. Use /bind edit-cmd later if an existing bind should run a different group

---

Commands Covered 💬

Command	What It Does
/cmd group add	Creates a new command group
/cmd add	Adds commands into a command group
/cmd list	Shows saved command groups and commands
/cmd execute	Runs a saved command group manually for testing or admin use
/cmd group remove	Deletes a command group
/bind add-cmd	Connects a command group to an in-game bind
/bind edit-cmd	Changes the command group connected to an existing bind

---

/cmd execute and send ⚡

Overview 🚀

The /cmd execute and /cmd send commands let server owners and admins send commands to their Rust Console servers through Helios.

Use /cmd execute for saved command groups.

Use /cmd send for one quick manual command.

---

Commands Covered 💬

Command	What It Does
/cmd execute	Sends a saved command group to all servers or one selected server
/cmd send	Sends one single command to all servers or one selected server

---

/cmd send 💬

Use /cmd send when you want to send one manual command.

This can send the command to all servers, or you can optionally choose one specific server.

/cmd send command:"fps"

/cmd send command:"fps" server:"US Main"

---

/cmd execute 📦

Use /cmd execute when you want to run a saved command group.

This can run the command group on all servers, or you can optionally choose one specific server.

/cmd execute

---

Setup Flow 🛠️

1. Use /cmd send for one quick manual command
2. Use /cmd execute for saved command groups
3. Choose a specific server if you do not want it sent to all servers
4. Check the Helios response after sending

Step 1: Plan The Group 🧠

Before running commands, decide what the group should do and when it should be used.

Good command group ideas:

• Give a starter kit
• Give wood, meds, or event items
• Spawn a rowboat near the player
• Spawn a recycler near the player
• Run several wipe setup commands
• Send a server message
• Trigger event setup commands
• Run the same admin command sequence across servers

Use a short, clear group name. The name should describe the action, not the bind phrase.

Good names:

• starterkit
• give_wood
• spawn_rowboat
• spawn_recycler
• give_medical
• wipe_setup
• raid_alert_test

Avoid vague names like test, new, or command1 once the group is used on a live server.

---

Step 2: Create The Command Group 📁

Use /cmd group add to create the group that will hold your commands.

/cmd group add

When the command asks for a name, enter the group name you planned.

Example group name:

spawn_rowboat

At this point, the group exists, but it does not do anything yet. You still need to add commands to it with /cmd add.

---

Step 3: Add Commands To The Group 🧾

Use /cmd add to add a Rust Console server command to the group.

/cmd add

Choose the command group you created, then enter the server command Helios should run.

You can add more than one command to the same group. When the group runs, Helios runs the saved commands in that group.

Example group:

starterkit

Example commands inside that group:

kit givetoplayer "starter" "{PlayerName}"
inventory.giveto "{PlayerName}" "syringe.medical" 3

This kind of group is useful when a player-triggered bind should give the player a kit or items.

---

Placeholder Support 📍

Command groups can use player placeholders. Placeholders are replaced when Helios runs the command.

This matters most when the command group is triggered by a bind, because Helios can use the player who triggered the bind.

Placeholder	What It Inserts	Common Use
{PlayerName}	The triggering player's name	Giving kits, giving items, running player-targeted commands
{PlayerPositionX}	The triggering player's X coordinate	Spawning something near the player
{PlayerPositionY}	The triggering player's Y coordinate	Spawning something above or below the player
{PlayerPositionZ}	The triggering player's Z coordinate	Spawning something near the player
{PlayerPos}	The triggering player's full position, when supported by the command	Commands that accept one combined position value

Use placeholders exactly as written, including the braces.

Example player-name placeholder:

kit givetoplayer "pvp" "{PlayerName}"

Example item command:

inventory.giveto "{PlayerName}" "wood" 10000

Example position placeholders:

{PlayerPositionX},{PlayerPositionY},{PlayerPositionZ}

Example combined position placeholder:

{PlayerPos}

If a command needs a player name, use {PlayerName}. If a command needs a location, use the position placeholders.

---

Position Offsets 🧭

You can offset each position value with + or -.

Example:

{PlayerPositionX}+2,{PlayerPositionY}+1,{PlayerPositionZ}

This means:

• X position is moved by 2
• Y position is moved up by 1
• Z position stays the same

More offset examples:

{PlayerPositionX}-3,{PlayerPositionY},{PlayerPositionZ}+4

{PlayerPositionX},{PlayerPositionY}+5,{PlayerPositionZ}

Offsets are useful for spawning entities, effects, or objects near the player instead of directly on top of them.

---

Example: Spawn A Rowboat 🚤

Create a group named:

spawn_rowboat

Add this command to the group:

spawn rowboat {PlayerPositionX}+2,{PlayerPositionY}+1,{PlayerPositionZ}

When a player triggers this group from a bind, Helios spawns a rowboat close to that player.

You can replace rowboat with another valid entity name.

General format:

spawn ENTITY_NAME {PlayerPositionX}+2,{PlayerPositionY}+1,{PlayerPositionZ}

---

Example: Give A Kit To The Triggering Player 🎒

Create a group named:

starterkit

Add a command like:

kit givetoplayer "starter" "{PlayerName}"

When a player triggers the group from a bind, {PlayerName} becomes that player's name.

You can also add more commands to the same group:

inventory.giveto "{PlayerName}" "bandage" 5
inventory.giveto "{PlayerName}" "syringe.medical" 3

---

Example: Use A Full Position Placeholder 📌

Some commands accept one combined position value instead of separate X, Y, and Z values.

For those commands, use {PlayerPos} when the command supports it.

Example:

zones.createcustomzone "Event Zone" "{PlayerPos}" 0 Sphere 25 1 1 0 1 1

If the command expects separate coordinates, use {PlayerPositionX}, {PlayerPositionY}, and {PlayerPositionZ} instead.

---

Step 4: Review The Group 🔎

Use /cmd list to check the saved command groups and the commands inside them.

/cmd list

Use this before testing so you can confirm:

• The group exists
• The group name is spelled correctly
• The commands were added to the right group
• The placeholders are spelled correctly
• The command order makes sense

---

Step 5: Test The Group 🧪

Use /cmd execute to manually test the group before connecting it to a player-facing bind.

/cmd execute

Test with one controlled player first.

Be extra careful when the group:

• Gives items or kits
• Spawns entities
• Teleports players
• Creates zones
• Changes server state
• Sends global messages

If the command uses {PlayerName} or player position placeholders, test it the same way players will trigger it later. That makes sure the placeholder resolves to the correct player.

---

Step 6: Attach The Group To A Bind 🎮

After your command group is created, filled, reviewed, and tested, use /bind add-cmd if players should trigger it from Rust Console chat.

/bind add-cmd

This connects the command group to an in-game bind phrase.

Example bind phrase:

i need wood

When the player says that phrase in game, Helios runs the command group attached to the bind.

The bind does not create the command group. It only points to a command group that already exists.

---

Step 7: Edit A Bind Later 🔧

Use /bind edit-cmd when you need to change which command group is attached to an existing bind.

/bind edit-cmd

This is useful when:

• You made a better version of a command group
• A bind is pointing to the wrong group
• You want the same in-game phrase to run a different action
• You are replacing an old event, kit, or spawn workflow

---

Step 8: Remove Old Groups 🗑️

Use /cmd group remove when a saved command group is obsolete, duplicated, or no longer safe to run.

/cmd group remove

Before removing a group, make sure no active binds, timed commands, or admin workflows still depend on it.

---

Full Setup Flow 🛠️

1. Run /cmd group add to create a command group
2. Run /cmd add to add commands into that group
3. Use /cmd list to review what you made
4. Test the group with /cmd execute
5. Use {PlayerName} if the command targets the player
6. Use position placeholders if the command needs the player's location
7. Run /bind add-cmd to attach the command group to a bind
8. Test the bind in game with one controlled player
9. Use /bind edit-cmd if you need to change the command group later
10. Remove old groups with /cmd group remove when you no longer need them

---

Complete Walkthrough: Player Wood Bind ✅

This example creates a group that gives wood to the player who triggers the bind.

1. Create a command group named:

give_wood

2. Add this command with /cmd add:

inventory.giveto "{PlayerName}" "wood" 10000

3. Review it:

/cmd list

4. Test it:

/cmd execute

5. Attach it to a bind:

/bind add-cmd

6. Use an in-game trigger phrase like:

i need wood

When the player says the bind phrase in game, Helios runs the give_wood command group and replaces {PlayerName} with that player's name.

---

Complete Walkthrough: Player Rowboat Bind ✅

This example creates a group that spawns a rowboat near the player who triggers the bind.

1. Create a command group named:

spawn_rowboat

2. Add this command with /cmd add:

spawn rowboat {PlayerPositionX}+2,{PlayerPositionY}+1,{PlayerPositionZ}

3. Review it:

/cmd list

4. Test it:

/cmd execute

5. Attach it to a bind:

/bind add-cmd

6. Use an in-game trigger phrase like:

spawn boat

When the player says the bind phrase in game, Helios runs the spawn_rowboat command group and replaces the position placeholders with that player's current location.

---

Common Uses 📋

Command groups are useful for:

• Saved admin command sets
• Repeated wipe setup commands
• Commands used by binds
• Event commands
• Spawning entities or items
• Spawning entities near the triggering player with position placeholders
• Giving kits or items to {PlayerName}
• Creating zones at {PlayerPos} when the server command supports it
• Running the same command setup across servers

---

Requirements 📌

Before using command groups, make sure:

• Helios is connected to at least one server in this Discord
• You have permission to run admin commands
• You selected the correct server when needed
• A command group exists before using /bind add-cmd
• The command group has commands added with /cmd add
• You know whether the server command needs {PlayerName}, separate position values, or {PlayerPos}

---

Notes 📝

• Most admin commands require Manage Server permission
• Create the group first with /cmd group add
• Add commands to the group with /cmd add
• Use /cmd list to check your saved groups
• Use /cmd execute to test command groups before connecting them to binds
• /bind add-cmd does not create the command group by itself
• {PlayerName} is for commands that target the triggering player
• {PlayerPositionX}, {PlayerPositionY}, and {PlayerPositionZ} are for commands that need separate coordinates
• {PlayerPos} is for commands that support one combined player position value
• You can replace rowboat with any valid entity name in spawn commands
• Use position offsets carefully so commands do not spawn things inside players, bases, or terrain
• Test command groups before using them in production
• Test each bind before making it available to the full server
• Some command group features may require Premium