HL Gaming Bot Documentation – Developer Guide

HL Gaming Bot Platform – Developer Guide

Welcome to the HL Gaming Bot Platform Developer Guide. This document will walk you through every step of creating, configuring, and polishing a bot that integrates with our chat interface. You don’t need to worry about any backend complexity—just fill out the fields you see in the Developer Portal, follow the format rules, and your bot will come to life.

We’ve designed the portal to be intuitive yet powerful. Whether you’re adding a simple “hello world” command or building a full statistics lookup with images and cards, the form fields and templates below will make it straightforward.

Feel free to bookmark this guide and refer back whenever you’re adding new commands or making updates. Let’s get started!

Portal Locations

To begin building your bot, you can:

Create a new bot:
Visit the HL Gaming Bot Portal. Here you fill out your bot’s Name, Image, Description, and add Commands & also allow to edit or delete your bots.
View all your bots:
Go to My Bots. This page lists every bot created by all devs, with options to chat and use.

Bookmark both pages for quick access as you develop and manage your bots.

Bot Information

This section defines the core identity of your bot. You will fill out three fields: Name, Image, and Description. These help users recognize and trust your bot.

Field	Type	Required	Description & Tips
Name	Text	Yes	What it is: A unique identifier for your bot (no spaces). Rules: Letters (A–Z or a–z), digits (0–9), and underscore (_) only. Uniqueness: If you try to reuse an existing name, the portal will prompt you to choose another. Example: `FreeFireStatsBot`
Image	File Upload	No	What it is: PNG or JPG icon for your bot. Size: Up to 2 MB; square or circular images display best. Purpose: Shown next to your bot’s name in listings and chat bubbles. Tip: Use a transparent PNG for a polished look.
Description	Textarea (max 100 chars)	Yes	What it is: A short tagline (up to ~10 words). Allowed content: Plain text only, no HTML or markdown. Purpose: Helps users understand at a glance what your bot does. Example: `Lookup Free Fire stats with one command`

Commands

Each bot can expose one or more commands. A command is an action users can trigger by typing a keyword (e.g. /stats) or clicking a button. Click Add Command to create your first one. You can add as many commands as you need, and reorder or delete them at any time.

Inside each command block you will see:

Trigger Name: What the user types to invoke this command.
API Endpoint: The URL your service will handle to produce a response.
Parameters Section: Define any extra inputs your API needs.
Response JSON Template: Map your API’s output into chat bubbles.
Static Replies: Pre-written messages that appear before or alongside API replies.

Parameters

Use Add Param to request additional data from the user or send fixed values to your API. Each parameter row consists of three fields:

Field	Type	Required	Purpose
Param name	Text	Yes	Used as the key when calling your API. Example: `freeFireUid`, `searchTerm`.
Default value	Text	No	If provided, that value is always sent and no prompt is shown. Great for fixed settings like `region=US`.
Intro message	Textarea	If no default	Message the chat user sees, asking them to supply this value. Example: “Please enter your Free Fire UID to continue.”

Flow: If any parameter has no default, the chat UI pauses and displays each Intro message one by one until the user provides all required values. Once complete, your API call is made with all parameters included.

Response JSON Template

This is the heart of how your bot’s replies look. Enter a JSON object that defines:

type: text, image, or card.
content: For text and image, this holds the text or URL. For card, see below.
Additional fields: e.g. title, fields array for cards.

You may include placeholders (see next section) to inject dynamic values from the user or your API.

{
  "type": "text",
  "content": "Hello {username}, you said: {input}"
}

Card example:

{
  "type":  "card",
  "title": "Profile Overview",
  "image": "{api.result.AccountAvatarId}",
  "fields": [
    { "label": "Name",  "value": "{api.result.AccountName}" },
    { "label": "Level", "value": "{api.result.AccountLevel}" }
  ]
}

Static Replies

Static replies are simple text messages that your bot sends regardless of your API call. They are great for:

Welcoming the user.
Informing them that processing is happening (e.g. “Fetching stats…”).
Providing fallback content if your API fails.

Use Add Reply to insert one or more of these messages above your API-based response.

Placeholders

You can dynamically inject several values into your templates:

