### Load and Start Particle System (YueScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/8.using-effect.mdx

Provides an example of creating a particle system instance, registering a callback for completion, and starting particle emission using YueScript syntax.

```yue
-- Import the Particle class
_ENV = Dora

-- Create a particle system object
particle = Particle "effect.par"

-- Register the particle system end callback
particle\onFinished () ->
	print "Particle system ended"

-- Start emitting particles
particle\start!
```

--------------------------------

### Install and Run Yarn Editor (Windows)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/120.dev-configuration.mdx

Installs dependencies, builds the Yarn editor, and starts it for Windows.

```sh
cd Tools\dora-dora && pnpm install
pnpm build-yarn-editor
pnpm start
```

--------------------------------

### Quick Start Example in C#

Source: https://github.com/ippclub/dora-ssr/blob/main/Tools/dora-cs/README.md

Demonstrates a basic game loop using Dora-CS, including sprite creation, scheduled coroutines for timed events, and action-based animations. Ensure Dora.dll is accessible.

```csharp
using Dora;
using System.Collections;

App.Run(() =>
{
    var node = new Sprite(Nvg.GetDoraSSR());
    node.Schedule(Co.Once(run));
    IEnumerator run()
    {
        for (int i = 3; i >= 1; i--)
        {
            Log.Info($"{i}");
            yield return Co.Seconds(1.0);
        }
        Log.Info("Hello World");
        node.Perform(ActionDef.Sequence(
        [
            ActionDef.Scale(0.1f, 1.0f, 0.5f),
            ActionDef.Scale(0.5f, 0.5f, 1.0f, EaseType.OutBack),
        ]));
    }
});
```

--------------------------------

### Start Local Development Server

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/README.md

Starts a local development server for live preview. Changes are reflected without a server restart.

```bash
pnpm start
```

--------------------------------

### Load and Start Particle System (Lua)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/8.using-effect.mdx

Demonstrates how to import the Particle class, create a particle system instance, register a callback for when the system finishes, and start emitting particles in Lua.

```lua
-- Import the Particle class
local Particle <const> = require("Particle")

-- Create a particle system object
local particle = Particle("effect.par")

-- Register the particle system end callback
particle:onFinished(function()
	print("Particle system ended")
end)

-- Start emitting particles
particle:start()
```

--------------------------------

### Install and Run Yarn Editor (macOS)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/120.dev-configuration.mdx

Installs dependencies, builds the Yarn editor, and starts it for macOS.

```sh
cd Tools/dora-dora && pnpm install
pnpm build-yarn-editor
pnpm start
```

--------------------------------

### start

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/HttpServer.mdx

Starts the HTTP server on the specified port.

```APIDOC
## start

### Description
Starts the HTTP server on the specified port.

### Signature
```tl
start: function(self: HttpServer, port: integer): boolean
```

### Parameters
#### Path Parameters
- **port** (integer) - Required - The port number on which to start the server.

### Returns
#### Success Response (boolean)
- **return value** (boolean) - A boolean value indicating whether the server started successfully.
```

--------------------------------

### Load and Start Particle System (TypeScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/8.using-effect.mdx

Illustrates importing the Particle class, creating a particle system instance, registering a callback for when the system finishes, and starting particle emission in TypeScript.

```ts
// Import the Particle class
import { Particle } from "Dora";

// Create a particle system object
const particle = Particle("effect.par");

// Register the particle system end callback
particle.onFinished(() => {
	print("Particle system ended");
});

// Start emitting particles
particle.start();
```

--------------------------------

### Install monaco-editor-locales-plugin

Source: https://github.com/ippclub/dora-ssr/blob/main/Tools/dora-dora/config/monaco-editor-locales-plugin/README.md

Install the plugin using npm.

```bash
npm install --save-dev monaco-editor-locales-plugin
```

--------------------------------

### Start Particle Emission

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Particle.mdx

Call the 'start' function to begin emitting particles from the system.

```tl
start: function(self: Particle)
```

--------------------------------

### Minimal Skill Example

Source: https://github.com/ippclub/dora-ssr/blob/main/Assets/Doc/skills/skill-creator/SKILL.md

A basic example of a SKILL.md file, including frontmatter and a simple body structure for an 'api-review' skill.

```markdown
---
name: api-review
description: Use this skill when the user asks for an API design or contract review.
---

# API Review

Use this skill when the user asks for an API design, contract, or request/response structure review.

## Steps

1. Read the relevant API definitions and call sites.
2. Check naming, consistency, error handling, and compatibility risks.
3. Output findings, risks, and suggested improvements.
```

--------------------------------

### ECS Framework: Scene Setup, Movement System, and Rendering Sync

Source: https://context7.com/ippclub/dora-ssr/llms.txt

Implements a full Entity-Component-System example including scene setup, a per-frame movement system, and observers for reacting to component changes. Uses `Entity`, `Group`, and `Observer` for managing game logic.

