dacha 0.16.0 → 0.17.0

package/build/contrib/components/animatable/index.d.ts

@@ -3,10 +3,36 @@ import { IndividualState } from './individual-state';
 import { GroupState } from './group-state';
 import type { AnimatableConfig } from './types';
 export type { AnimatableConfig };
+/**
+ * Animatable component for managing animations.
+ *
+ * It provides a state machine for an actor to manage its animations.
+ * Each state can have a set of transitions to other states,
+ * and each transition describes a set of conditions to check before the transition is triggered.
+ *
+ * State consists of a timeline of frames where each frame represents a snapshot of the actor's state.
+ * Frames allow to update any actor's component values.
+ * It can be used for example to update the sprite's current frame.
+ *
+ * In addition to individual states, it supports group states.
+ * Group states allow to avoid repeating the states with the same set of transitions,
+ * but slightly different frames.
+ * For instance, it can be used to describe a character state like "idle",
+ * "run" or "jump" from different angles.
+ *
+ * It is better to use an editor to create the animatable component
+ * since it has a quite complex structure.
+ *
+ * @category Components
+ */
 export declare class Animatable extends Component {
+    /** States of the animatable component */
     states: (IndividualState | GroupState)[];
+    /** Initial state of the animatable component */
     initialState: string;
+    /** Current state of the animatable component */
     currentState?: IndividualState | GroupState;
+    /** Duration of the current state relative to the total duration of the timeline */
     duration: number;
     constructor(config: AnimatableConfig);
     setCurrentState(currentState: string): void;

package/build/contrib/components/animatable/index.js

@@ -1,16 +1,41 @@
 import { Component } from '../../../engine/component';
 import { IndividualState } from './individual-state';
 import { GroupState } from './group-state';
+/**
+ * Animatable component for managing animations.
+ *
+ * It provides a state machine for an actor to manage its animations.
+ * Each state can have a set of transitions to other states,
+ * and each transition describes a set of conditions to check before the transition is triggered.
+ *
+ * State consists of a timeline of frames where each frame represents a snapshot of the actor's state.
+ * Frames allow to update any actor's component values.
+ * It can be used for example to update the sprite's current frame.
+ *
+ * In addition to individual states, it supports group states.
+ * Group states allow to avoid repeating the states with the same set of transitions,
+ * but slightly different frames.
+ * For instance, it can be used to describe a character state like "idle",
+ * "run" or "jump" from different angles.
+ *
+ * It is better to use an editor to create the animatable component
+ * since it has a quite complex structure.
+ *
+ * @category Components
+ */
 export class Animatable extends Component {
+    /** States of the animatable component */
     states;
+    /** Initial state of the animatable component */
     initialState;
+    /** Current state of the animatable component */
     currentState;
+    /** Duration of the current state relative to the total duration of the timeline */
     duration;
     constructor(config) {
         super();
-        const { initialState, states = [], } = config;
-        this.states = states
-            .reduce((acc, state) => {
+        const { initialState, states = [] } = config;
+        this.states = states.reduce((acc, state) => {
             const { type } = state;
             if (type === 'individual') {
                 acc.push(new IndividualState(state));

package/build/contrib/components/audio-source/index.d.ts

@@ -6,12 +6,47 @@ export interface AudioSourceConfig {
     volume: number;
     autoplay: boolean;
 }
+/**
+ * AudioSource component for playing audio.
+ *
+ * It handles the playing of audio for an actor.
+ * It allows to play audio files and control the volume and looping of the audio.
+ *
+ * @example
+ * ```typescript
+ * // Create an audio source
+ * const audioSource = new AudioSource({
+ *   src: 'assets/audio/some-sound.mp3',
+ *   group: 'master',
+ *   looped: false,
+ *   volume: 1,
+ *   autoplay: false,
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(audioSource);
+ *
+ * // Modify properties
+ * audioSource.volume = 0.5; // Set volume to 50%
+ *
+ * // Play the audio
+ * actor.dispatchEvent(PlayAudio);
+ * ```
+ *
+ * @category Components
+ */
 export declare class AudioSource extends Component {
+    /** Path to the audio asset */
     src: string;
+    /** Group of the audio, used to combine audio sources together and control them at once */
     group: string;
+    /** Whether the audio is looped */
     looped: boolean;
+    /** Volume of the audio, from 0 to 1 */
     volume: number;
+    /** Whether the audio is autoplayed on scene enter or after actor is added to scene */
     autoplay: boolean;
+    /** Whether the audio is playing now */
     playing: boolean;
     constructor(config: AudioSourceConfig);
     clone(): AudioSource;

package/build/contrib/components/audio-source/index.js

@@ -1,10 +1,45 @@
 import { Component } from '../../../engine/component';
+/**
+ * AudioSource component for playing audio.
+ *
+ * It handles the playing of audio for an actor.
+ * It allows to play audio files and control the volume and looping of the audio.
+ *
+ * @example
+ * ```typescript
+ * // Create an audio source
+ * const audioSource = new AudioSource({
+ *   src: 'assets/audio/some-sound.mp3',
+ *   group: 'master',
+ *   looped: false,
+ *   volume: 1,
+ *   autoplay: false,
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(audioSource);
+ *
+ * // Modify properties
+ * audioSource.volume = 0.5; // Set volume to 50%
+ *
+ * // Play the audio
+ * actor.dispatchEvent(PlayAudio);
+ * ```
+ *
+ * @category Components
+ */
 export class AudioSource extends Component {
+    /** Path to the audio asset */
     src;
+    /** Group of the audio, used to combine audio sources together and control them at once */
     group;
+    /** Whether the audio is looped */
     looped;
+    /** Volume of the audio, from 0 to 1 */
     volume;
+    /** Whether the audio is autoplayed on scene enter or after actor is added to scene */
     autoplay;
+    /** Whether the audio is playing now */
     playing;
     constructor(config) {
         super();

package/build/contrib/components/behaviors/index.d.ts

@@ -6,6 +6,25 @@ interface BehaviorConfig {
 export interface BehaviorsConfig {
     list: BehaviorConfig[];
 }
+/**
+ * Behaviors component for managing a list of behaviors.
+ *
+ * Behavior is a script that allows to add custom game logic to an actor,
+ * such as movement, AI or any other custom logic.
+ *
+ * @example
+ * ```typescript
+ * // Create a behaviors component
+ * const behaviors = new Behaviors({
+ *   list: [{ name: 'some-script', options: {} }],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(behaviors);
+ * ```
+ *
+ * @category Components
+ */
 export declare class Behaviors extends Component {
     list: BehaviorConfig[];
     constructor(config: BehaviorsConfig);

package/build/contrib/components/behaviors/index.js

@@ -1,4 +1,23 @@
 import { Component } from '../../../engine/component';
+/**
+ * Behaviors component for managing a list of behaviors.
+ *
+ * Behavior is a script that allows to add custom game logic to an actor,
+ * such as movement, AI or any other custom logic.
+ *
+ * @example
+ * ```typescript
+ * // Create a behaviors component
+ * const behaviors = new Behaviors({
+ *   list: [{ name: 'some-script', options: {} }],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(behaviors);
+ * ```
+ *
+ * @category Components
+ */
 export class Behaviors extends Component {
     list;
     constructor(config) {
@@ -8,7 +27,10 @@ export class Behaviors extends Component {
     }
     clone() {
         return new Behaviors({
-            list: this.list.map(({ name, options }) => ({ name, options: { ...options } })),
+            list: this.list.map(({ name, options }) => ({
+                name,
+                options: { ...options },
+            })),
         });
     }
 }

package/build/contrib/components/bitmap-text/index.d.ts

@@ -18,17 +18,63 @@ export interface BitmapTextConfig {
     sortingLayer: string;
     sortCenter: [number, number];
 }
+/**
+ * BitmapText component for rendering text using a bitmap font.
+ *
+ * It handles text representation of an actor using a bitmap font.
+ * It uses an asset file in the format of a bitmap font (.fnt and .xml are supported) to render text.
+ *
+ * @example
+ * ```typescript
+ * // Create a bitmap text
+ * const bitmapText = new BitmapText({
+ *   text: 'Greetings traveller!',
+ *   font: 'assets/fonts/some-pixel-font.fnt',
+ *   fontSize: 24,
+ *   align: 'center',
+ *   color: '#000',
+ *   opacity: 1,
+ *   blending: 'normal',
+ *   disabled: false,
+ *   sortingLayer: 'text',
+ *   sortCenter: [0, 0],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(bitmapText);
+ *
+ * // Modify properties
+ * bitmapText.text = 'Stay a while and listen!';
+ * ```
+ *
+ * @category Components
+ */
 export declare class BitmapText extends Component {
+    /** Text to render */
     text: string;
+    /** Path to the font asset */
     font: string;
+    /** Size of the text */
     fontSize: number;
+    /** Alignment of the text
+     * - left - Align text to the left edge
+     * - center - Center text horizontally
+     * - right - Align text to the right edge
+     */
     align: TextAlign;
+    /** Color of the text */
     color: string;
+    /** Opacity of the text */
     opacity: number;
+    /** Blending mode of the text */
     blending: BlendingMode;
+    /** Whether the text is disabled */
     disabled: boolean;
+    /** Sorting layer of the text */
     sortingLayer: string;
+    /** Center point of the text */
     sortCenter: [number, number];
+    /** Internal rendering data */
     renderData?: RenderData;
     constructor(config: BitmapTextConfig);
     clone(): BitmapText;

package/build/contrib/components/bitmap-text/index.js

@@ -1,15 +1,61 @@
 import { Component } from '../../../engine/component';
+/**
+ * BitmapText component for rendering text using a bitmap font.
+ *
+ * It handles text representation of an actor using a bitmap font.
+ * It uses an asset file in the format of a bitmap font (.fnt and .xml are supported) to render text.
+ *
+ * @example
+ * ```typescript
+ * // Create a bitmap text
+ * const bitmapText = new BitmapText({
+ *   text: 'Greetings traveller!',
+ *   font: 'assets/fonts/some-pixel-font.fnt',
+ *   fontSize: 24,
+ *   align: 'center',
+ *   color: '#000',
+ *   opacity: 1,
+ *   blending: 'normal',
+ *   disabled: false,
+ *   sortingLayer: 'text',
+ *   sortCenter: [0, 0],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(bitmapText);
+ *
+ * // Modify properties
+ * bitmapText.text = 'Stay a while and listen!';
+ * ```
+ *
+ * @category Components
+ */
 export class BitmapText extends Component {
+    /** Text to render */
     text;
+    /** Path to the font asset */
     font;
+    /** Size of the text */
     fontSize;
+    /** Alignment of the text
+     * - left - Align text to the left edge
+     * - center - Center text horizontally
+     * - right - Align text to the right edge
+     */
     align;
+    /** Color of the text */
     color;
+    /** Opacity of the text */
     opacity;
+    /** Blending mode of the text */
     blending;
+    /** Whether the text is disabled */
     disabled;
+    /** Sorting layer of the text */
     sortingLayer;
+    /** Center point of the text */
     sortCenter;
+    /** Internal rendering data */
     renderData;
     constructor(config) {
         super();

package/build/contrib/components/camera/index.d.ts

@@ -3,10 +3,33 @@ export interface CameraConfig {
     zoom: number;
     current: boolean;
 }
+/**
+ * Camera component for defining how a scene should be viewed.
+ *
+ * Camera component marks an actor as the possible camera to view the scene.
+ *
+ * @example
+ * ```typescript
+ * // Create a camera
+ * const camera = new Camera({
+ *   zoom: 2,
+ *   current: true,
+ * });
+ * ```
+ *
+ * // Add to actor
+ * actor.setComponent(camera);
+ *
+ * @category Components
+ */
 export declare class Camera extends Component {
+    /** Zoom of the camera */
     zoom: number;
+    /** Whether the camera is the current camera. Only one camera can be the current camera. */
     current: boolean;
+    /** Size of the game window in the x axis in pixels */
     windowSizeX: number;
+    /** Size of the game window in the y axis in pixels */
     windowSizeY: number;
     constructor(config: CameraConfig);
     clone(): Camera;

package/build/contrib/components/camera/index.js

@@ -1,8 +1,31 @@
 import { Component } from '../../../engine/component';
+/**
+ * Camera component for defining how a scene should be viewed.
+ *
+ * Camera component marks an actor as the possible camera to view the scene.
+ *
+ * @example
+ * ```typescript
+ * // Create a camera
+ * const camera = new Camera({
+ *   zoom: 2,
+ *   current: true,
+ * });
+ * ```
+ *
+ * // Add to actor
+ * actor.setComponent(camera);
+ *
+ * @category Components
+ */
 export class Camera extends Component {
+    /** Zoom of the camera */
     zoom;
+    /** Whether the camera is the current camera. Only one camera can be the current camera. */
     current;
+    /** Size of the game window in the x axis in pixels */
     windowSizeX;
+    /** Size of the game window in the y axis in pixels */
     windowSizeY;
     constructor(config) {
         super();

package/build/contrib/components/collider/index.d.ts

@@ -7,6 +7,37 @@ export interface ColliderConfig {
     sizeY?: number;
     radius?: number;
 }
+/**
+ * Collider component for defining collision boundaries.
+ *
+ * Collider component defines the collision shape for an actor. It's used by the
+ * physics system to detect collisions between actors.
+ *
+ * @example
+ * ```typescript
+ * // Create a box collider
+ * const boxCollider = new Collider({
+ *   type: 'box',
+ *   centerX: 0,
+ *   centerY: 0,
+ *   sizeX: 64,
+ *   sizeY: 64
+ * });
+ *
+ * // Create a circle collider
+ * const circleCollider = new Collider({
+ *   type: 'circle',
+ *   centerX: 0,
+ *   centerY: 0,
+ *   radius: 32
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(boxCollider);
+ * ```
+ *
+ * @category Components
+ */
 export declare class Collider extends Component {
     type: 'box' | 'circle';
     centerX: number;

package/build/contrib/components/collider/index.js

@@ -1,4 +1,35 @@
 import { Component } from '../../../engine/component';
+/**
+ * Collider component for defining collision boundaries.
+ *
+ * Collider component defines the collision shape for an actor. It's used by the
+ * physics system to detect collisions between actors.
+ *
+ * @example
+ * ```typescript
+ * // Create a box collider
+ * const boxCollider = new Collider({
+ *   type: 'box',
+ *   centerX: 0,
+ *   centerY: 0,
+ *   sizeX: 64,
+ *   sizeY: 64
+ * });
+ *
+ * // Create a circle collider
+ * const circleCollider = new Collider({
+ *   type: 'circle',
+ *   centerX: 0,
+ *   centerY: 0,
+ *   radius: 32
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(boxCollider);
+ * ```
+ *
+ * @category Components
+ */
 export class Collider extends Component {
     type;
     centerX;

package/build/contrib/components/keyboard-control/index.d.ts

@@ -19,8 +19,47 @@ export interface KeyboardEventBindConfig {
 export interface KeyboardControlConfig extends Record<string, unknown> {
     inputEventBindings: KeyboardEventBindConfig[];
 }
+/**
+ * KeyboardControl component for handling keyboard input events.
+ *
+ * KeyboardControl component handles the keyboard input events for an actor.
+ * It can be used to bind keyboard events to game actions.
+ *
+ * @example
+ * ```typescript
+ * // Create a keyboard control
+ * const keyboardControl = new KeyboardControl({
+ *   inputEventBindings: [
+ *     {
+ *       key: 'KeyW',
+ *       pressed: true,
+ *       keepEmit: true,
+ *       eventType: 'RUN',
+ *       attrs: [
+ *         {
+ *           name: 'angle',
+ *           type: 'number',
+ *           value: 270,
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(keyboardControl);
+ * ```
+ *
+ * @category Components
+ */
 export declare class KeyboardControl extends Component {
+    /** Input event bindings */
     inputEventBindings: InputEventBindings;
+    /**
+     * Creates a new KeyboardControl component.
+     *
+     * @param config - Configuration for the keyboard control
+     */
     constructor(config: KeyboardControlConfig);
     clone(): KeyboardControl;
 }

package/build/contrib/components/keyboard-control/index.js

@@ -1,6 +1,45 @@
 import { Component } from '../../../engine/component';
+/**
+ * KeyboardControl component for handling keyboard input events.
+ *
+ * KeyboardControl component handles the keyboard input events for an actor.
+ * It can be used to bind keyboard events to game actions.
+ *
+ * @example
+ * ```typescript
+ * // Create a keyboard control
+ * const keyboardControl = new KeyboardControl({
+ *   inputEventBindings: [
+ *     {
+ *       key: 'KeyW',
+ *       pressed: true,
+ *       keepEmit: true,
+ *       eventType: 'RUN',
+ *       attrs: [
+ *         {
+ *           name: 'angle',
+ *           type: 'number',
+ *           value: 270,
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(keyboardControl);
+ * ```
+ *
+ * @category Components
+ */
 export class KeyboardControl extends Component {
+    /** Input event bindings */
     inputEventBindings;
+    /**
+     * Creates a new KeyboardControl component.
+     *
+     * @param config - Configuration for the keyboard control
+     */
     constructor(config) {
         super();
         const { inputEventBindings } = config;

package/build/contrib/components/mouse-control/index.d.ts

@@ -14,8 +14,58 @@ export interface MouseEventBindConfig {
 export interface MouseControlConfig {
     inputEventBindings: MouseEventBindConfig[];
 }
+/**
+ * MouseControl component for handling mouse input events.
+ *
+ * Handles the mouse input events for an actor.
+ * It can be used to bind mouse events to game actions.
+ *
+ * @example
+ * ```typescript
+ * // Create a mouse control
+ * const mouseControl = new MouseControl({
+ *   inputEventBindings: [
+ *     {
+ *       event: 'mousedown',
+ *       button: 0,
+ *       eventType: 'ATTACK',
+ *       attrs: [
+ *         {
+ *           name: 'type',
+ *           type: 'string',
+ *           value: 'lightAttack',
+ *         },
+ *       ],
+ *     },
+ *     {
+ *       event: 'mousedown',
+ *       button: 2,
+ *       eventType: 'ATTACK',
+ *       attrs: [
+ *         {
+ *           name: 'type',
+ *           type: 'string',
+ *           value: 'heavyAttack',
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(mouseControl);
+ * ```
+ *
+ * @category Components
+ */
 export declare class MouseControl extends Component {
+    /** Input event bindings */
     inputEventBindings: InputEventBindings;
+    /**
+     * Creates a new MouseControl component.
+     *
+     * @param config - Configuration for the mouse control
+     */
     constructor(config: MouseControlConfig);
     clone(): MouseControl;
 }