/registrations

Create and manage public game signups with teams, alliances, live game IDs, and staff tools.

Requirements

Bot can send messages - to publish the signup card and staff notices.
Bot can attach files - to send CSV exports.
Google Sheets setup - the bot owner must authorize Google Sheets once with /registrations sheets authorize. Workbooks are created in the authorized Google account's manolo/data/registrations folder hierarchy.
Bot can manage the target channels - so the signup card and admin replies can stay up to date.
User can use application commands - so that the bot's slash commands are available.
Staff access - create, edit, close, reopen, delete, export, game ID management, and removals are restricted to the bot owner or configured manager roles.

What It Does

/registrations creates and manages event-style signups for the supported games. The public signup embed is intentionally summary-only: it shows the event name, description, status, and slots. It does not list participants on the public card.

Slot meaning depends on the event mode: in solo registrations, one slot equals one player; in team registrations, one slot equals one full team, with the team size configured by staff.

Staff can keep an event open, close it when signups end, reopen it later if needed, or delete it when they no longer want it active. Closed events keep their data and remain accessible to organizers and admins. Deleted events disappear from search and autocomplete, but the public signup card stays in the channel and its buttons reply that the event was deleted.

The command supports both solo registrations and whole-team signups, alliance caps, templated join/leave text, and a post-close game ID flow with an optional password. Event numbers are global across the bot, so the same event number stays the same even if the event is looked up from a different server-facing context.

An organizer can optionally configure a cached scenario. In that case each registering player chooses a country privately; team leaders choose one for every member of their roster. The scenario must already be available in the bot's local scenario cache. Organizers may optionally make countries unique, which prevents a country from being selected twice.

Public actions happen through buttons on the signup card.
Manager/admin actions are available through the private config view and slash commands.
Lookups include open and closed events, but never deleted ones.

Slash Commands

/registrations wizard

Managers can use /registrations wizard for a private, guided setup instead of filling a long slash-command form. Choose whether to create an event or modify an event you already manage, answer the prompted questions, then confirm the final review. The wizard covers event details, channels, roles, capacity, country rules, teams, alliance caps, templates, and notification/DM settings. The channel section uses one selector: choose a channel, then apply it to all four settings or use the individual signup, reports, announcements, and logs buttons. Each setting remains visible with its own explanation.

Nothing is created or changed until Create event or Apply changes is pressed on the review screen. Drafts are private, last for 30 minutes, and are discarded when cancelled, expired, or when the bot restarts. Game ID announcements, participant management, Sheets, exports, lifecycle controls, and deletion remain in the existing manager panel.