Placeholder	Value Injected	Example Usage
`{username}`	User’s display name	`"Welcome back, {username}!"`
`{input}`	Raw command or text they typed	`"You asked: {input}"`
`{yourParamName}`	Any parameter defined above (e.g. `{freeFireUid}`)	`"Fetching stats for UID {freeFireUid}"`
`{api.someField}`	Any key from your API’s JSON response	`"Rank: {api.result.BrRankPoint}"`

Click the 🔍 icon next to any textarea to open the Field Picker, which lists all available placeholders so you don’t have to remember names.

Reply Syntax & Operators
(Advanced Reference)

This reference details every aspect of our reply‐templating language—no implementation details, just the rules and syntax you can use in your “Reply” fields. You’ll learn about:

Conditional blocks: {if}{else if}{else}{/if} (single, multi‐branch, nested)
Operators: arithmetic, comparison, logical, ternary, optional chaining, array indexing
Placeholders: property paths and array access
Line breaks: \n vs. real newlines
Auto‐embedded media: images, video, audio, YouTube, links
dozens of tested examples and expected outputs

1. Conditional Blocks

Wrap any content in {if …}{/if} (with optional {else}/{else if}) to show or hide based on a Boolean expression.

Single‐branch: {if expr}…{/if}
If–Else: {if expr}…{else}…{/if}
Multi‐branch: {if expr1}…{else if expr2}…{else}…{/if}
Nested: you can place one block inside another.

2. Operators & Expressions

Inside any {…}, you can write full JavaScript‐style expressions:

Arithmetic: + - * / % ** (2**3 → 8)
Comparison: > >= < <= == === != !==
Logical: && || !
Ternary: cond ? a : b
Optional chaining: user?.profile?.age
Array access: clips[0].url
Math methods: Math.round(), Math.min(), Math.max(), Math.floor()

3. Placeholders & Paths

Use {path.to.field} or {arrayName[index]} to inject data:

{user.name} → user’s name
{stats.scores[2]} → third element of stats.scores
Combine with operators: {stats.wins + stats.losses}

4. Line Breaks

Control line breaks via:

\n (the two characters backslash + n) → renders as <br>
Real newline (press Enter) → also renders as <br>

Use \n when you need a break inside a single‐line editor.

5. Media & Link Embedding

Any URL in the final text is auto‐converted:

Images: .jpg/.png/.gif/.webp → <img src="…">
YouTube: short or full links → embedded <iframe>
Video: .mp4/.webm/.ogg → <video controls>
Audio: .mp3/.wav/.aac → <audio controls>
Other URLs: clickable <a href>

6. Example Templates & Expected Output

Each example shows a template, sample data, and what the user sees.

// Template:
{if user.level >= 50}
🏆 Elite Level {user.level}
{else}
📈 Level {user.level}
{/if}

// Data:
{ user: { level: 42 } }
// Output:
📈 Level 42

// Data:
{ user: { level: 75 } }
// Output:
🏆 Elite Level 75

// Template:
K/D Ratio: {stats.kills / stats.deaths >= 1 ? 'Good 👍' : 'Needs Work 👎'}\n
Total: {stats.kills + stats.deaths}

// Data:
{ stats: { kills: 20, deaths: 15 } }
// Output:
K/D Ratio: Good 👍

Total: 35

// Template:
{if user.premium}
⭐ Premium user: {user.name}\n
{if usage.remainingToday > 0}
  Quota left: {usage.remainingToday}
{else}
  Quota exhausted!
{/if}
{else}
🔓 Standard user. Upgrade for daily perks!
{/if}

// Data A (premium with quota):
{ user:{premium:true,name:'Alex'}, usage:{remainingToday:5} }
// Output:
⭐ Premium user: Alex

Quota left: 5

// Data B (premium, no quota):
{ user:{premium:true,name:'Alex'}, usage:{remainingToday:0} }
// Output:
⭐ Premium user: Alex

Quota exhausted!

// Data C (non‐premium):
{ user:{premium:false,name:'Alex'}, usage:{remainingToday:5} }
// Output:
🔓 Standard user. Upgrade for daily perks!

// Template:
Latest clip: {clips[0]}\n
Avg Score: {Math.round((scores[0] + scores[1] + scores[2]) / 3)}

// Data:
{ clips:['url1.mp4','url2.mp4'], scores:[10,20,15] }
// Output:
Latest clip: url1.mp4

Avg Score: 15

7. Quick Reference

