@skewedaspect/sage 0.5.0 → 0.5.1

package/src/classes/bindings/value.ts

@@ -1,227 +0,0 @@
-//----------------------------------------------------------------------------------------------------------------------
-// Value Binding
-//----------------------------------------------------------------------------------------------------------------------
-
-import type { GameEventBus } from '../eventBus.ts';
-
-// Interfaces
-import type { Action } from '../../interfaces/action.ts';
-import type { Binding, ValueBindingDefinition } from '../../interfaces/binding.ts';
-import type { DeviceValueReader, InputState } from '../../interfaces/input.ts';
-
-//----------------------------------------------------------------------------------------------------------------------
-
-/**
- * Options for configuring a value binding
- */
-export interface ValueBindingOptions
-{
-    /**
-     * Factor to scale the input value by (1.0 = no scaling)
-     */
-    scale ?: number;
-
-    /**
-     * Value to add to the input value after scaling
-     */
-    offset ?: number;
-
-    /**
-     * Whether to invert the input value (multiply by -1)
-     */
-    invert ?: boolean;
-
-    /**
-     * Optional context name this binding belongs to
-     */
-    context ?: string;
-
-    /**
-     * If true, only emit values when they change
-     * If false, always emit values on each process call
-     */
-    emitOnChange ?: boolean;
-
-    /**
-     * Deadzone threshold (0.0 to 1.0)
-     * Input values below this threshold will be treated as 0
-     */
-    deadzone ?: number;
-
-    /**
-     * Value to emit when the input is digital and true
-     * Only used when action is digital
-     */
-    onValue ?: boolean | number;
-
-    /**
-     * Value to emit when the input is digital and false
-     * Only used when action is digital
-     */
-    offValue ?: boolean | number;
-
-    /**
-     * Minimum value to clamp output to
-     */
-    min ?: number;
-
-    /**
-     * Maximum value to clamp output to
-     */
-    max ?: number;
-}
-
-/**
- * Implementation of a value binding, which directly converts an analog input
- * to an analog output with optional scaling, offset, and clamping.
- * Can handle both digital and analog inputs/outputs based on action type.
- */
-export class ValueBinding implements Binding
-{
-    public readonly type = 'value' as const;
-    public readonly action : Action;
-    public readonly context ?: string;
-    public readonly deviceID : string;
-    public readonly reader : DeviceValueReader;
-
-    // Value-specific options
-    private readonly _scale : number;
-    private readonly _offset : number;
-    private readonly _invert : boolean;
-    private readonly _emitOnChange : boolean;
-    private readonly _deadzone : number;
-    private readonly _onValue : boolean | number;
-    private readonly _offValue : boolean | number;
-    private readonly _min : number;
-    private readonly _max : number;
-
-    // State tracking
-    private _lastValue : number | boolean | undefined;
-
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Get the current options for this value binding.
-     *
-     * @returns The current options for this value binding
-     */
-    get options() : ValueBindingOptions
-    {
-        return {
-            scale: this._scale,
-            offset: this._offset,
-            invert: this._invert,
-            emitOnChange: this._emitOnChange,
-            deadzone: this._deadzone,
-            onValue: this._onValue,
-            offValue: this._offValue,
-            min: this._min,
-            max: this._max,
-        };
-    }
-
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Create a new value binding
-     *
-     * @param action - Action to emit values for
-     * @param deviceID - Device ID this binding is for
-     * @param reader - Input reader to read values from
-     * @param options - Binding configuration options
-     */
-    constructor(
-        action : Action,
-        deviceID : string,
-        reader : DeviceValueReader,
-        options : ValueBindingOptions = {}
-    )
-    {
-        this.action = action;
-        this.deviceID = deviceID;
-        this.reader = reader;
-        this.context = options.context;
-
-        // Common options that apply to both analog and digital
-        this._scale = options.scale ?? 1.0;
-        this._offset = options.offset ?? 0.0;
-        this._invert = options.invert ?? false;
-        this._emitOnChange = options.emitOnChange ?? true;
-        this._deadzone = options.deadzone ?? 0.0;
-
-        // For digital actions, these control the output value
-        // For analog actions, these are not used
-        this._onValue = options.onValue ?? true;
-        this._offValue = options.offValue ?? false;
-
-        // Store min/max values explicitly
-        const defaultMin = this.action.type === 'analog'
-            ? this.action.minValue ?? Number.NEGATIVE_INFINITY
-            : Number.NEGATIVE_INFINITY;
-        this._min = options.min ?? defaultMin;
-
-        const defaultMax = this.action.type === 'analog'
-            ? this.action.maxValue ?? Number.POSITIVE_INFINITY
-            : Number.POSITIVE_INFINITY;
-        this._max = options.max ?? defaultMax;
-    }
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Public Methods
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Process input state and emit an action value
-     *
-     * @param state - Current input state
-     * @param eventBus - Event bus to emit action events to
-     * @returns True if a value was emitted, false otherwise
-     */
-    public process(state : InputState, eventBus : GameEventBus) : void
-    {
-        const rawValue = this.reader.getValue(state);
-        if(rawValue === undefined) { return; }
-
-        const numericValue = typeof rawValue === 'boolean' ? (rawValue ? 1.0 : 0.0) : rawValue;
-        if(numericValue === undefined) { return; }
-
-        let value = this._deadzone > 0 && Math.abs(numericValue) < this._deadzone ? 0 : numericValue;
-        value = ((this._invert ? -value : value) * this._scale) + this._offset;
-
-        // Apply min/max clamping
-        value = Math.max(this._min, Math.min(this._max, value));
-
-        if(this._emitOnChange && this._lastValue === value) { return; }
-        this._lastValue = value;
-
-        eventBus.publish({
-            type: `action:${ this.action.name }`,
-            payload: {
-                value,
-                deviceId: this.deviceID,
-                context: this.context,
-            },
-        });
-    }
-
-    /**
-     * Returns a JSON-serializable representation of this value binding
-     *
-     * @returns A simple object representation that can be converted to JSON
-     */
-    public toJSON() : ValueBindingDefinition
-    {
-        return {
-            type: this.type,
-            action: this.action.name,
-            input: {
-                deviceID: this.deviceID,
-                ...this.reader.toJSON(),
-            },
-            context: this.context,
-            options: this.options,
-        };
-    }
-}
-
-//----------------------------------------------------------------------------------------------------------------------