```lua
-- Lua: full ECS example — scene setup, movement system, rendering sync
local Entity   = require("Entity")
local Group    = require("Group")
local Observer = require("Observer")
local Sprite   = require("Sprite")
local Node     = require("Node")
local Vec2     = require("Vec2")
local Scale    = require("Scale")
local Roll     = require("Roll")
local Ease     = require("Ease")
local Director = require("Director")

-- Entity groups for querying
local sceneGroup    = Group {"scene"}
local positionGroup = Group {"position"}

-- React when a scene entity is added
Observer("Add", {"scene"}):watch(function(_entity, scene)
    Director.entry:addChild(scene)
    scene:onTapEnded(function(touch)
        positionGroup:each(function(e)
            e.target = touch.location
        end)
    end)
end)

-- React when an image component is added: create sprite
Observer("Add", {"image"}):watch(function(entity, image)
    sceneGroup:each(function(e)
        local sprite = Sprite(image)
        if sprite then
            sprite:runAction(Scale(0.5, 0, 0.5, Ease.OutBack))
            sprite:addTo(e.scene)
            entity.sprite = sprite
        end
        return true
    end)
end)

-- React when sprite is removed: clean up
Observer("Remove", {"sprite"}):watch(function(entity)
    entity.oldValues.sprite:removeFromParent()
end)

-- Per-frame movement system
Group({"position", "speed", "target"}):watch(function(entity, position, speed, target)
    if target == position then return end
    local dir    = (target - position):normalize()
    local newPos = (position + dir * speed):clamp(position, target)
    entity.position = newPos
    if newPos == target then entity.target = nil end
    entity.direction = math.deg(math.atan(dir.x, dir.y))
end)

-- Rendering sync observer
Observer("AddOrChange", {"position", "direction", "sprite"}):watch(function(entity, position, direction, sprite)
    sprite.position = position
    local last = entity.oldValues.direction or sprite.angle
    if math.abs(direction - last) > 1 then
        sprite:runAction(Roll(0.3, last, direction))
    end
end)

-- Bootstrap entities
Entity { scene = Node() }
Entity { image = "Image/logo.png", position = Vec2.zero, direction = 45.0, speed = 4.0 }
Entity { image = "Image/logo.png", position = Vec2(-100, 200), direction = 90.0, speed = 10.0 }

```

--------------------------------

### Create Game Start Interface

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/example/10.First Game Tutorial/8.gameflow.mdx

Sets up the initial game screen with a title and a start button. It manages input contexts and transitions to the game scene upon button tap.

```tsx
const Background = () => (
	<draw-node>
		<rect-shape width={width} height={height} fillColor={0xff4b6b6c}/>
	</draw-node>
);

const StartUp = () => {
	// Switch to the UI input context
	inputManager.popContext();
	inputManager.pushContext('UI');

	return (
		<>
			{/* Draw background */}
			<Background/>

			{/* Display title */}
			<label
				fontName='Xolonium-Regular'
				fontSize={80}
				text='Dodge the Creeps!'
				textWidth={400}
				y={200}
			/>

			{/* Create Start button */}
			<draw-node y={-150}>
				<rect-shape width={250} height={80} fillColor={0xff3a3a3a} />
				<label fontName='Xolonium-Regular' fontSize={60} text={'Start'} />

				{/* Button interaction logic */}
				<node
					width={250}
					height={80}
					onTapped={() => emit('Input.Start')}
					onMount={node => {
						node.gslot('Input.Start', () => {
							Director.entry.removeAllChildren(); // Clear current scene
							toNode(<Game />); // Enter game scene
						});
					}}
				/>
			</draw-node>
		</>
	);
};

```

--------------------------------

### start

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Platformer/Unit.mdx

Starts the "UnitAction" with the specified name, and returns true if the "UnitAction" was started successfully.

```APIDOC
## start

### Description
Starts the "UnitAction" with the specified name, and returns true if the "UnitAction" was started successfully.

### Signature
start: function(self: Unit, name: string): boolean

### Parameters
#### Path Parameters
- **name** (string) - Required - The name of the "UnitAction" to start.

### Returns
#### Success Response (boolean)
True if the "UnitAction" was started successfully, false otherwise.
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/README.md

Installs project dependencies using pnpm. Run this command in the project root.

```bash
pnpm install
```

--------------------------------

### Create Start Screen UI

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/example/10.First Game Tutorial/2.scene.mdx

Adds a start screen to the game's UI layer, including a background, title, and a start button. The start button emits an 'Input.Start' event when tapped.

```tsx
import { emit } from 'Dora';

const StartUp = () => {
	return (
		<>
			<Rect/>
			<label fontName='Xolonium-Regular' fontSize={80} text='Dodge the Creeps!' textWidth={400}/>
			<draw-node y={-150}>
				<rect-shape width={250} height={80} fillColor={0xff3a3a3a}/>
				<label fontName='Xolonium-Regular' fontSize={60} text='Start'/>
				<node width={250} height={80} onTapped={() => emit('Input.Start')}/>
			</draw-node>
		</>
	);
};

toNode(<StartUp/>)?.addTo(Director.ui);
```

--------------------------------

### Platformer.Visual.start

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Platformer/Visual.mdx

Starts playing the visual effect.

```APIDOC
## start

### Description

Starts playing the visual effect.

### Type

Function

### Signature

```tl
start: function(self: Visual)
```
```

--------------------------------

### get

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/HttpClient.mdx

Starts a non-blocking GET request. Returns a request handle that can be used to cancel the request.

```APIDOC
## get

### Description
Starts a non-blocking GET request.

### Signature
```tl
get: function(self: HttpClient, url: string, timeout: number, callback: function(data: string | nil)): integer
```

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to make the request to.
- **timeout** (number) - Optional - The request timeout in seconds (default is 5 seconds).
- **callback** (function) - Required - Called when the request finishes. It receives the response text, or nil if the request fails or is cancelled.