Feature	Syntax	Example
If	`{if expr}…{/if}`	`{if x>0}Positive{/if}`
If–Else	`{if expr}…{else}…{/if}`	`{if ok}Yes{else}No{/if}`
Multi‐branch	`{if e1}…{else if e2}…{else}…{/if}`	`{if n>0}Pos{else if n<0}Neg{else}Zero{/if}`
Arithmetic	`+ - * / % **`	`{a*b + c}`
Comparison	`> >= < <= == === != !==`	`{x===y ? 'eq' : 'ne'}`
Logical	`&& \|\| !`	`{a>0 && b<0}`
Ternary	`cond ? a : b`	`{age>=18 ? 'Adult' : 'Minor'}`
Optional chaining	`obj?.prop?.[0]`	`{user?.email}`
Array index	`arr[index]`	`{items[0].name}`
Math methods	`Math.round(), Math.min(),…`	`{Math.max(a,b)}`
Line break	`\n` or real newline	`Line1\nLine2`
Media URL	Any `http(s)://…`	`…clip.mp4` → video

Use this as your definitive guide to everything you can write in a reply template—no more guessing, just paste your logic and media links, and let your bot deliver dynamic, rich responses.

Conditional Replies in Practice

Here’s a step-by-step example showing:

A dummy API response
A single reply template with multiple conditions
How each scenario renders in chat

1. Dummy API Response

{
  "user": {
    "name": "ValiantHero",
    "level": 45,
    "exp": 91200
  },
  "stats": {
    "wins": 12,
    "losses": 3
  },
  "usage": {
    "usedToday": 10,
    "dailyLimit": 100,
    "remainingToday": 90
  }
}

2. Reply Template with Conditions

// Greeting & basic info
Hello {user.name}! Level: {user.level} (EXP: {user.exp})\n

// Level tier messages
{if user.level >= 50}
🏆 Elite Tier! Keep dominating!
{else if user.level >= 30}
🔥 Veteran Tier! Well done!
{else if user.level >= 10}
💪 Rising Tier! Keep growing!
{else}
🌱 Newcomer Tier! Welcome aboard!
{/if}\n

// Win/Loss summary
Wins: {stats.wins} | Losses: {stats.losses}\n

// Usage reminder
API calls today: {usage.usedToday}/{usage.dailyLimit} (Remaining: {usage.remainingToday})

3. Conditions Cheat Sheet

Expression	Meaning	Example Result
`user.level >= 50`	Level is 50 or higher	🏆 Elite Tier!
`user.level >= 30`	Level is between 30–49	🔥 Veteran Tier!
`user.level >= 10`	Level is between 10–29	💪 Rising Tier!
`else`	Level is below 10	🌱 Newcomer Tier!

4. Rendered Output

Scenario A: Level 60 Veteran

API Data: "level": 60, wins:12, losses:3, usage.remainingToday:90
Rendered Chat Bubble:

Hello ValiantHero! Level: 60 (EXP: 91200)
🏆 Elite Tier! Keep dominating!
Wins: 12 | Losses: 3
API calls today: 10/100 (Remaining: 90)

Scenario B: Level 25 Challenger

API Data: "level": 25, wins:12, losses:3, usage.remainingToday:90
Rendered Chat Bubble:

Hello ValiantHero! Level: 25 (EXP: 91200)
💪 Rising Tier! Keep growing!
Wins: 12 | Losses: 3
API calls today: 10/100 (Remaining: 90)

Scenario C: Newcomer

API Data: "level": 5, wins:2, losses:1, usage.remainingToday:90
Rendered Chat Bubble:

Hello ValiantHero! Level: 5 (EXP: 91200)
🌱 Newcomer Tier! Welcome aboard!
Wins: 2 | Losses: 1
API calls today: 10/100 (Remaining: 90)

✔️ Key takeaways:

Use {if…}{else if…}{else}{/if} to cover all branches.
Insert \n or real newlines for line breaks.
Mix placeholders ({user.level}), operators (>=), and text freely.
Test with different API values to verify each branch.

This pattern scales: add as many {else if} clauses as you need, combine with arithmetic or ternary operators, and your bot will always choose the correct message.

Example Workflow