Command	Type	Required?	Description
/registrations create
`name`	Text	✔️	Event title shown on the signup embed.
`game`	Choice	✔️	Choose `Supremacy 1914`, `Call of War`, `Iron Order`, or `Conflict of Nations`.
`scenario` / `unique_countries`	Autocomplete / Boolean	Optional	Require country selection from a locally cached scenario. Enable `unique_countries` to reserve each country for one active player.
`signup_channel`	Text Channel	✔️	Where the public signup card will be posted.
`announcements_channel`	Text Channel	✔️	Where game-start announcements are posted.
`report_channel`	Text Channel	✔️	Where join and leave notices are posted.
`logs_channel`	Text Channel	✔️	Where admin and internal logs are posted.
`participant_role`	Role	Optional	Role assigned to registered participants.
`manager_role`	Role	Optional	Role allowed to manage this event.
`max_participants`	Integer	Optional	Maximum active signups. Default is 100.
`allow_overflow`	Boolean	Optional	Let signups continue after the slot limit is reached.
`minimum_level`	Integer	Optional	Minimum in-game level required to join.
`final_date`	Text	Optional	Closing date in `YYYY-MM-DD` or `YYYY-MM-DD HH:mm` format.
`description`	Text	Optional	Templated public description shown on the signup card.
`team_mode`	Boolean	Optional	Allow whole-team signups instead of solo signups.
`team_size`	Integer	Conditional	Team size including the leader. Required when team mode is enabled.
`team_discord`	Wizard / manager panel	Optional	The slash command keeps the default teammate rule to stay within Discord's 25-option limit. Use the wizard or private manager panel to choose required, optional, or forbidden teammate Discord identities.
`suggestions_discord`	Boolean	Optional	Controls suggested players separately from team members. The default is `false` (Optional), so a suggestion can identify only the in-game account. Set it to `true` (Required) when the suggested player must be a member of this server.
`alliance_limit`	Integer	Optional	Maximum number of active signups per alliance. Set to 0 to disable.
`join_message`	Text	Optional	Templated notice sent when someone joins.
`leave_message`	Text	Optional	Templated notice sent when someone leaves.
`join_notifications` / `leave_notifications`	Boolean	Optional	Independently enable or disable join/leave reports, log entries, and player DMs. Both default to enabled.
`join_dms` / `leave_dms`	Boolean	Optional	Independently enable or disable join/leave DMs. Both default to enabled.
/registrations list
No parameters required.
/registrations suggest
`event`	Event selector	✔️	The open single-player event receiving the suggestion.
`user`	Server member	Optional	When supplied, suggest this server member. When omitted, the proposer enters only the player's in-game ID or username. This game-only flow is available when suggestions are Optional. The target does not need a linked account or prior bot usage.
/registrations pending
`event`	Event selector	✔️	Manager-only review queue for pending player suggestions. Select an application to accept it or reject it with an optional reason.
/registrations register
`event` / `user`	Event selector / Server member	✔️	Manager-only manual registration. In team mode, the modal requires the leader account, team name, and the complete teammate roster.
/registrations edit
`event`	Event selector	✔️	Pick the event to edit from autocomplete.
`name`	Text	Optional	New event title.
`description`	Text	Optional	New templated public description.
`scenario`	Autocomplete	Optional	Set the locally cached scenario used for country selection. This is blocked while the event has active registrations.
`team_mode`	Boolean	Optional	Turn team signups on or off.
`team_size`	Integer	Optional	New team size including the leader.
`suggestions_discord`	Boolean	Optional	Set `true` to require a Discord server member when suggesting a player. Leave it `false` to allow a game-only suggestion identified by its in-game ID or username.
`alliance_limit`	Integer	Optional	New cap per alliance.
`join_message`	Text	Optional	New templated join notice.
`leave_message`	Text	Optional	New templated leave notice.
`reset_message`	Choice	Optional	Choose `Join message`, `Leave message`, or `Both messages` to restore the selected custom templates to their built-in defaults.
`join_notifications` / `leave_notifications`	Boolean	Optional	Enable or disable each notification type separately. The private config panel has matching toggle buttons.
`join_dms` / `leave_dms`	Boolean	Optional	Enable or disable each DM type separately. The private config panel has matching toggle buttons.
`final_date`	Text	Optional	New closing date/time.
`max_participants`	Integer	Optional	New capacity.
`allow_overflow`	Boolean	Optional	Allow registrations past the slot limit.
`participant_role`	Role	Optional	Change the participant role.
`manager_role`	Role	Optional	Change the manager role.
`signup_channel`	Text Channel	Optional	Move the signup card to another channel.
`announcements_channel`	Text Channel	Optional	Change the required game-start announcements channel.
`report_channel`	Text Channel	Optional	Change the report channel.
`logs_channel`	Text Channel	Optional	Change the internal logs channel.
`minimum_level`	Integer	Optional	Change the minimum join level.
/registrations countries
`event`	Event selector	✔️	Event whose country rules should be changed.
`unique_countries` / `clear_scenario`	Boolean	Optional	Enable or disable unique countries, or clear the scenario. Changing or clearing a scenario is blocked while active registrations exist.
/registrations gameid set
`event`	Event selector	✔️	The closed event to update.
`game_id`	Text	✔️	Numeric live game/map ID. A password can be stored too.
`password`	Text	Optional	Optional game password to announce later.
/registrations gameid announce
`event`	Event selector	✔️	The closed event whose players should be notified.
This action reads the stored game ID and DMs active registrants sequentially.
/registrations sheets authorize \| create \| import \| export
`authorize`	No options	Required first	Owner-only setup. Open the returned link and approve access before using the event actions.
`event`	Event selector	✔️	Used by create, import, and export to copy MongoDB data to the sheet or import sheet edits into the event. These actions are staff-only. Team events use `Teams` and `Members`; solo events use `Participants`.
`Teams` / `Members`	Team workbook tabs	Team events	`Teams` contains one row per team without a serialized roster. `Members` contains one row per player, including the leader at index `0`. Imports validate entry IDs, indexes, roles, team size, identities, countries, and alliances before changing the event.
/registrations export
`event`	Event selector	✔️	Exports active registrations as CSV. Solo events keep the existing `registration-<event>-export.csv` attachment. Team events return `registration-<event>-teams.csv` and `registration-<event>-members.csv`.
/registrations close
`event`	Event selector	✔️	Closes the event without deleting any data.
/registrations reopen
`event`	Event selector	✔️	Reopens a closed event and clears any stored live game ID and password.
/registrations delete
`event`	Event selector	✔️	Marks the event deleted, removes participant data, and leaves the public signup card in place.
/registrations manage
`event`	Event selector	✔️	Choose the event you want to manage.
`game_user_id`	Text	✔️	The in-game user ID to remove. Not a Discord user ID.
`reason`	Text	Optional	Optional removal reason.