### Returns
- **integer** - The request handle, or 0 if the request cannot be scheduled.
```

--------------------------------

### Initialize QLearner Instance

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/105.Using Machine Learning/2.using-qlearning.mdx

Create a QLearner instance with specified gamma, alpha, and maxQ values. Gamma discounts future rewards, alpha controls learning rate, and maxQ limits Q-value growth.

```lua
local ML = require("ML")
local qLearner = ML.QLearner(0.5, 0.5, 100.0)
```

```tl
local ML = require("ML")
local qLearner = ML.QLearner(0.5, 0.5, 100.0)
```

```ts
import { ML } from "Dora";
const qLearner = ML.QLearner(0.5, 0.5, 100.0);
```

```yue
_ENV = Dora
qLearner = ML.QLearner 0.5, 0.5, 100.0
```

--------------------------------

### Get Pass from Effect

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Effect.mdx

Retrieves a Pass object from the Effect by its index. Indices start from 1.

```tl
get: function(self: Effect, index: integer): Pass
```

--------------------------------

### Initialize and Use InputManager

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/InputManager.mdx

Demonstrates how to create an InputManager, define input contexts and actions, activate a context, register a listener, and then clean up. Ensure to require the 'InputManager' module before use.

```tl
local InputManager = require("InputManager")
local inputManager = InputManager.CreateManager({
	context1 = {
		action1 = Trigger.KeyDown("W"),
	},
})
-- activate context1
inputManager:pushContext("context1")
-- add prefix "Input." to the listened action name
node:gslot("Input.action1", function()
	print("action1 triggered")
end)
-- remove context1 from the context stack
inputManager:popContext()
inputManager:destroy()
```

--------------------------------

### BOOT

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Module/tic80.mdx

The BOOT function is executed once at the start of the cartridge's execution, intended for initialization and setup code.

```APIDOC
## BOOT

### Description
The BOOT function is called a single time when your cartridge is booted. It should be used for startup/initialization code. For scripting languages that allow code in the global scope (Lua, etc.) using BOOT is preferred rather than including source code in the global scope.

### Signature
```tl
global BOOT: function()
```
```

--------------------------------

### Initialize Wa Project

Source: https://github.com/ippclub/dora-ssr/blob/main/Tools/dora-wa/README.md

Create a new Wa project and navigate into its directory. Ensure the 'name' field in 'wa.mod' is set to 'init'.

```sh
wa init -n hello_dora --wasi
cd hello_dora
```

--------------------------------

### Get File Extension

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Path.mdx

Extracts the file extension from a given path. For example, '/a/b/c.TXT' would return 'txt'.

```tl
Path:getExt("/a/b/c.TXT")
```

--------------------------------

### Import QLearner Module

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/105.Using Machine Learning/2.using-qlearning.mdx

Import the ML module and initialize a QLearner instance. Adjust gamma, alpha, and maxQ parameters as needed for your specific learning task.

```lua
local ML = require("ML")
local qLearner = ML.QLearner(0.5, 0.5, 100.0) -- Adjust gamma, alpha, maxQ as needed
```

```tl
local ML = require("ML")
local qLearner = ML.QLearner(0.5, 0.5, 100.0) -- Adjust gamma, alpha, maxQ as needed
```

```ts
import { ML } from "Dora";
const qLearner = ML.QLearner(0.5, 0.5, 100.0); // Adjust gamma, alpha, maxQ as needed
```

```yue
_ENV = Dora
qLearner = ML.QLearner 0.5, 0.5, 100.0 -- Adjust gamma, alpha, maxQ as needed
```

--------------------------------

### Initialize YarnRunner with Custom State and Commands

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/80.Writing Game Dialogue/2.using-yarn.mdx

Instantiate YarnRunner with the Yarn file path, starting node, initial state variables, and custom commands. The `playerScore` is an example of initial state, and `print` is an example of a custom command.

```lua
local runner = YarnRunner("tutorial.yarn", "Start", {
	playerScore = 100
}, {
	print = print
})
```

```tl
local runner = YarnRunner("tutorial.yarn", "Start", {
	playerScore = 100
}, {
	print = print
})
```

```typescript
const runner = YarnRunner("tutorial.yarn", "Start", {
	playerScore: 100
}, {
	print: print
})
```

```yuescript
runner = YarnRunner "tutorial.yarn", "Start", {
	playerScore: 100
}, {
	print: print
}
```

--------------------------------

### ImGui Window Creation (Teal)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Shows how to create an ImGui window with text in Teal. This example includes a return value, common in Teal's loop structures.

```tl
threadLoop(function(): boolean
	ImGui.Begin("Example Window", { "AlwaysAutoResize" }, function()
		ImGui.Text("This is an example window")
	end)
	return false
end)
```

--------------------------------

### Get Filename With Extension

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Path.mdx

Extracts the full filename including its extension from a given path. For example, '/a/b/c.TXT' would return 'c.TXT'.

```tl
Path:getFilename("/a/b/c.TXT")
```

--------------------------------

### Get Filename Without Extension

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Path.mdx

Extracts the filename without its extension from a given path. For example, '/a/b/c.TXT' would return 'c'.

```tl
Path:getName("/a/b/c.TXT")
```

--------------------------------

### ImGui Window Creation (YueScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Provides an example of ImGui window creation using YueScript's concise syntax. This version uses implicit returns and a more compact function definition.

```yue
threadLoop ->
	Begin "Example Window", [ "AlwaysAutoResize" ], ->
		Text "This is an example window"
