dora-ssr Documentation

Dora SSR is a game development engine designed for fast development across multiple devices (smartphones, handhelds, desktops). It provides a complete toolkit including a Web IDE and an LLM-powered Coding Agent.

Key capabilities include:

• Scene Management: Tree-based 2D and 3D scenes with physics, lighting, and animation.
• Programming Models: Supports multiple languages including Lua (via YueScript and Teal), TypeScript (with TSX), Wa, Rust, and C#.
• Visual Tools: Built-in Web IDE with specialized editors for particles, physics, visual-script, Spine, tile-maps, and Git; plus a Scratch-like Blockly environment.
• Data & Logic: ECS module for entity management, asynchronous processing for I/O, SQLite for data management, and Excel synchronization.
• Multimedia: Support for H.264 video, various audio formats (FLAC, OGG, MP3, WAV) with 3D spatial sound, and Effekseer effects.
• UI & Layout: CSS Flex layout for adaptive scenes, ImGui for debugging, and vector graphics (SVG) rendering.

The Dora SSR API is organized into several functional domains to support game development. Key domains include:

• Basic Functionality: Core engine services like App, View, and Profiler.
• Asset & Data Management: Handling files, paths, caching, and databases via Content, Path, Cache, DB, and Git.
• Input Management: Processing keyboard, mouse, and controller input via InputManager (note: tap/touch events are handled via node events).
• Scene & Tree Management: Managing the game hierarchy using Director, Scheduler, and various Camera types, along with Node and specialized nodes like AlignNode or Menu.
• Graphics Rendering: 2D rendering (Sprites, Grids, Labels, etc.) and 3D rendering (Node3D, Model3D, Camera3D, etc.).
• Physics: 2D physics simulation (PhysicsWorld, Body) and 3D physics (PhysicsWorld3D, Body3D).
• ECS Framework: Entity-Component-System capabilities using Entity, Group, and Observer.
• Specialized Systems: Includes a Platformer Game Framework, Coroutine Management, Machine Learning (C4.5, Q-learning), Dialogue Systems (YarnRunner), and Networking (HttpClient, HttpServer).

Miniz provides several compression and archive capabilities:

• zlib/Deflate Compatibility: Acts as a drop-in replacement for the most commonly used zlib APIs. It is a completely independent implementation, meaning zlib's licensing requirements do not apply.
• Stream-based Processing: Unlike block-based compressors, Miniz supports stream-based processing using a coroutine-style implementation. The zlib-style API functions can be called one byte at a time.
• Low-level Codecs: The tdefl (compressor) and tinfl (decompressor) APIs use simple state structs that can be saved/restored via memcpy. These low-level APIs do not use the heap.
• Archive Management: Includes a set of APIs for reading, writing, and appending .ZIP format archives, designed for embedded, mobile, or game development.
• Image Support: Contains simple functions for writing .PNG format image files.
• Performance: Tuned to be comparable to zlib. It includes a specialized real-time compressor designed to compete with fastlz/minilzo.

The ActionEditor is a visual Web IDE component within the dora-dora toolset designed for editing Dora .model files. It provides a canvas-based interface using WebGL and imgui-ts to manage sprites, animations, keyframes, and look settings.

Key capabilities include:

• Model Management: Parsing and serializing .model XML files, including handling malformed files by creating empty models.
• Visual Editing: A WebGL-powered canvas for sprite manipulation (move, rotate, scale, anchor, size) via gizmos, node tree hierarchy, and property panels.
• Animation Workflow: A timeline with a 60fps grid, keyframe management (add, delete, copy, paste, move), and playback controls (play, pause, loop, easing).
• Atlas Packing: Converting .clips input into .clip and .png output files.
• Integration: Seamlessly integrated into the Web IDE for creating, opening, and saving Dora animation files.

The Dora Game UI component library is designed to allow developers to rapidly build game interfaces (HUD, menus, inventories, dialogue, etc.) using a React-like dynamic TSX syntax. It leverages AlignNode for Yoga/Flexbox layout and NanoVG-style vector drawing for scalable, low-resource visual performance.

Key Design Goals:

• Fast Onboarding: Use TSX composition instead of complex rendering pipelines.
• Runtime Mutability: Use DoraX signal and createRoot() for dynamic updates (states, lists, progress bars).
• Reliable Layout: Use AlignNode's style for dimensions, spacing, alignment, and positioning.
• Lightweight Drawing: Default to calling nvg drawing functions directly in a Node's render callback to avoid excessive off-screen textures.
• Themable: Visuals are driven by theme tokens, component variants, and painter functions.
• Full Input Support: Covers touch, mouse, keyboard, and gamepad (hover, pressed, selected, disabled, focused, etc.).