Lookup note: the event picker uses autocomplete and only returns open or closed events. Deleted events never appear.

Server scope: regular users and managers stay within their current server, while the bot owner can search registrations across every server.

List note: event rows are shown as Name (status, used/limit), for example Friendly War (open, 23/500) or Weekend Match (closed, 40/42).

Public Buttons

Button	What It Does	Visibility
`Join`	Opens the join modal for the event. Team events collect a team name and roster; solo events collect one player profile. Scenario events then open a private searchable country picker, one country per roster player.	Shown on the public signup card while the event is open.
`Suggest Player`	Privately selects a server member and submits their game account for organizer approval. The game account is checked immediately; approval later uses that saved snapshot without another game API lookup.	Shown only for open single-player events.
`Leave`	Removes your registration from the event if you are already signed up.	Shown on the public signup card.
`Stats`	Shows the current event stats and the active participant list in an ephemeral response.	Shown on the public signup card.
`Manage`	Opens the private configuration summary for the event. Staff also see the admin action buttons there.	Shown on the public signup card.
`View Game ID`	Shows the stored live game ID in an ephemeral response, and the password too if one was stored.	Disabled until a game ID exists.

The public card itself stays summary-only. It does not show a live participant list, which keeps the embed compact and easier to read in busy channels.

Modal Flows

Modal	Purpose	Important Notes
`Solo join`	Join a standard single-player registration.	The game account field is optional. If you leave it blank and your Discord account already has a linked game profile, the bot uses the linked one. If you type a user ID or username, that input is used instead.
`Team join`	Join as a whole team.	The leader provides the team name, optional leader account, and the teammate roster. Team size is staff-defined and includes the leader. With teammate Discord set to `required`, use `Discord name; in-game user ID or in-game username`. With `optional`, a teammate may use that format or provide only the game account. With `forbidden`, only game accounts are accepted. Discord-free teammates are omitted from mentions, DMs, and role changes.
`Suggest player`	Submit a single-player application for a selected server member.	The proposer enters a required game account. The bot validates it immediately and saves the resolved username, level, alliance, and profile data for organizer review. Scenario events continue to a private country picker.
`Admin manual registration`	Register a selected server member directly.	Managers provide the account details privately. Team events require the full roster. Every supplied account is checked when the form is submitted, before the final registration is created.
`Admin game ID`	Store the live game ID and optional password.	This is a staff action and is used after the event is closed.
`Admin remove participant`	Remove a registered player or team from the event.	This asks for the in-game user ID only. It does not need the Discord user ID.

Lifecycle & Lookup

Open

Players can join through the signup buttons or join modal. The signup card is active, and staff can still edit the event before or while it is open.

Closed

Signups stop, but the event stays intact for organizers. Staff can still view the config summary, export the roster, set the live game ID and password, announce it to players, remove participants, reopen the event, or delete it later. If the event is deleted, the signup card stays in the channel, but its buttons only reply that the event was deleted.

Deleted

Deletion permanently removes the event, its participant entries, and its pending applications from storage. Deleted events do not appear in `/registrations list`, autocomplete, or normal event lookup anymore. The old signup card remains visible in its channel, but its buttons only explain that the event was deleted.