```

--------------------------------

### Get Directory Path

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Path.mdx

Extracts the parent directory path from a given file path. For example, '/a/b/c.TXT' would return '/a/b'.

```tl
Path:getPath("/a/b/c.TXT")
```

--------------------------------

### Simple Input System Example

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/51.Using Input/2.using-enhanced-input.mdx

Defines an input context with a 'Ctrl+C' action using a sequence of key presses and listens for its completion. Requires importing InputManager and Node modules.

```lua
-- Import modules
local InputManager <const> = require("InputManager")
local Trigger <const> = InputManager.Trigger
local Node <const> = require("Node")

-- Create input manager with one context and one action
local input = InputManager.CreateManager({
	testContext = {
		["Ctrl+C"] = Trigger.Sequence({
			Trigger.KeyPressed("LCtrl"),
			Trigger.KeyDown("C")
		})
	}
})

-- Create a node to receive and process input events
local node = Node()

-- Connect global event signals; note the "Input." prefix matches the action's name
node:gslot("Input.Ctrl+C", function(state, progress, value) 
	if state == "Completed" then
		print("Ctrl+C triggered successfully")
		-- Remove the current active context, pressing Ctrl+C won't trigger again
		input:popContext()
	end
end)

-- Activate the testContext to enable its input triggers
input:pushContext("testContext")

```

```tl
-- Import modules
local InputManager <const> = require("InputManager")
local Trigger <const> = InputManager.Trigger
local Node <const> = require("Node")
local type Vec2 = require("Vec2")

-- Create input manager with one context and one action
local input = InputManager.CreateManager({
	testContext = {
		["Ctrl+C"] = Trigger.Sequence({
			Trigger.KeyPressed("LCtrl"),
			Trigger.KeyDown("C")
		})
	}
})

-- Create a node to receive and process input events
local node = Node()

-- Connect global event signals; note the "Input." prefix matches the action's name
node:gslot("Input.Ctrl

+C", function(state: InputManager.TriggerState, progress: number, value: number | boolean | Vec2.Type)
	if state == "Completed" then
		print("Ctrl+C triggered successfully")
		-- Remove the current active context, pressing Ctrl+C won't trigger again
		input:popContext()
	end
end)

-- Activate the testContext to enable its input triggers
input:pushContext("testContext")

```

```ts
import { Node, KeyName, Vec2 } from "Dora";
import { CreateManager, Trigger, TriggerState } from "InputManager";

-- Create input manager with one context and one action
const inputManager = CreateManager({
	testContext: {
		["Ctrl+C"]: Trigger.Sequence([
			Trigger.KeyPressed(KeyName.LCtrl),
			Trigger.KeyDown(KeyName.C)
		])
	}
});

-- Create a node to receive and process input events
const node = Node();

-- Connect global event signals; note the "Input." prefix matches the action's name
node.gslot("Input.Ctrl+C", (state: TriggerState, progress: number, value: number | boolean | Vec2.Type) => {
	if (state === TriggerState.Completed) {
		print("Ctrl+C triggered successfully");
		-- Remove the current active context, pressing Ctrl+C won't trigger again
		inputManager.popContext();
	}
});

-- Activate the testContext to enable its input triggers
inputManager.pushContext("testContext");

```

```yue
_ENV = Dora
import "InputManager" as :CreateManager, :Trigger

-- Create input manager with one context and one action
inputManager = CreateManager
	testContext:
		["Ctrl+C"]:
			Trigger.Sequence [
				Trigger.KeyPressed "LCtrl"
				Trigger.KeyDown "C"
			]

-- Create a node to receive and process input events
with Node!
	-- Connect global event signals; note the "Input." prefix matches the action's name
	\gslot "Input.Ctrl+C", (state, progress, value) ->
		if state == "Completed"
			print "Ctrl+C triggered successfully"
			-- Remove the current active context, pressing Ctrl+C won't trigger again
			inputManager\popContext!

-- Activate the testContext to enable its input triggers
inputManager\pushContext "testContext"

```

--------------------------------

### Example Project Structure for Module Imports

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/100.project-management.mdx

Illustrates a typical project directory layout for managing modules, including the init file and script organization.

```text
project/
├── init.lua
└── Script/
├── moduleA.lua
└── moduleB.lua
```

--------------------------------

### Get Relative Path

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Path.mdx

Calculates the relative path from a base path to a target path. For example, from '/a' to '/a/b/c.TXT' would result in 'b/c.TXT'.

```tl
Path:getRelative("/a/b/c.TXT", "/a")
```

--------------------------------

### Create a Simple ImGui Window

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Demonstrates creating a basic ImGui window with text and a separator. Ensure ImGui and threadLoop are required before use.

```lua
local ImGui <const> = require("ImGui")
local threadLoop <const> = require("threadLoop")

threadLoop(function()
	ImGui.Begin("Example Window", function()
		ImGui.Text("Welcome to ImGui with Dora SSR!")
		ImGui.Separator()
		ImGui.TextWrapped("This is a simple example window showcasing basic text and a separator.")
	end)
end)
```

```tl
local ImGui <const> = require("ImGui")
local threadLoop <const> = require("threadLoop")

threadLoop(function(): boolean
	ImGui.Begin("Example Window", function()
		ImGui.Text("Welcome to ImGui with Dora SSR!")
		ImGui.Separator()
		ImGui.TextWrapped("This is a simple example window showcasing basic text and a separator.")
	end)
	return false
end)
```

```ts
import { threadLoop } from "Dora";
import * as ImGui from "ImGui";

