engine-component

Create and register data-only ECS components for the Donburi game engine.

Updated Nov 16, 2025

Search Tags:#go #component #ecs #serialization #engine #inspector #donburi

Ready to run

npx skills add https://github.com/TheLazyLemur/engine --skill engine-component

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: engine-component
Source: https://github.com/TheLazyLemur/engine/tree/main/.claude/skills/engine-component
Command: npx skills add https://github.com/TheLazyLemur/engine --skill engine-component

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Create and register new ECS components for the Donburi-based game engine by providing a clear pattern for data containers, component type registration, and serialization compatibility.

Core Features & Use Cases

Data-driven component design: define component data structures and create constructor helpers to ensure consistent defaults.
Registration and serialization: wire new components into engine registration flows so they participate in serialization and editor tooling.
Insider guidance for editor integration: guidance on inspector tagging and patterns for editor-friendly components used by designers and developers.
Use Case: you are adding a new Rotator or Velocity component to the game to enable new entity behaviors.

Quick Start

Define a new component data type, register it with the engine, and enable editor support.

Frequently Asked Questions about engine-component

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I create and register new ECS components in a Donburi game engine?▼

To create ECS components in a Donburi game engine, define a data-only component structure, use a New<Name> constructor for defaults, and wire the type into engine registration flows to enable serialization and editor support.

What is the pattern for adding data-only ECS components with serialization support?▼

The pattern for data-only ECS components involves defining the data structure, applying consistent naming with New<Name> constructors, and hooking the type into registration flows so it participates in serialization and editor tooling.

How do I make custom ECS components inspector-friendly for game editors?▼

To make ECS components inspector-friendly, apply inspector tagging and use constructor helpers to ensure consistent defaults, allowing designers and developers to easily manage component data within the editor.

Does this component registration pattern support Go-based ECS architectures?▼

Yes, this ECS component registration pattern is designed for Go-based architectures, specifically targeting the Donburi game engine to wire entity behaviors into serialization and editor tooling.

When should I use New<Name> constructors for ECS component registration?▼

You should use New<Name> constructors during ECS component registration to establish consistent default values, ensuring the component data structure is properly initialized for serialization and editor integration.

What is the best way to extend entity behavior with new game components?▼

The best way to extend entity behavior is by defining a new data container, registering the component type with the engine, and enabling editor support to integrate new mechanics like velocity or rotation.