Event lookup and numbering

Event numbers are assigned globally across the bot, not per server. The number is shown in staff-facing config views and lookup contexts. Public signup cards stay focused on the event title and summary fields.

Teams and alliance snapshots

Team signups are counted as one slot per team, not one slot per member. The alliance limit is checked using the alliance snapshot captured at signup time, so later alliance changes do not rewrite the stored registration history. Team join messages list the leader first and label them with (leader).

Player suggestions

Suggestions are pending applications, not registrations: they reserve no capacity, country, or alliance space until a manager accepts them. A manager can review the private queue from /registrations pending or the Participants panel. Approval repeats only local checks using the account snapshot captured at submission; it does not call the game API again. If a unique scenario country was taken while the application waited, the manager can choose a replacement country privately.

By default, suggestions have Optional Discord identity. Use the member selector, or omit user from /registrations suggest and enter only the player's in-game ID or username. The game-only player is stored with no Discord ID, so the bot does not try to DM, mention, or assign them a Discord role; the proposer and managers still receive the relevant notices. A suggested server member does not need a linked account or prior bot usage.

If suggestions_discord is true, the event is Required: every new suggestion must identify a real member of the server. Changing this setting does not invalidate existing applications or accepted registrations. Suggestions remain unavailable for team-mode events.

Linked account fallback

Every registration requires a verified in-game account. If a player does not type a game account ID or username, the bot uses the profile linked to their Discord account for that event's game. If the player enters a user ID or username manually, that input takes priority. If there is no valid link and no manual account, the signup is rejected. If the wrong account is linked, the player can unlink and relink it, or just sign up by typing the correct profile manually.

Templates & Variables

Template support is available in the public description, join message, and leave message fields. You can also reuse the same placeholders in future templated text fields. Unknown variables are left unchanged, so it is safe to test a template before using it live.

Join and leave notifications and DMs are configured independently. Each can be enabled or disabled, and custom templates can be reset separately with reset_message: Join message, reset_message: Leave message, or together with reset_message: Both messages in /registrations edit. An empty or reset template uses the built-in default. The report channel uses the configured template, the logs channel always receives the generated built-in message, and DMs follow the separate join_dms/leave_dms settings.

For team signups, the leader fills in the team name and then lists teammates one per line in the team modal. The bot counts the leader plus those teammates against the configured team size. The team_discord setting controls whether teammate Discord identities are required, optional, or forbidden; it does not remove the leader's Discord identity because the leader is the person submitting the signup.

Template	When it appears
Signup card footer	Footer on the public signup embed. The rest of that card stays fixed.
Join confirmation	Private reply to the player or team leader immediately after a successful signup. Team rosters are appended automatically.
Join report	Notice posted in the event's report channel after a successful signup. Team rosters and selected countries are appended automatically when applicable.
Join DM	Direct message sent after a successful signup when join DMs are enabled. Team rosters are appended automatically.
Team edit confirmation	Private reply to a team leader after their team name, leader account, or teammate roster is updated.
Leave confirmation	Private reply after a player or team leaves. Team rosters are appended automatically.
Leave report	Notice posted in the event's report channel after a player or team leaves. Team rosters are appended automatically.
Leave DM	Direct message sent after a player or team leaves when leave DMs are enabled. Team rosters are appended automatically.
Game ID view	Private response when a participant presses the Game ID button.
Game-start DM	Direct message sent to active participants when staff announce the game ID.
Game-start announcement	Message posted in the required announcements channel when staff announce the game ID.

The six join/leave templates are shared by solo and team events. Use $registrationlabel for wording that fits either mode. If a team template does not explicitly contain $teammemberroster, the leader-first roster is added below the rendered message. For successful join reports, selected countries are also added below when available; put $countryroster in the report template to choose its position. Existing per-mode templates are preserved as compatibility fallbacks, but new configuration uses these unified templates.

Template Builder

Write any text, insert placeholders, and preview the result with sample registration data. This preview does not change a registration.

Documentation preview

Default template Template text

Processed sample

The sample represents a team event named Summer Cup. Real values come from the event and the player who joined.

Variable examples at a glance

Variable	Example processed value

Player and leader variables