threadLoop(() => {
	ImGui.Begin("Example Window", () => {
		ImGui.Text("Welcome to ImGui with Dora SSR!");
		ImGui.Separator();
		ImGui.TextWrapped("This is a simple example window showcasing basic text and a separator.");
	});
	return false;
});
```

```yue
_ENV = Dora Dora.ImGui

threadLoop ->
	Begin "Example Window", ->
		Text "Welcome to ImGui with Dora SSR!"
		Separator!
		TextWrapped "This is a simple example window showcasing basic text and a separator."
```

--------------------------------

### Show Score Label After Game Start

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/example/10.First Game Tutorial/7.enemy.mdx

Make the score label visible after the 'Get Ready!' prompt is removed. This ensures the score display appears only when the game is actively running.

```tsx
world.once(() => {
	const msg = toNode(
		<label fontName='Xolonium-Regular' fontSize={80} text='Get Ready!' y={200}/>
	);
	sleep(1); // Remove the prompt after 1 second
	msg?.removeFromParent();
	if (label.current) {
		label.current.visible = true; // Show the score label
	}
	// Start spawning enemies
	// ...
});
```

--------------------------------

### Create VideoNode Instance (YueScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/10.using-video-node.mdx

Instantiate a VideoNode to play a video file. Provide the path to the .h264 video and optionally set it to loop.

```yue
_ENV = Dora

-- Create a VideoNode that plays once
video = VideoNode "assets/video.h264"

-- Create a VideoNode that loops
loopingVideo = VideoNode "assets/video.h264", true
```

--------------------------------

### Handle Collision Events

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/example/10.First Game Tutorial/5.physics.mdx

Attach an event listener to a physical entity to detect when it starts colliding with another object. This example logs a message when the player collides with an object in Group 0.

```ts
// Handle collision events
player.onContactStart(other => {
	if (other.group === 0) {
		print('Player collided with an enemy!');
	}
});
```

--------------------------------

### Hello World in YueScript

Source: https://github.com/ippclub/dora-ssr/blob/main/README.md

Basic 'Hello World' example in YueScript. Initializes a sprite and performs a sequence of actions, including a countdown and scaling, after the sprite loads.

```moonscript
_ENV = Dora

with Sprite "Image/logo.png"
   \once ->
     for i = 3, 1, -1
       print i
       sleep 1
     print "Hello World!"
     \perform Sequence(
       Scale 0.1, 1, 0.5
       Scale 0.5, 0.5, 1, Ease.OutBack
     )
```

--------------------------------

### Setup ZFP Compression Submodule

Source: https://github.com/ippclub/dora-ssr/blob/main/Source/3rdParty/bimg/3rdparty/tinyexr/README.md

To enable ZFP compression, first checkout the zfp repository as a submodule. This command initializes and updates the submodule.

```bash
git submodule update --init
```

--------------------------------

### Complete Q-Learning Example in Lua

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/105.Using Machine Learning/2.using-qlearning.mdx

This Lua code demonstrates a full Q-learning implementation for an agent learning to choose weapons. It includes setting up the QLearner, defining states and actions, simulating learning episodes with rewards, and testing the learned policy against different scenarios. Ensure the ML module is available.

```lua
-- Import the ML module
local ML = require("ML")

-- Create a QLearner instance with gamma, alpha, and maxQ set
local qLearner = ML.QLearner(0.5, 0.5, 100.0)

-- Define the number of possible values for each condition (hints)
-- Environment types: Forest (0), Desert (1), Snowy (2) => 3 types
-- Enemy types: Infantry (0), Tank (1) => 2 types
local hints = {3, 2}

-- Define action set
-- Use Handgun (1), Use Rocket Launcher (2), Use Sniper Rifle (3)
local actions = {1, 2, 3}