User triggers command (e.g. types /stats or clicks a button).
Static replies display, one after another, to set expectations.
Parameter prompts appear in sequence if you defined any without defaults.
API call is made with JSON or query params including username, input, and your parameters.
JSON template merges placeholders with returned data.
Final bubble is rendered in chat according to your type and content settings.
If errors occur, your static replies still show and a generic error bubble appears.

Advanced Example: Free Fire UID Lookup

Here’s how you might build a robust stats command:

Trigger Name: /stats
API Endpoint: https://api.ffstats.com/get?uid={freeFireUid}
Parameters:
- freeFireUid (no default) – Intro: “Enter your Free Fire UID:”
Static Replies:
- “Hang tight, retrieving your stats…”

Response Template:

{
  "type":  "card",
  "title": "Stats for {username}",
  "image": "{api.result.avatarUrl}",
  "fields": [
    { "label": "Level",    "value": "{api.result.level}" },
    { "label": "Kills",    "value": "{api.result.kills}" },
    { "label": "Matches",  "value": "{api.result.matches}" }
  ]
}

When a user enters their UID, they see:

“Hang tight, retrieving your stats…”
Parameter prompt: “Enter your Free Fire UID:”
(User enters UID)
“Bot is typing…” indicator
A card showing Level, Kills, Matches with the user’s avatar

Error Handling & Warnings

Invalid JSON: If your template or API returns malformed JSON, users see “Bot error: invalid response format.”
Timeouts: If your endpoint doesn’t reply in a few seconds, users see “Bot error: request timed out.”
Missing placeholders: If you reference a placeholder that doesn’t exist, that part will render empty—watch for typos!
CORS: Ensure your server allows requests from https://hlgamingofficial.com to avoid silent failures.

From Zero to Published Bot

Welcome to the most comprehensive guide you’ll ever read on building your very first chat bot on the HL Gaming platform. We’re about to demystify every single step—from logging in and creating your bot’s identity, to wiring up a live API call, to formatting a user-friendly response and finally hitting “Publish” so the world can start using your creation. We won’t assume you know anything about coding, APIs, or JSON; instead, we’ll explain why each button exists, why each field matters, and how everything fits together, so you’ll never feel lost or unsure. By the end of this walkthrough, you’ll have a fully functional “Stylish Name Maker” bot that anyone can invoke with a simple slash command. Ready? Let’s dive in, step by step, with crystal-clear detail.

1. Create Your Bot “Shell” (Identity)

The first thing you need when building a bot is to give it a name, an icon, and a short description—think of this as creating your bot’s business card or avatar that will appear whenever someone sees it in a list or chat. These three pieces of information form your bot’s “identity,” and they help users quickly understand what your bot does and trust that it’s legitimate.

Open the Developer Portal: In your web browser navigate to https://www.hlgamingofficial.com/p/hl-gaming-bot-portal.html , and if you’re not already signed in, click “Sign In” at the top right. If you don’t have an HL Gaming account, click “Sign Up” and follow the on-screen prompts—it only takes a minute to register with an email and password.
Click “Create a New Bot”: You’ll see a form with three clearly labeled fields:
- Name:
  Enter StylishNameBot (or any unique identifier you choose). This name must contain only letters, numbers, or underscores—no spaces or special symbols—because it serves as the internal key the system uses to reference your bot. Pick something short and descriptive so users can easily remember it.
- Image:
  (Optional) Upload an icon file in PNG or JPG format, up to 2 MB in size. Square or circular images display best. This icon will appear next to your bot’s messages in chat, giving it a polished, branded look. If you’re not sure what to upload, you can skip this for now and add it later once you have a design ready.
- Description:
  Enter up to 10 words of plain text—no HTML or markdown allowed. For example: “Generate fun, decorative usernames with one simple command.” This tagline is what users will see under your bot’s name in the chatbot directory, so make it concise and informative.
Save Your Bot:
When you’ve filled in Name and Description (and optionally uploaded an Image), click the Save or Create button at the bottom of the form. Your new bot will now appear in the “My Bots” section as an empty container—ready for you to add commands.

2. Add Your First Command

With the shell of your bot created, the next step is to define what it actually does: its commands. A command is a keyword (usually prefixed by a slash, like /help) that users type to trigger your bot. In our example, we’ll add a command called /stylish that calls a simple styling API to generate decorative usernames.