Variable	Meaning
`$player`	Primary player label for the signup.
`$registrationlabel`	Mode-neutral signup label: the player's formatted game identity for solo signups, or `Team <name>` for team signups.
`$playerid`	Player's in-game account ID.
`$playermention`	Formatted in-game profile label, such as `MarcZX10` ([48035824](...)).
`$playerusername`	Resolved in-game username.
`$discordid`	Player's Discord user ID.
`$discordusername`	Player's Discord username.
`$discordname`, `$discorddisplayname`	Player's Discord display name.
`$discordmention`	Player's Discord mention, such as `<@661229020792487917>`.
`$playergameusername`	Explicit alias for the player's in-game username.
`$playerdiscordid`, `$playerdiscordusername`, `$playerdiscorddisplayname`, `$playerdiscordmention`	Explicit Discord identity aliases.
`$playerdisplayname`	Discord display name used for the signup.
`$playerprofileurl`	Profile URL for the linked game account, when available.
`$country`, `$countryname`	Selected scenario country name. It is blank when the event has no scenario.
`$countryid`	Selected scenario country ID. It is blank when the event has no scenario.
`$leader`	Leader label in team signups.
`$leaderid`	Leader's in-game account ID.
`$leadermention`	Leader's formatted in-game profile label.
`$leadmention`	Discord mention for the leader.
`$leaderusername`	Leader's resolved game username.
`$leaderdisplayname`	Leader's Discord display name.
`$leaderdiscordname`	Leader's Discord name or display name.
`$leaderdiscordid`	Leader's Discord user ID.
`$leaderdiscordusername`, `$leaderdiscorddisplayname`, `$leaderdiscordmention`	Leader's Discord username, display name, and mention.

Team and roster variables

Variable	Meaning
`$teamname`	The submitted team name.
`$teamsize`	Configured team size including the leader.
`$teammembercount`	Number of roster members listed after the leader.
`$teammembers`	Roster labels separated by new lines.
`$teammembermentions`	Comma-separated Discord mentions for roster members.
`$teammemberplayermentions`	Comma-separated formatted in-game profile labels for roster members.
`$teammemberplayerids`	Comma-separated teammate in-game account IDs.
`$teammemberids`	Compatibility alias for `$teammemberplayerids`.
`$teammember1`, `$teammember2`, ...	Each teammate's full Discord-plus-game roster line.
`$teammember1playerid`, `$teammember2playerid`, ...	Each teammate's in-game account ID.
`$teammember1country`, `$teammember2country`, ...	Each teammate's selected scenario country name.
`$teammember1countryid`, `$teammember2countryid`, ...	Each teammate's selected scenario country ID.
`$teammember1discordid`, `$teammember2discordid`, ...	Each teammate's Discord user ID.
`$teammember1playermention`, `$teammember2playermention`, ...	Each teammate's formatted in-game profile label.
`$teammember1discordmention`, `$teammember2discordmention`, ...	Each teammate's Discord mention.
`$teammemberdiscordids`	Comma-separated Discord user IDs for roster members.
`$teammemberdiscordmentions`	Comma-separated Discord mentions for roster members.
`$teammemberdiscordnames`	Comma-separated Discord display names for roster members.
`$teammemberroster`	Formatted roster block with the leader first and teammates below. It is automatically appended for team join/leave messages unless placed in the template.
`$countryroster`	Selected country block: one country for solo signups, or leader-first countries for a team. Successful join reports and audit logs append it automatically when countries were selected; add it to a join report template to control its position.

Event, slots, and status variables

Variable	Meaning
`$eventname`	Event title.
`$eventid`	Event number if available, otherwise the internal event ID.
`$eventnumber`	Global bot-wide event number.
`$eventdbid`	Internal database ID.
`$scenarioid`	Configured scenario ID. It is blank when the event has no scenario.
`$scenario`, `$scenarioname`	Configured scenario name. If the local scenario catalogue has no name, this falls back to the scenario ID.
`$status`	Current event status, such as open or closed.
`$usedslots`	Current number of active registrations.
`$remainingslots`	How many slots are left, or `∞` if the event has no cap.
`$capacity`	Configured capacity, or `∞` when unlimited.
`$teammode`	Whether team mode is enabled.
`$minimumlevel`	Minimum required game level.
`$finaldate`	Formatted final date or closing time.

