Class ScriptComponent

The ScriptComponent allows you to extend the functionality of an Entity by attaching your own Script Types defined in JavaScript files to be executed with access to the Entity. For more details on scripting see Scripting.

Hierarchy (view full)

Constructors

constructor

Properties

entity system

Accessors

enabled scripts

Methods

create destroy fire get has hasEvent move off on once

Events

EVENT_CREATE EVENT_DESTROY EVENT_DISABLE EVENT_ENABLE EVENT_ERROR EVENT_MOVE EVENT_REMOVE EVENT_STATE

Constructors

constructor

Properties

entity

entity: Entity

The Entity that this Component is attached to.

system

system: ComponentSystem

The ComponentSystem used to create this Component.

Accessors

enabled

scripts

Methods

create

  • create(nameOrType, args?): ScriptType

  • Create a script instance and attach to an entity script component.

    Parameters

    • nameOrType: string | typeof ScriptType

      The name or type of ScriptType.

    • Optionalargs: {
          attributes: object;
          enabled: boolean;
          ind: number;
          preloading: boolean;
      } = {}

      Object with arguments for a script.

      • attributes: object

        Object with values for attributes (if any), where key is name of an attribute.

      • enabled: boolean

        If script instance is enabled after creation. Defaults to true.

      • ind: number

        The index where to insert the script instance at. Defaults to -1, which means append it at the end.

      • preloading: boolean

        If script instance is created during preload. If true, script and attributes must be initialized manually. Defaults to false.

    Returns ScriptType

    Returns an instance of a ScriptType if successfully attached to an entity, or null if it failed because a script with a same name has already been added or if the ScriptType cannot be found by name in the ScriptRegistry.

    Example

    entity.script.create('playerController', {
        attributes: {
            speed: 4
        }
    });

destroy

fire

  • fire(name, arg1?, arg2?, arg3?, arg4?, arg5?, arg6?, arg7?, arg8?): EventHandler

  • Fire an event, all additional arguments are passed on to the event listener.

    Parameters

    • name: string

      Name of event to fire.

    • Optionalarg1: any

      First argument that is passed to the event handler.

    • Optionalarg2: any

      Second argument that is passed to the event handler.

    • Optionalarg3: any

      Third argument that is passed to the event handler.

    • Optionalarg4: any

      Fourth argument that is passed to the event handler.

    • Optionalarg5: any

      Fifth argument that is passed to the event handler.

    • Optionalarg6: any

      Sixth argument that is passed to the event handler.

    • Optionalarg7: any

      Seventh argument that is passed to the event handler.

    • Optionalarg8: any

      Eighth argument that is passed to the event handler.

    Returns EventHandler

    Self for chaining.

    Example

    obj.fire('test', 'This is the message');

get

has

hasEvent

  • hasEvent(name): boolean

  • Test if there are any handlers bound to an event name.

    Parameters

    • name: string

      The name of the event to test.

    Returns boolean

    True if the object has handlers bound to the specified event name.

    Example

    obj.on('test', function () { }); // bind an event to 'test'
    obj.hasEvent('test'); // returns true
    obj.hasEvent('hello'); // returns false

move

  • move(nameOrType, ind): boolean

  • Move script instance to different position to alter update order of scripts within entity.

    Parameters

    • nameOrType: string | typeof ScriptType

      The name or type of ScriptType.

    • ind: number

      New position index.

    Returns boolean

    If it was successfully moved.

    Example

    entity.script.move('playerController', 0);

off

  • off(name?, callback?, scope?): EventHandler

  • Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event, if scope is not provided then all events with the callback will be unbound.

    Parameters

    • Optionalname: string

      Name of the event to unbind.

    • Optionalcallback: HandleEventCallback

      Function to be unbound.

    • Optionalscope: object

      Scope that was used as the this when the event is fired.

    Returns EventHandler

    Self for chaining.

    Example

    const handler = function () {
    };
    obj.on('test', handler);

    obj.off(); // Removes all events
    obj.off('test'); // Removes all events called 'test'
    obj.off('test', handler); // Removes all handler functions, called 'test'
    obj.off('test', handler, this); // Removes all handler functions, called 'test' with scope this

on

  • on(name, callback, scope?): EventHandle

  • Attach an event handler to an event.

    Parameters

    • name: string

      Name of the event to bind the callback to.

    • callback: HandleEventCallback

      Function that is called when event is fired. Note the callback is limited to 8 arguments.

    • Optionalscope: object = ...

      Object to use as 'this' when the event is fired, defaults to current this.

    Returns EventHandle

    Can be used for removing event in the future.

    Example

    obj.on('test', function (a, b) {
        console.log(a + b);
    });
    obj.fire('test', 1, 2); // prints 3 to the console

    Example

    const evt = obj.on('test', function (a, b) {
        console.log(a + b);
    });
    // some time later
    evt.off();