package/src/classes/entity.ts

@@ -1,256 +0,0 @@
-//----------------------------------------------------------------------------------------------------------------------
-// Game Entity
-//----------------------------------------------------------------------------------------------------------------------
-
-import type { GameEntityBehaviorConstructor } from '../interfaces/entity.ts';
-import { type GameEvent, GameEventBus } from './eventBus.ts';
-
-//----------------------------------------------------------------------------------------------------------------------
-
-/**
- * Interface representing a subscription to a game event.
- */
-interface GameEventSubscription
-{
-    count : number;
-    unsubscribe : () => void;
-}
-
-/**
- * Interface representing the context of a game entity.
- * @template EntityState - The type of the state object.
- */
-interface SimpleGameEntity<EntityState extends object = object>
-{
-    id : string;
-    type : string;
-    state : EntityState;
-    eventBus : GameEventBus;
-}
-
-//----------------------------------------------------------------------------------------------------------------------
-
-/**
- * Base class for game entity behaviors.
- */
-export abstract class GameEntityBehavior<RequiredState extends object = object>
-{
-    abstract name : string;
-    abstract eventSubscriptions : string[];
-
-    protected entity : SimpleGameEntity | null = null;
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Internal API
-    //------------------------------------------------------------------------------------------------------------------
-
-    $emit(event : GameEvent) : void
-    {
-        if(!this.entity)
-        {
-            throw new Error('Entity is not set for this behavior.');
-        }
-
-        event.senderID = this.entity.id;
-        this.entity.eventBus.publish(event);
-    }
-
-    /**
-     * Sets the entity for this behavior.
-     * @param entity - The entity to set.
-     */
-    $setEntity(entity : SimpleGameEntity | null) : void
-    {
-        this.entity = entity;
-    }
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Implementation API
-    //------------------------------------------------------------------------------------------------------------------
-
-    abstract processEvent(event : GameEvent, state : RequiredState) : Promise<boolean> | boolean;
-
-    update?(dt : number, state : RequiredState) : void;
-
-    destroy?() : Promise<void>;
-}
-
-//----------------------------------------------------------------------------------------------------------------------
-
-/**
- * Base class for game entities.
- * @template EntityState - The type of the state object.
- */
-export class GameEntity<EntityState extends object = object> implements SimpleGameEntity<EntityState>
-{
-    /** The unique identifier of the entity. */
-    public readonly id : string;
-
-    /** The type of the entity. */
-    public readonly type : string;
-
-    /** The state of the entity. */
-    public state : EntityState;
-
-    /** A map of behaviors attached to the entity. */
-    public behaviors : Map<string, GameEntityBehavior> = new Map<string, GameEntityBehavior>();
-
-    /** The event bus for the entity. */
-    public eventBus : GameEventBus;
-
-    /** The event subscriptions for the entity. */
-    private subscriptions : Map<string, GameEventSubscription> = new Map<string, GameEventSubscription>();
-
-    /**
-     * Creates an instance of GameEntityBase.
-     * @param type - The type of the entity.
-     * @param initialState - The initial state of the entity.
-     * @param behaviors - An array of behaviors to attach to the entity.
-     * @param eventBus
-     */
-    constructor(
-        type : string,
-        eventBus : GameEventBus,
-        initialState : EntityState,
-        behaviors : GameEntityBehaviorConstructor[]
-    )
-    {
-        this.id = crypto.randomUUID();
-        this.type = type;
-        this.state = initialState;
-        this.eventBus = eventBus;
-
-        // Attach behaviors
-        for(const behaviorCtor of behaviors)
-        {
-            this.attachBehavior(new behaviorCtor());
-        }
-    }
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Internal Methods
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Processes a game event by passing it to the entity's behaviors.
-     * @param event - The game event to process.
-     * @returns A promise that resolves when the event has been processed.
-     */
-    async $processEvent(event : GameEvent) : Promise<void>
-    {
-        for(const behavior of this.behaviors.values())
-        {
-            // eslint-disable-next-line no-await-in-loop
-            const result = await behavior.processEvent(event, this.state);
-            if(result)
-            {
-                // If the behavior returns true, stop other behaviors from processing the event.
-                break;
-            }
-        }
-    }
-
-    /**
-     * Updates the entity by calling the update method of its behaviors.
-     * @param dt - The delta time since the last update.
-     */
-    $update(dt : number) : void
-    {
-        for(const behavior of this.behaviors.values())
-        {
-            behavior.update?.(dt, this.state);
-        }
-    }
-
-    /**
-     * Destroys the entity by calling the destroy method of its behaviors.
-     * @returns A promise that resolves when the entity has been destroyed.
-     */
-    async $destroy() : Promise<void>
-    {
-        for(const behavior of this.behaviors.values())
-        {
-            behavior.destroy?.();
-        }
-
-        // Unsubscribe from all event subscriptions
-        for(const subscription of this.subscriptions.values())
-        {
-            subscription.unsubscribe();
-        }
-
-        this.behaviors.clear();
-        this.subscriptions.clear();
-    }
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Public Methods
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Attaches a behavior to the entity.
-     * @param behavior - The behavior to attach.
-     * @throws Will throw an error if the behavior is already attached.
-     */
-    attachBehavior(behavior : GameEntityBehavior) : void
-    {
-        if(this.behaviors.has(behavior.name))
-        {
-            throw new Error(`Behavior ${ behavior.name } is already attached to this entity.`);
-        }
-
-        // Subscribe to the behavior's event subscriptions
-        for(const event of behavior.eventSubscriptions)
-        {
-            // Check if the event is already subscribed
-            const existingSubscription = this.subscriptions.get(event);
-            if(existingSubscription)
-            {
-                existingSubscription.count++;
-            }
-            else
-            {
-                // Create a new subscription
-                const unsubscribe = this.eventBus.subscribe(event, this.$processEvent.bind(this));
-                this.subscriptions.set(event, { count: 1, unsubscribe });
-            }
-        }
-
-        // Attach the behavior
-        this.behaviors.set(behavior.name, behavior);
-        behavior.$setEntity(this);
-    }
-
-    /**
-     * Detaches a behavior from the entity.
-     * @param behaviorName - The behavior to detach.
-     */
-    detachBehavior(behaviorName : string) : void
-    {
-        const behavior = this.behaviors.get(behaviorName);
-        if(behavior)
-        {
-            // Remove the behavior's event subscriptions
-            for(const event of behavior.eventSubscriptions)
-            {
-                const subscription = this.subscriptions.get(event);
-                if(subscription)
-                {
-                    subscription.count--;
-                    if(subscription.count <= 0)
-                    {
-                        subscription.unsubscribe();
-                        this.subscriptions.delete(event);
-                    }
-                }
-            }
-
-            // Remove the behavior
-            this.behaviors.delete(behavior.name);
-            behavior.$setEntity(null);
-        }
-    }
-}
-
-//----------------------------------------------------------------------------------------------------------------------
-