In “My Bots,” click on StylishNameBot to open its detail page, then click the Add Command button. A new command block will expand below.

In this command block, complete the following fields exactly as shown:

Field	Value to Enter	Why It Matters
Trigger Name	`/stylish`	This is what users will type in chat to invoke your command. The leading slash is a convention that distinguishes bot commands from regular messages.
API Endpoint	`https://developers-hlgamingofficial-tests.vercel.app/api/dev-dumb-hlg`	This URL tells the platform where to send the request when the command is triggered. The parts wrapped in curly braces (`{name}`, `{count}`) are placeholders that the system will replace with actual values collected from the user.Like this is complete test api `https://developers-hlgamingofficial-tests.vercel.app/api/dev-dumb-hlg?name={name}&count={count}&apikey=8967798989`

3. Configure Parameters (Collecting User Input)

The API we’re using requires three parameters to work: name, count, and an apikey. You’ll configure two of these (name and count) to prompt the user, and you’ll hard-code the apikey so it’s sent automatically with every request.

name (no default): The base word you want stylized—users will type this in.
count (no default): How many decorative variants to generate—users enter a number.
apikey (default: 8967798989): A fixed value that authenticates your API request—no prompt shown to the user.

To set these up, click Add Param three times. For each row, fill in the columns like this:

Param name	Default value	Intro message (prompt shown to user)
`name`	(leave blank)	"Please enter the base name you’d like stylized (e.g. ‘ghost’)."
`count`	(leave blank)	"How many stylish variants would you like? Enter a number (e.g. ‘5’)."
`apikey`	`8967798989`	(no prompt; this is sent automatically)

Behind the scenes:
1. Once the bot sends any static replies (in the next step), the platform pauses and shows the first intro message—“Please enter the base name…”—waiting for your input.
2. After you type “ghost” (for example) and submit, it shows the second intro message—“How many stylish variants…”—and waits again.
3. When all required values are collected, the system substitutes them into the endpoint URL in place of {name} and {count}, adds the fixed apikey, and makes the HTTP request to the API.

4. Wire Up the Response Template (Parsing API Output)

When our test API runs, it returns JSON data containing a boolean success flag, an array of stylishNames, and a metadata object with details about authorship, website, purpose, inputs, and server IP. We need to tell the platform how to take that raw JSON and expose it to our static reply placeholders.

{
  "success": true,
  "stylishNames": [
    "ᴅghost彡★",
    "₫ghost𝓓",
    "★彡ghost𝕯𝖊𝖛",
    "✧ghostᴅ",
    "𝔇ghost𝔇",
    "₫ghost𝕯𝖊𝖛",
    "Ɗghost𝙳",
    "𝙳ghost⟆",
    "𝙳ghost★彡",
    "ᴅghostƊ"
  ],
  "metadata": {
    "authors": [
      "HL GAMING OFFICIAL"
    ],
    "website": "https://hlgamingofficial.com",
    "purpose": "Test API for HL Gaming developers",
    "inputs": {
      "name": "ghost",
      "count": 10
    },
    "ip": "37.111.179.248"
  }
}

Paste the following into the Response JSON Template box exactly:

{
  "success": true,
  "stylishNames": [
    "ᴅghost彡★",
    "₫ghost𝓓",
    "★彡ghost𝕯𝖊𝖛",
    "✧ghostᴅ",
    "𝔇ghost𝔇",
    "₫ghost𝕯𝖊𝖛",
    "Ɗghost𝙳",
    "𝙳ghost⟆",
    "𝙳ghost★彡",
    "ᴅghostƊ"
  ],
  "metadata": {
    "authors": [
      "HL GAMING OFFICIAL"
    ],
    "website": "https://hlgamingofficial.com",
    "purpose": "Test API for HL Gaming developers",
    "inputs": {
      "name": "ghost",
      "count": 10
    },
    "ip": "37.111.179.248"
  }
}

5. Add a Detailed Static Reply (User-Facing Message)

Static replies are the messages your bot sends after calling the API and before (or instead of) any further dynamic content. Here, we’ll use HTML tags to format a clear, multi-line response that lists each stylish variant alongside important metadata. In the “User Replies” section, paste exactly:

Hello! Here are {metadata.inputs.count} stylish names for {metadata.inputs.name}:

0 = {stylishNames.0}

1 = {stylishNames.1}