-- Simulate multiple learning iterations
for episode = 1, 1000 do
	-- Randomly generate the current environment and enemy type
	local environment = math.random(0, 2) -- 0: Forest, 1: Desert, 2: Snowy
	local enemy = math.random(0, 1) -- 0: Infantry, 1: Tank

	-- Use pack() method to combine current conditions into a unique state value
	local stateValues = {environment, enemy}
	local state = ML.QLearner:pack(hints, stateValues)

	-- Attempt to get the best action for the given state
	local action = qLearner:getBestAction(state)

	-- If there is no best action, randomly select an action (exploration)
	if action == 0 then
		action = actions[math.random(#actions)]
	else
		-- With a certain probability, choose a random action to explore new strategies (ε-greedy strategy)
		local explorationRate = 0.1 -- 10% chance to explore
		if math.random() < explorationRate then
			action = actions[math.random(#actions)]
		end
	end

	-- Execute the action and get a reward based on the current environment and enemy type
	local reward = 0
	if action == 1 then -- Use Handgun
		if enemy == 0 then -- Against Infantry (advantage)
			reward = 20
		else -- Against Tank (disadvantage)
			reward = -10
		end
	elseif action == 2 then -- Use Rocket Launcher
		if enemy == 1 then -- Against Tank (advantage)
			reward = 30
		else -- Against Infantry (disadvantage)
			reward = 0
		end
	elseif action == 3 then -- Use Sniper Rifle
		if environment == 2 then -- In Snowy environment (advantage)
			reward = 25
		else
			reward = 10
		end
	end

	-- Update Q value
	qLearner:update(state, action, reward)
end

-- Test learning results
print("Learning complete, starting tests...")

-- Define test scenarios
local testScenarios = {
	{environment = 0, enemy = 0}, -- Forest, against Infantry
	{environment = 1, enemy = 1}, -- Desert, against Tank
	{environment = 2, enemy = 0}, -- Snowy, against Infantry
}

for i, scenario in ipairs(testScenarios) do
	local stateValues = {scenario.environment, scenario.enemy}
	local state = ML.QLearner:pack(hints, stateValues)
	local action = qLearner:getBestAction(state)

	-- Display test results
	local envNames = {"Forest", "Desert", "Snowy"}
	local enemyNames = {"Infantry", "Tank"}
	local actionNames = {"Handgun", "Rocket Launcher", "Sniper Rifle"}

	print(string.format("Scenario %d: Environment-%s, Enemy-%s => Recommended Use %s",
		i,
		envNames[scenario.environment + 1],
		enemyNames[scenario.enemy + 1],
		actionNames[action]))
end
```

--------------------------------

### Install Dora SSR on Ubuntu

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/10.quick-start.mdx

Install Dora SSR on Ubuntu using the provided PPA. Ensure your package list is updated before installation.

```sh
sudo add-apt-repository ppa:ippclub/dora-ssr
sudo apt update
sudo apt install dora-ssr
```

--------------------------------

### YueScript Q-Learning Initialization

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/105.Using Machine Learning/2.using-qlearning.mdx

This YueScript snippet initializes a Q-learning agent, defining the environment and enemy types, and setting up the possible actions. It serves as the setup for the learning process.

```yuescript
-- Import the ML module
_ENV = Dora

-- Create a QLearner instance with gamma, alpha, and maxQ set
qLearner = ML.QLearner 0.5, 0.5, 100.0

-- Define the number of possible values for each condition (hints)
-- Environment types: Forest (0), Desert (1), Snowy (2) => 3 types
-- Enemy types: Infantry (0), Tank (1) => 2 types
hints = [3, 2]

-- Define action set
-- Use Handgun (1), Use Rocket Launcher (2), Use Sniper Rifle (3)
actions = [1, 2, 3]

```

--------------------------------

### Create and Configure Looping Video Node

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/10.using-video-node.mdx

Demonstrates creating a looping VideoNode, scaling it to fit the screen, and notes that playback starts automatically when mounted.

```lua
local VideoNode <const> = require("VideoNode")
local Vec2 <const> = require("Vec2")
local Size <const> = require("Size")

-- Create a looping video node
local video = VideoNode("assets/background_video.h264", true)

if video then
	-- Scale to fit screen if needed
	local visualSize = App.visualSize
	local videoSize = video.size
	local scaleX = visualSize.width / videoSize.width
	local scaleY = visualSize.height / videoSize.height
	local scale = math.min(scaleX, scaleY)
	video.scaleX = scale
	video.scaleY = scale

	-- Video will start playing automatically when mounted to scene
	-- It will continue playing and loop as long as the node is in the scene
end
```

```tl
local VideoNode <const> = require("VideoNode")
local Vec2 <const> = require("Vec2")
local Size <const> = require("Size")

-- Create a looping video node
local video = VideoNode("assets/background_video.h264", true)

if not video is nil then
	-- Scale to fit screen if needed
	local visualSize = App.visualSize
	local videoSize = video.size
	local scaleX = visualSize.width / videoSize.width
	local scaleY = visualSize.height / videoSize.height
	local scale = math.min(scaleX, scaleY)
	video.scaleX = scale
	video.scaleY = scale

	-- Video will start playing automatically when mounted to scene
	-- It will continue playing and loop as long as the node is in the scene
end
```

```ts
import { VideoNode, Vec2, Size, App } from "Dora";

// Create a looping video node
const video = VideoNode("assets/background_video.h264", true);

if (video) {
	// Scale to fit screen if needed
	const visualSize = App.visualSize;
	const videoSize = video.size;
	const scaleX = visualSize.width / videoSize.width;
	const scaleY = visualSize.height / videoSize.height;
	const scale = Math.min(scaleX, scaleY);
	video.scaleX = scale;
	video.scaleY = scale;

	// Video will start playing automatically when mounted to scene
	// It will continue playing and loop as long as the node is in the scene
}
```

```yue
_ENV = Dora

-- Create a looping video node
with VideoNode "assets/background_video.h264", true
	-- Scale to fit screen if needed
	visualSize = App.visualSize
	videoSize = .size
	scaleX = visualSize.width / videoSize.width
	scaleY = visualSize.height / videoSize.height
	scale = math.min scaleX, scaleY
	.scaleX = scale
	.scaleY = scale

	-- Video will start playing automatically when mounted to scene
	-- It will continue playing and loop as long as the node is in the scene

```

--------------------------------

### Install Dora SSR on macOS with Homebrew

Source: https://github.com/ippclub/dora-ssr/blob/main/README.md

Use this command to install Dora SSR on macOS using Homebrew. Ensure Homebrew is installed first.

```bash
brew install --cask ippclub/tap/dora-ssr
```

--------------------------------

### Create Editor Window with Toolbar and Status Bar (YueScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

This YueScript example illustrates the creation of a menu bar and status bar using ImGui.

```yue
_ENV = Dora Dora.ImGui

threadLoop ->
	Begin "Editor Main Window", ["MenuBar", "AlwaysAutoResize"], ->
		-- Toolbar
		BeginMenuBar ->
			BeginMenu "File", ->
				if MenuItem "New"
					print "New File"
				if MenuItem "Save"
					print "Save File"
			BeginMenu "Edit", ->
				if MenuItem "Undo"
					print "Undo Operation"

		-- Main content area
		Text "This is the main content area"
		Dummy Vec2 0, 100

		-- Status bar
		BeginChild "StatusBar", Vec2(0, 20), ->
			Text "Status: Ready"

```

--------------------------------

### Initialize PlatformWorld and Camera Settings

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/example/100.Platformer Tutorial/3.scene.mdx

Creates a `PlatformWorld` and configures its camera properties, including boundary, follow ratio, and zoom level. The `AppSizeChanged` slot ensures the zoom updates on screen resize.

```tl
local world = Platformer.PlatformWorld()
world.camera.boundary = Rect(-1250, -500, 2500, 1000)
world.camera.followRatio = Vec2(0.02, 0.02)
world.camera.zoom = View.size.width / DesignWidth
world:gslot("AppSizeChanged", function()
	world.camera.zoom = View.size.width / DesignWidth
end)
```

--------------------------------

### get

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/HttpServer.mdx

Registers a handler function for handling GET requests.

```APIDOC
## get

### Description
Registers a handler function for handling GET requests.

### Signature
```tl
get: function(
	sself: HttpServer,
	pattern: string,
	handler: function(Request): (table | string)
)
```

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The pattern to match the URL of the request.
- **handler** (function) - Required - The handler function to call when the pattern is matched. The function can return a Lua table which will be serialized to JSON, or return a string as plain text.
```

--------------------------------

### get

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Array.mdx

Gets the item at the specified 1-based index from the array.

```APIDOC
## get

**Type:** Function.

**Description:**

&emsp;&emsp;Gets the item at the given index.

**Signature:**
```tl
get: function(self: Array, index: integer): Item
```

**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| index | integer | The index to get, should be 1 based. |

**Returns:**

| Return Type | Description |
| --- | --- |
| Item | The item value. |

```

--------------------------------

### File and Asset Management with Content Module (Lua)

Source: https://context7.com/ippclub/dora-ssr/llms.txt

Demonstrates using the Content module for file system operations. Includes adding search paths, synchronous and asynchronous file loading, saving to writable directories, and listing directory contents.

```lua
-- Lua: search paths, sync read, async load, write to writable dir
local Content = require("Content")
local Path    = require("Path")
local thread  = require("thread")

-- Add the current script's directory to the search path
Content:insertSearchPath(1, Path:getScriptPath(...))

-- Synchronous read (small config files)
local config = Content:load("config/settings.json")
if config then
    print("Config: " .. config)
end

-- Asynchronous load (large assets, textures, etc.)
thread(function()
    local atlas = Content:loadAsync("Image/atlas.png")
    print("Atlas loaded: " .. tostring(atlas ~= nil))
end)

-- Write to the writable path (save-game data, user settings)
local savePath = Path(Content.writablePath, "saves", "slot1.json")
Content:save(savePath, '{"level":5,"score":3200}')

-- List all files in a directory
local files = Content:getFiles("Image")
for _, f in ipairs(files) do
    print("Image asset: " .. f)
end
```

--------------------------------

### Create Editor Window with Toolbar and Status Bar (Teal)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

This Teal example demonstrates creating a menu bar and status bar using ImGui functions.

```tl
local ImGui <const> = require("ImGui")
local threadLoop <const> = require("threadLoop")
local Vec2 <const> = require("Vec2")

threadLoop(function(): boolean
	ImGui.Begin("Editor Main Window", { "MenuBar", "AlwaysAutoResize" }, function()
		-- Toolbar
		ImGui.BeginMenuBar(function()
			ImGui.BeginMenu("File", function()
				if ImGui.MenuItem("New") then
					print("New File")
				end
			if ImGui.MenuItem("Save") then
				print("Save File")
			end
		end)
		ImGui.BeginMenu("Edit", function()
			if ImGui.MenuItem("Undo") then
				print("Undo Operation")
			end
		end)
	end)

		-- Main content area
		ImGui.Text("This is the main content area")
		ImGui.Dummy(Vec2(0, 100))

		-- Status bar
		ImGui.BeginChild("StatusBar", Vec2(0, 20), function()
			ImGui.Text("Status: Ready")
		end)
	end)
	return false
end)
```

--------------------------------

### Optimized ImGui Window Creation (TypeScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Optimized TypeScript example showing how to define window flags and draw functions as constants outside the main thread loop for efficiency.

```ts
const windowFlags = [ WindowFlag.AlwaysAutoResize ];
const drawFunction = () => {
	ImGui.Text("This is an example window");
};
threadLoop(() => {
	ImGui.Begin("Example Window", windowFlags, drawFunction);
	return false;
});
```

--------------------------------

### OutInCubic

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Ease.mdx

Starts fast, decelerates, then accelerates, creating a rapid start, a slowdown, and then a speed-up.

```APIDOC
## OutInCubic

### Description
An easing function that starts fast, decelerates, then accelerates.

### Signature
```tl
const OutInCubic: EaseFunc
```
```

--------------------------------

### ImGui Window Creation (Lua)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Demonstrates basic ImGui window creation and text display in Lua. Use this for simple UI elements within the ImGui immediate mode framework.

```lua
threadLoop(function()
	ImGui.Begin("Example Window", { "AlwaysAutoResize" }, function()
		ImGui.Text("This is an example window")
	end)
end)
```

--------------------------------

### Install dependent packages for Linux (Ubuntu/Debian)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/120.dev-configuration.mdx

Install necessary development packages for building on Ubuntu/Debian.

```sh
sudo apt-get update
sudo apt-get install -y libsdl2-dev libgl1-mesa-dev libssl-dev libx11-dev lua5.1 luarocks
```

--------------------------------

### YueScript Function Call at Block Start

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/25.Language Tutorial/2.yuescript-15min.mdx

Demonstrates how a function call can initiate a block, with its arguments spanning multiple lines and potentially having different indentation levels.

```yue
if func 1, 2, 3, -- called as func(1, 2, 3, "hello", "world")
		"hello",
		"world"
	print "hello"
```

--------------------------------

### OutInQuart

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Ease.mdx

Starts fast, decelerates sharply, then accelerates sharply, resulting in a rapid start, a sharp slowdown, and then a sharp speed-up.

```APIDOC
## OutInQuart

### Description
An easing function that starts fast, decelerates sharply, then accelerates sharply.

### Signature
```tl
const OutInQuart: EaseFunc
```
```

--------------------------------

### Hello World in Lua

Source: https://github.com/ippclub/dora-ssr/blob/main/README.md

Basic 'Hello World' example in Lua. Initializes a sprite, waits for it to load, then performs a sequence of actions including a countdown and scaling.

```lua
local _ENV = Dora

local sprite = Sprite("Image/logo.png")
sprite:once(function()
  for i = 3, 1, -1 do
    print(i)
    sleep(1)
  end
  print("Hello World")
  sprite:perform(Sequence(
    Scale(0.1, 1, 0.5),
    Scale(0.5, 0.5, 1, Ease.OutBack)
  ))
end)
```

--------------------------------

### Install Dora CLI using uv

Source: https://github.com/ippclub/dora-ssr/blob/main/Tools/dora-cli/README.md

Installs the Dora SSR CLI tool using the uv package manager.

```bash
uv tool install Dora-SSR/Tools/dora-cli
```

--------------------------------

### ImGui Window Creation (TypeScript)

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/95.using-imgui.mdx

Illustrates ImGui window setup using TypeScript syntax. Note the use of enums for window flags and arrow functions.

```ts
threadLoop(() => {
	ImGui.Begin("Example Window", [ WindowFlag.AlwaysAutoResize ], () => {
		ImGui.Text("This is an example window");
	});
	return false;
});
```

--------------------------------

### Start Visual Effect

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Platformer/Visual.mdx

Call the 'start' function to begin playing a visual effect. This function takes the visual object itself as an argument.

```typescript
start: function(self: Visual)
```

--------------------------------

### Load Singlepart EXR from File

Source: https://github.com/ippclub/dora-ssr/blob/main/Source/3rdParty/bimg/3rdparty/tinyexr/README.md

This example demonstrates a detailed process for loading a singlepart EXR file by first parsing its version and header, then loading the image data. It includes error handling and resource cleanup.

```cpp
  EXRVersion exr_version;

  int ret = ParseEXRVersionFromFile(&exr_version, argv[1]);
  if (ret != 0) {
    fprintf(stderr, "Invalid EXR file: %s\n", argv[1]);
    return -1;
  }

  if (exr_version.multipart) {
    return -1;
  }

  EXRHeader exr_header;
  InitEXRHeader(&exr_header);

  const char* err = NULL;
  ret = ParseEXRHeaderFromFile(&exr_header, &exr_version, argv[1], &err);
  if (ret != 0) {
    fprintf(stderr, "Parse EXR err: %s\n", err);
    FreeEXRErrorMessage(err);
    return ret;
  }

  EXRImage exr_image;
  InitEXRImage(&exr_image);

  ret = LoadEXRImageFromFile(&exr_image, &exr_header, argv[1], &err);
  if (ret != 0) {
    fprintf(stderr, "Load EXR err: %s\n", err);
    FreeEXRHeader(&exr_header);
    FreeEXRErrorMessage(err);
    return ret;
  }

  FreeEXRImage(&exr_image);
  FreeEXRHeader(&exr_header);

```

--------------------------------

### OutInQuint

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/api/Class/Ease.mdx

Starts fast, decelerates extremely quickly, then accelerates extremely quickly, resulting in a very rapid start, a sharp slowdown, and then a sharp speed-up.

```APIDOC
## OutInQuint

### Description
An easing function that starts fast, decelerates extremely quickly, then accelerates extremely quickly.

### Signature
```tl
const OutInQuint: EaseFunc
```
```

--------------------------------

### Start and Stop Particle Emission

Source: https://github.com/ippclub/dora-ssr/blob/main/Docs/docs/tutorial/50.Using Nodes/8.using-effect.mdx

Control the emission of particles using the start() and stop() methods. Use these to activate or deactivate the particle effects as needed.

```lua
particle:start() -- Start emitting particles
particle:stop()  -- Stop emitting particles
```

```tl
particle:start() -- Start emitting particles
particle:stop()  -- Stop emitting particles
```

```ts
particle.start(); // Start emitting particles
particle.stop();  // Stop emitting particles
```

```yue
particle\start! -- Start emitting particles
particle\stop! -- Stop emitting particles
```

--------------------------------

### Build ZFP Library

Source: https://github.com/ippclub/dora-ssr/blob/main/Source/3rdParty/bimg/3rdparty/tinyexr/README.md

After checking out the ZFP submodule, navigate to its directory and build the library. Ensure the 'lib' directory exists before running make.

```bash
cd deps/ZFP
mkdir -p lib
make
```

--------------------------------

### Run Dora CLI without installation

Source: https://github.com/ippclub/dora-ssr/blob/main/Tools/dora-cli/README.md

Executes the Dora CLI using uvx without installing it globally. Useful for quick checks or testing.

```bash
uvx --from Tools/dora-cli dora --help
```