Game and alliance variables

Variable	Meaning
`$game`	Game family, such as Supremacy 1914 or Conflict of Nations.
`$gameid`	Stored live game ID.
`$gamepassword`	Stored live game password, when one exists.
`$alliance`	Alliance snapshot name or ID captured at signup time.
`$alliancecount`	How many active signups share that alliance snapshot.

Examples

Create a solo event


              
                /registrations create
                name: Summer Cup
                game: Supremacy 1914
                signup_channel: #signups
                announcements_channel: #announcements
                report_channel: #updates
                logs_channel: #logs
                description: $eventname is open for $usedslots/$capacity players.

Creates a standard solo signup where players can join with a linked account or by typing a profile manually.

Create a team event with alliance limits


              
                /registrations create
                name: AvA Night
                game: Call of War
                team_mode: true
                team_size: 5
                alliance_limit: 2

The leader counts as one of the five players. The bot will enforce the team size and the alliance cap using the leader's signup snapshot.

Store and announce a live game ID


              
                /registrations gameid set
                event: Summer Cup
                game_id: 10293847
                password: secret


              
                /registrations gameid announce
                event: Summer Cup

If the event has a password, the bot first asks whether to include it in the announcements channel and DMs, only DMs, only the announcements channel, or nowhere. The announcement is then sent sequentially to active registrants and the staff reply includes delivered, failed, and total counts.

Use templated join and leave messages


              
                /registrations edit
                event: Summer Cup
                join_message: Welcome $player, team $teamname is in!
                leave_message: $player has left $eventname.

Any supported placeholder can be mixed into descriptions, join notices, and leave notices. Unknown placeholders are left untouched.

Additional Notes

Set up privately first. Create and configure the event in private signup and announcements channels, verify the card and templates, then make those channels public when everything is ready.
Manage opens an ephemeral summary. The config view is private, and the admin action buttons only appear for users who can manage the event.
Export stays available for staff on closed events. Solo CSV exports keep their existing single-file layout. Team exports are split into one team file and one member file, with the leader always at member index 0; no roster JSON cell is required.
Game ID announcements use the dedicated announcements channel. It is required for each event, and unavailable channels stop the announcement instead of falling back elsewhere.
Player-facing content is editable. The private Templates panel manages signup-card, join, leave, Game ID, and game-start text per event.
Refresh Alliances is manual and manager-only. It checks each unique active leader and teammate account again, at least one second apart, and privately shows progress, success/failure counts, and an estimated remaining time.
Map player checks require a closed event and game ID. The Checks panel can compare active registrations with the live map. It reports registered players missing from the map, map players not registered for the event, and, when countries were selected at signup, incorrect nation choices.
Refresh never removes players automatically. If an alliance exceeds its configured limit, the final panel lets a manager review the affected alliance, choose one player, and explicitly confirm a removal. Removing a teammate only removes that teammate from the team roster.
Suggestions are private until reviewed. Pending applications are visible only to event managers. Managers see pending counts in their private event views, and accepted or rejected decisions notify both the proposed player and the proposer.
Manual registration uses the same event rules. Managers can add a player or complete team from the Participants panel or /registrations register; capacity, duplicate, country, level, and alliance checks still apply.
Sheets are managed privately. The Manage panel includes a Sheets menu with create, import-from-sheet, export-to-sheet, and Update Map Nations actions. Solo workbooks keep Participants; team workbooks use Teams plus Members, while Event and Map Check keep their existing purposes. Team imports group member rows by entryID, require complete indexes and a leader row, and validate everything before writing. Once the event is closed and has a game ID, Update Map Nations writes every active registered player and teammate's live nation to Map Check, alongside missing, unknown, and country-match results. Importing a sheet does not call game APIs or send join/leave notices.
Deleting an event keeps its spreadsheet. The bot deletes the registration data from MongoDB but never deletes, clears, or moves the corresponding Google Sheet.
Deleted means deleted. If you delete the event, the bot removes the participant entries, marks the event deleted, and leaves the public signup card in the channel so old buttons can explain that it is gone.
Public cards stay clean. They are designed to be readable at a glance, even in busy channels.