2 = {stylishNames.2}

3 = {stylishNames.3}

…

Author: {metadata.authors.0}

Website: {metadata.website}

Purpose: {metadata.purpose}

IP: {metadata.ip}

Thanks for using HL GAMING OFFICIAL!

Why this works:
– {metadata.inputs.count} and {metadata.inputs.name} confirm what the user asked for.
– Each {stylishNames.N} placeholder pulls the Nth element from the array of styled names.
– HTML <br> tags create line breaks, ensuring each list item appears on its own line. – Bold tags <b> highlight the count and name for emphasis. – Finally, metadata fields (author, website, purpose, IP) show provenance and build trust.

6. Save, Test Interactively, and Publish

You’re almost done! Now we’ll save your command, run a live test, and then publish it so anyone on the platform can start using your new bot.

Click the Save Command button at the bottom of the command block. This stores all your trigger, endpoint, parameters, template, and static reply settings.
Click Try It (or open a new chat window) and type:
/stylish ghost 5
If you include both parameters inline (ghost and 5), the bot skips the intro prompts and directly calls the API. Otherwise, it will pause and ask you each question in turn:
- "Please enter the base name you’d like stylized (e.g. 'ghost')."
- "How many stylish variants would you like? Enter a number (e.g. '5')."
After you answer, you’ll see “Bot is typing…” as the API request runs.
Within a second or two, your static reply appears with a numbered list of stylish names and the metadata block. Verify that:
- The count and base name match your inputs.
- You see exactly as many variants as you asked for (e.g. 5).
- The author, website, purpose, and IP fields display correctly.
If any text needs tweaking—maybe you want to reword your prompt or adjust formatting—simply edit the relevant fields and click “Save Command” again. You can immediately test again without republishing.
When everything looks perfect, flip the Published toggle at the top of your bot’s page to On. Congratulations—your bot is now live and discoverable by all HL Gaming users. Users can invoke /stylish in any supported chat and get creative, styled usernames in an instant.

Troubleshooting & Pro Tips

Parameter Order: The order in which you add parameters determines the sequence of prompts. If you swap count and name, you’ll first be asked for the number, then the word.
Field Picker: Use the 🔍 icon next to any template or reply textarea to browse available placeholders—you never have to type them manually.
Template Syntax: Ensure your JSON template’s field names exactly match the API’s JSON structure. A small typo (e.g. stylishnames instead of stylishNames) will break the mapping.
Edit On The Fly: You can update commands, responses, and static replies at any time. Changes go live immediately—no downtime or re-publishing required.
Experiment Freely: Once you’re comfortable, try adding rich “card” responses with images, fields, and buttons instead of plain text. The platform supports multiple content types.

Congratulations, Bot Hero!

You’ve just taken an idea—“make a list of fun, stylish usernames”—and turned it into a fully operational, published bot without writing a single line of server-side code. The HL Gaming Bot Platform handled all the complexity: authentication, HTTP requests, JSON parsing, dynamic parameter collection, and rendering in chat. All you had to do was define triggers, parameters, and templates.

From here, the sky’s the limit: integrate other public APIs, build multi-command bots, add conditional logic with {if}{else} blocks, or craft rich “card” responses with images, buttons, and more. You now have the knowledge to build bots that delight users, automate tasks, and showcase your creativity—all with a point-and-click interface. Go forth and build amazing experiences!

FAQ & Best Practices

Q: Can I define commands without parameters?: A: Absolutely. If you don’t need extra input, skip the parameters section and your API will be called immediately after static replies.
Q: Is there a limit on image size in image type?: A: We recommend hosting images under 1 MB and using optimized JPEG/PNG to keep chat loading fast.
Q: How do I include multiple fields in a card?: A: Use the fields array in your template—each object needs label and value.
Q: Can I change my bot’s name or description later?: A: Yes. Just edit the Name or Description field and click “Update Bot.” Be aware name changes must still satisfy uniqueness rules.
Q: What if I want to support buttons or links?: A: Coming soon! For now, focus on perfecting text, image, and card layouts. Future updates will let you define actions and embeds.

That’s it! You now have an in-depth, friendly roadmap to every field and feature in the HL Gaming Bot Developer Portal. Take your time, experiment with placeholders, static replies, and response templates, and delight users with polished, dynamic bots. Happy building!