once

  • once(name, callback, scope?): EventHandle

  • Attach an event handler to an event. This handler will be removed after being fired once.

    Parameters

    • name: string

      Name of the event to bind the callback to.

    • callback: HandleEventCallback

      Function that is called when event is fired. Note the callback is limited to 8 arguments.

    • Optionalscope: object = ...

      Object to use as 'this' when the event is fired, defaults to current this.

    Returns EventHandle

    • can be used for removing event in the future.

    Example

    obj.once('test', function (a, b) {
        console.log(a + b);
    });
    obj.fire('test', 1, 2); // prints 3 to the console
    obj.fire('test', 1, 2); // not going to get handled

Events

StaticEVENT_CREATE

EVENT_CREATE: string = 'create'

Fired when a ScriptType instance is created and attached to the script component. This event is available in two forms. They are as follows:

  1. create - Fired when a script instance is created. The name of the script type and the script type instance are passed as arguments.
  2. create:[name] - Fired when a script instance is created that has the specified script type name. The script instance is passed as an argument to the handler.

Example

entity.script.on('create', (name, scriptInstance) => {
    console.log(`Instance of script '${name}' created`);
});

Example

entity.script.on('create:player', (scriptInstance) => {
    console.log(`Instance of script 'player' created`);
});

StaticEVENT_DESTROY

EVENT_DESTROY: string = 'destroy'

Fired when a ScriptType instance is destroyed and removed from the script component. This event is available in two forms. They are as follows:

  1. destroy - Fired when a script instance is destroyed. The name of the script type and the script type instance are passed as arguments.
  2. destroy:[name] - Fired when a script instance is destroyed that has the specified script type name. The script instance is passed as an argument.

Example

entity.script.on('destroy', (name, scriptInstance) => {
    console.log(`Instance of script '${name}' destroyed`);
});

Example

entity.script.on('destroy:player', (scriptInstance) => {
    console.log(`Instance of script 'player' destroyed`);
});

StaticEVENT_DISABLE

EVENT_DISABLE: string = 'disable'

Fired when the script component becomes disabled. This event does not take into account the enabled state of the entity or any of its ancestors.

Example

entity.script.on('disable', () => {
    console.log(`Script component of entity '${entity.name}' has been disabled`);
});

StaticEVENT_ENABLE

EVENT_ENABLE: string = 'enable'

Fired when the script component becomes enabled. This event does not take into account the enabled state of the entity or any of its ancestors.

Example

entity.script.on('enable', () => {
    console.log(`Script component of entity '${entity.name}' has been enabled`);
});

StaticEVENT_ERROR

EVENT_ERROR: string = 'error'

Fired when a ScriptType instance had an exception. The handler is passed the script instance, the exception and the method name that the exception originated from.

Example

entity.script.on('error', (scriptInstance, exception, methodName) => {
    console.log(`Script error: ${exception} in method '${methodName}'`);
});

StaticEVENT_MOVE

EVENT_MOVE: string = 'move'

Fired when the index of a ScriptType instance is changed in the script component. This event is available in two forms. They are as follows:

  1. move - Fired when a script instance is moved. The name of the script type, the script type instance, the new index and the old index are passed as arguments.
  2. move:[name] - Fired when a specifically named script instance is moved. The script instance, the new index and the old index are passed as arguments.

Example

entity.script.on('move', (name, scriptInstance, newIndex, oldIndex) => {
    console.log(`Script '${name}' moved from index '${oldIndex}' to '${newIndex}'`);
});

Example

entity.script.on('move:player', (scriptInstance, newIndex, oldIndex) => {
    console.log(`Script 'player' moved from index '${oldIndex}' to '${newIndex}'`);
});

StaticEVENT_REMOVE

EVENT_REMOVE: string = 'remove'

Fired when the script component has been removed from its entity.

Example

entity.script.on('remove', () => {
    console.log(`Script component removed from entity '${entity.name}'`);
});

StaticEVENT_STATE

EVENT_STATE: string = 'state'

Fired when the script component changes state to enabled or disabled. The handler is passed the new boolean enabled state of the script component. This event does not take into account the enabled state of the entity or any of its ancestors.

Example

entity.script.on('state', (enabled) => {
    console.log(`Script component of entity '${entity.name}' changed state to '${enabled}'`);
});

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods
Events