> For the complete documentation index, see [llms.txt](https://help.smartico.ai/welcome/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.smartico.ai/welcome/products/ai-agents/ai-agent-doodle-game-creator.md).

# AI Agent: Doodle Game Creator

{% hint style="warning" %}
**This agent is retired.** Create doodles in **Vibe Studio** instead: open the Pop-up list, click **Create** and choose **Doodle with Vibe Studio**. Vibe Studio has 47 ready doodles, builds your own doodle from a short description, and lets your team save doodles as templates. See [Doodles](https://help.smartico.ai/welcome/products/crm-automation/communication-channels/doodles). Doodles you made with this agent keep working.
{% endhint %}

The Doodle Game Agent creates and customizes promo games for use in Campaign pop-ups. It can rebrand the game’s look and feel, update labels and visuals, and apply focused changes based on your instructions. The agent works on the currently loaded game template, so you can iterate quickly and see updates in preview as you go.

### Choosing a Starter Template

When launching the Doodle Creator Agent from the AI Assistant, you can start from a blank slate or select from a library of ready-to-use game templates:

* **Tic Tac Toe** — classic 3x3 turn-based board game against AI.
* **Memory Game** — card-matching game where players flip pairs.
* **Brick Breaker** — paddle-and-ball arcade game.
* **Puzzle Slider** — sliding-tile image unscrambling game.
* **Tap Frenzy** & **Mouse Hunt** — reaction-time and target-clicking mini-games.
* **Hungry Cat** — casual interactive feeding game.
* **Make your own game! (Blank Template)** — generate custom game rules and layouts completely from scratch.

{% embed url="<https://vimeo.com/1170593969>" %}

### What are Doodle Games?

Doodle Games are simple, highly engaging popups featuring primitive, casual games - such as Tic-Tac-Toe or Memory Game. Instead of using a standard, static communication pop-up (e.g., *"Here are your 3 free spins, claim them now"*), Doodle Games allow you to deliver rewards to your users in a fun, interactive, and gamified way.

The core philosophy of a Doodle Game is the guarantee of a win. Even if a player loses a round, they can try again without any limits or attempt costs until they succeed. The goal isn't to challenge the user, but to make the act of receiving a reward much more entertaining.

For creating standard promotional or informational pop-ups without game mechanics, see [AI Agent: Popups Builder](/welcome/products/ai-agents/ai-agent-popups-builder.md).

### Doodle Games vs. Mini-Games

While both features add gamification to your platform, their mechanics and use cases are completely different:

* [**Mini-games**](/welcome/products/mini-games.md)**:** These are random-reward games (like Spin the Wheel or Scratch & Catch). They are powered by a complex prize engine. Operators configure win probabilities, a pool of varying prizes, and the cost of an attempt (e.g., spending loyalty points to spin). A user relies on chance and can win different prizes based on the configured odds.
* **Doodle Games:** These do not have a prize engine behind them. There are no odds, probabilities, or random prize pools. Doodle Games are simply interactive wrappers for a pre-determined reward. The player plays the game, eventually wins, and gets the exact prize you set up in your campaign flow.

### How to create or restyle the Doodle Game? <a href="#how-to-use-it" id="how-to-use-it"></a>

1. Write your styling requirements to the agent by describing colors, shapes, typeface, buttons, etc. If you attach a reference image of the style you want, it will generate a better result since it will take the style from the pic on its own.
2. Review the generated game in preview and request targeted updates (for example: colors, labels, icons, background, or piece style). We’ve found that specifying exactly what you want to change and what you want to keep gets us better results.
3. If you want specific assets, upload your own images (logo, sprite, icon, or background) and ask the agent to use them and explain where they should be used.\
   When you are happy with the result, click **Publish** to save the template and use it in your pop-up setup.

<div data-with-frame="true"><figure><img src="https://77049817-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfS5hl0PiysHtKAKMsQTe%2Fuploads%2FsQqHDSugNHNtTqNLwLhS%2FAI%20Chats%20-%20smartico.ai%20%40%20EU2%202026-03-05%2007-37-39.png?alt=media&amp;token=c6d1eda1-2408-4675-8625-0d6940118d55" alt=""><figcaption></figcaption></figure></div>

Note:

* The best results are achieved when you provide a clear visual direction and a reference image.
* For cleaner iterations, request one change at a time (for example: “change only the replay button text”).
* The agent can use uploaded assets directly or generate new images if needed.
* The agent customizes the game template itself; the final campaign/business-logic setup is still done by you in the relevant platform sections.

### Manual Code & Configuration Editing

In addition to prompting the AI agent, the Doodle Creator interface includes a side panel with Code and Preview views. You can view the generated HTML, CSS, JavaScript, and configuration JSON at any time. Operators with web development experience can manually edit code, tweak styling values, update config fields, and save drafts directly without submitting further AI prompts.

### How to Set Up and Award Prizes with Doodle Games?

Because Doodle Games don't use a native prize engine, the reward distribution is managed entirely through the Flow Builder.

The Mechanics behind the Game: When a player successfully completes the game and clicks the "Claim Prize" button, the game triggers a specific deep link: `dp:doodle_win`. This deep link tells the Smartico platform: *"The player won this game!"* so that the platform knows it is time to drop the reward.

Here is Step-by-Step Configuration Guide...

**Step 1: Create your Doodle Popup**

1. Once you finish creating your doodle game and click "Publish" in the Doodle creation agent, navigate to the Popups section in your Smartico back-office.
2. Create a new pop-up based on this newly published Doodle Game.
3. Customize it to fit your case by adjusting images, tweaking the text, and setting up any needed localizations in the "Variations" tab.

Because the Doodle Game template exposes its text strings under the "Texts & Labels" configuration section, you can translate game titles, win messages, and button labels for each supported language in the **Content Variations** tab of the Pop-up editor without modifying the underlying code or recreating the game.

**Step 2: Connect the Reward in the Flow Builder of the Journey or Scheduled campaign**

1. Open the Flow Builder for the campaign you want to feature the Doodle Game in.
2. Drag a Popup node onto the canvas and select the Doodle popup you created in Step 1.

<div data-with-frame="true"><figure><img src="https://77049817-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfS5hl0PiysHtKAKMsQTe%2Fuploads%2Fol0YjVGa99E5dmTJw0b9%2Fimage.png?alt=media&amp;token=a566c62f-b18b-47fd-963d-a81f35d18625" alt=""><figcaption></figcaption></figure></div>

3. On the Popup node, look for the output connection labeled `dp:doodle_win` *(This represents the moment the user clicks the "Claim Prize" button).*
4. Drag a Reward node (e.g., Bonus, Points, Gems, Free Spins) onto the canvas and configure the exact prize you want to give away.
5. Connect the `dp:doodle_win` output from the Popup node directly to the Reward node.

<div data-with-frame="true"><figure><img src="https://77049817-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfS5hl0PiysHtKAKMsQTe%2Fuploads%2F7PNvJDM1Ho5d8YTJEnrl%2Fimage.png?alt=media&amp;token=654fc97f-abf7-4a32-a623-aee8f3299091" alt=""><figcaption></figcaption></figure></div>

That's it! When the campaign is active, the user will be greeted with a fun game, play until they win, and seamlessly receive the reward you connected in the flow.

### **Prompt example: creating a new Doodle game from scratch**

**Describe your goal**

```markdown
The idea:
- Let's make a mix between 2 games: Reversi and chess. 
- We will use an 8-by-8 board. 
- The game will start with 4 pieces placed diagonally (2 white, 2 black). 
- Since there would need to be 2 'people playing, the user will need to play against the AI.
```

**Describe the game's rules.**

```md
 Rules:
 - Each player must make one move per turn, unless they cannot make any, in which case the turn passes to the opponent.
 - A move consists of placing a piece so that it flanks one or more pieces of the opposite color and flipping those pieces over to show that player's own color.
 - All pieces that were flanked in that turn are flipped over when placing the opposite-color piece.
 - For these pieces to be flanked, they must form a continuous straight line (diagonal or orthogonal) of the same color between two pieces of the opposite color (one of them the newly placed piece and the other already present). The game ends when no player can move (usually when the board is full of pieces), and the player with the most pieces of their color on the board at that moment wins
 - We will add to the reversi pieces the "power" of the chess pieces (these will be special pieces), based on how chess pieces move inside the board:
    - horse: L movement - therefore, the pieces with an opposite colour inside this L movement will be considered as flanked, and will turn colors
    - queen: diagonal, vertical, horizontal movements - the pieces with an opposite colour inside this movement will be considered as flanked, and will turn colors
    - bishop: diagonal movement - the pieces with an opposite colour inside this movement will be considered as flanked, and will turn colors
    - tower: horizontal and vertical movements: - the pieces with an opposite colour inside this movement will be considered as flanked, and will turn colors
 - Each side will have 2 towers, 2 bishops, 2 horses, and only one queen

```

**Describe the user flow**

```markdown
User flow: 
- User lands on a screen where they need to choose the color they want to play with
- The game starts with white in an 8 x 8 board, where there are 4 pieces sorted diagonally by color
    - The game will have a counting board for each color, saying how many tiles belong to which color
- The game continues playing until:
    - winning: when the user wins with a button for play again, and displays the prize won
    - losing: when the AI wins with a button for play again
    - no possible next move (then the player with more pieces wins)
- If the player stays idle for more than 5 sec., please show the best next game play.
```

**Describe the User Interface (the style)**

{% hint style="info" icon="circle-exclamation" %}
Important: attach the image with reference to the styling that you want to achieve. The agent will get the idea much better from the image instead of a verbal explanation
{% endhint %}

```markdown
 UI: 
 - Please use a decadent visual as the UI.
 - Colors are fading: white is yellowish, black is faded, and pieces are broken. 
 - The board also has cracks; everything is placed in a military perspective. 
 - The pieces will be circular in shape, and special pieces will have an inscription in the center with each symbol (queen, bishop, horse, tower). 
 - I am sharing some references for how I would like the visuals to look in an image.
```

**Describe the tone and copy**

```
Use an old form of English. Some messages to display:
- Splash screen: Choose your alliance
- When winning: “Congrats, you are our hero.”
- When losing: “Oh no, doom has come to us.”
- Button for play again: "Let's go to war again!"
```

**Final result**

<div data-with-frame="true"><figure><img src="https://77049817-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfS5hl0PiysHtKAKMsQTe%2Fuploads%2F835MiaZVjH4KdxjIfXgg%2Fimage.png?alt=media&amp;token=a4318537-b52d-43a7-b2ad-2475c3d33072" alt="" width="375"><figcaption></figcaption></figure></div>

### **Prompt example: restyle the existing Doodle Game**<br>

**Describe your goal**

```
 The idea:
 - Rebrand a standard Tic-Tac-Toe game into an immersive, retro-futuristic hacking simulation titled "SYSTEM FAILURE." 
 - The game is no longer a friendly match. 
 - It is a battle against a sentient, rogue AI attempting to "lock" the player out of a terminal
```

**Describe the User Interface**

<pre><code><strong> Visual &#x26; UI Aesthetic:
</strong> - The Screen: A high-contrast, monochromatic CRT monitor effect (Amber or Emerald Green). Include flickering scanlines, a subtle screen bulge, and occasional "digital glitches" where the board momentarily tears or shifts.
 - The Board: Use a 3x3 grid made of ASCII characters (using +, -, and |) or glowing vector lines.
 - The Symbols: Replace 'X' and 'O' with a "System Breach" (a glitchy Skull icon) and a "Firewall Core" (a Shield or Hexagon).
 - Background Elements: A side panel with a scrolling "Kernel Log" that updates with hex code and system warnings in real-time.
</code></pre>

**Describe the tone and copy**

```
 The AI "Sentience" Logic
 - Personality: The AI is arrogant and "aware." It doesn't just play; it reacts. When it moves, it should display "thinking" strings like [CALCULATING HUMAN ERROR...] or [BYPASSING PLAYER LOGIC...].
 - Dialogue: If the player is winning, the AI should trigger "Corrupted" messages like CRITICAL ERROR: Logic breach detected. If the AI wins, it should display: User Access Revoked. System Purge Initiated.
```

**You can ask for functionality changes (not required)**

{% code fullWidth="false" %}

```
 Mechanical "Glitch" Features:
- The Sabotage Move: 
  - Implement a function where, once per game, the AI "hacks" the board. 
  - It should be able to force a "System Reboot" that clears one random row or "Corrupts" a square, making it unplayable for 2 turns.
- Entropic Decay: 
  - Every 5 moves, a random piece on the board should "flicker" and change its state or position, representing the system's breakdown.
```

{% endcode %}

**Final result**

<div data-with-frame="true"><figure><img src="https://77049817-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfS5hl0PiysHtKAKMsQTe%2Fuploads%2F0AjQJCvyKwHOVwgexe6h%2Fimage.png?alt=media&amp;token=f313e327-c998-438b-95a6-c6e2f59803e7" alt="" width="375"><figcaption></figcaption></figure></div>

### Best Practices to create/restyle the Doodle game <a href="#best-practices" id="best-practices"></a>

* **Be specific:** include exact colors, labels, style references, and what should stay unchanged.
* **Use focused follow-ups:** Ask for small, targeted edits instead of broad re-generation.
* **Refer to real assets when available:** Upload your own brand/logo/game elements for the most accurate result.
* **Iterate in steps:** Approve the main direction first, then fine-tune details.

### Frequently Asked Questions

**Can players lose their reward or run out of attempts in a Doodle Game?**

No. Doodle Games are built on a guaranteed-win mechanic. Losing or drawing a round allows the player to replay immediately at no attempt cost and without consuming campaign tickets, ensuring every targeted player eventually reaches the win screen to claim their reward.

**Can a Doodle Game deliver different random prizes like Spin the Wheel?**

No. Unlike Mini-Games, Doodle Games do not have an internal probability or random prize engine. The exact prize awarded is determined by the Reward node connected to the `dp:doodle_win` connection in your campaign Flow Builder. To award varying rewards, connect the flow to conditional branches or use a native Mini-Game.

**Why is the `dp:doodle_win` connection missing from my Flow Builder Popup node?**

The Flow Builder dynamically generates connection ports from the URL-type fields defined in the pop-up's underlying template. If `dp:doodle_win` does not appear, ensure you have created and selected a pop-up based on your published Doodle Game template rather than a standard static pop-up template.

**Can I update game texts and images later without reopening the AI agent?**

Yes. All game labels, button texts, and prize images defined during creation are saved as configurable template fields. You can adjust them at any time in the Pop-up settings or Content Variations tab in the Back-Office.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://help.smartico.ai/welcome/products/ai-agents/ai-agent-doodle-game-creator.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
