Engine API Reference - v2.6.1
    Preparing search index...

    Class ScriptComponent

    The ScriptComponent allows you add custom behavior to an Entity by attaching your own scripts written in JavaScript (or TypeScript).

    You should never need to use the ScriptComponent constructor directly. To add a ScriptComponent to an Entity, use Entity#addComponent:

    const entity = new pc.Entity();
    entity.addComponent('script');

    Once the ScriptComponent is added to the entity, you can access it via the script property. Add scripts to the entity by calling the create method:

    // Option 1: Add a script using the name registered in the ScriptRegistry
    entity.script.create('cameraControls');

    // Option 2: Add a script using the script class
    entity.script.create(CameraControls);

    For more details on scripting see the Scripting Section of the User Manual.

    Hierarchy (View Summary)

    Index

    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

    Properties

    entity: Entity

    The Entity that this Component is attached to.

    system: ComponentSystem

    The ComponentSystem used to create this Component.

    Accessors

    Methods

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

      Parameters

      • nameOrType: string | typeof Script

        The name or type of Script.

      • Optionalargs: {
            attributes?: any;
            enabled?: boolean;
            ind?: number;
            preloading?: boolean;
            properties?: any;
        } = {}

        Object with arguments for a script.

        • Optionalattributes?: any

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

        • Optionalenabled?: boolean

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

        • Optionalind?: number

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

        • Optionalpreloading?: boolean

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

        • Optionalproperties?: any

          Object with values that are assigned to the script instance.

      Returns null | 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.

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

    • 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.

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

    • 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.

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

    • 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.

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

    • 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: any

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

      Returns EventHandler

      Self for chaining.

      const handler = () => {};
      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

    • 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: any = ...

        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.

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

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

    • 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: any = ...

        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.
      obj.once('test', (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

    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.
    entity.script.on('create', (name, scriptInstance) => {
        console.log(`Instance of script '${name}' created`);
    });

    entity.script.on('create:player', (scriptInstance) => {
        console.log(`Instance of script 'player' created`);
    });
    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.
    entity.script.on('destroy', (name, scriptInstance) => {
        console.log(`Instance of script '${name}' destroyed`);
    });

    entity.script.on('destroy:player', (scriptInstance) => {
        console.log(`Instance of script 'player' destroyed`);
    });
    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.

    entity.script.on('disable', () => {
        console.log(`Script component of entity '${entity.name}' has been disabled`);
    });
    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.

    entity.script.on('enable', () => {
        console.log(`Script component of entity '${entity.name}' has been enabled`);
    });
    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.

    entity.script.on('error', (scriptInstance, exception, methodName) => {
        console.log(`Script error: ${exception} in method '${methodName}'`);
    });
    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.
    entity.script.on('move', (name, scriptInstance, newIndex, oldIndex) => {
        console.log(`Script '${name}' moved from index '${oldIndex}' to '${newIndex}'`);
    });

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

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

    entity.script.on('remove', () => {
        console.log(`Script component removed from entity '${entity.name}'`);
    });
    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.

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

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods
    Events