Private __attributesPrivate __attributesPrivate __destroyedPrivate __executionThe order in the script component that the methods of this script instance will run relative to other script instances in the component.
Private __scriptPrivate _enabledPrivate _enabledPrivate _initializedPrivate _postThe AppBase that the instance of this type belongs to.
The Entity that the instance of this type belongs to.
Static Private __nameName of a Script.
True if the instance of this type is in running state. False when script is not running,
because the Entity or any of its parents are disabled or the ScriptComponent is
disabled or the Script Instance is disabled. When disabled no update methods will be called
on each tick. initialize and postInitialize methods will run once when the script instance
is in enabled state during app tick.
Static attributesThe interface to define attributes for Script Types. Refer to ScriptAttributes.
var PlayerController = pc.createScript('playerController');
PlayerController.attributes.add('speed', {
type: 'number',
title: 'Speed',
placeholder: 'km/h',
default: 22.2
});
Static scriptName of a Script Type.
Private __initializeFire an event, all additional arguments are passed on to the event listener.
Name of event to fire.
Optional arg1: anyFirst argument that is passed to the event handler.
Optional arg2: anySecond argument that is passed to the event handler.
Optional arg3: anyThird argument that is passed to the event handler.
Optional arg4: anyFourth argument that is passed to the event handler.
Optional arg5: anyFifth argument that is passed to the event handler.
Optional arg6: anySixth argument that is passed to the event handler.
Optional arg7: anySeventh argument that is passed to the event handler.
Optional arg8: anyEighth argument that is passed to the event handler.
Self for chaining.
obj.fire('test', 'This is the message');
Test if there are any handlers bound to an event name.
The name of the event to test.
True if the object has handlers bound to the specified event name.
obj.on('test', function () { }); // bind an event to 'test'
obj.hasEvent('test'); // returns true
obj.hasEvent('hello'); // returns false
Private initDetach 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.
Optional name: stringName of the event to unbind.
Optional callback: HandleEventCallbackFunction to be unbound.
Optional scope: objectScope that was used as the this when the event is fired.
Self for chaining.
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
Attach an event handler to an event.
Name of the event to bind the callback to.
Function that is called when event is fired. Note the callback is limited to 8 arguments.
Optional scope: object = ...Object to use as 'this' when the event is fired, defaults to current this.
Can be used for removing event in the future.
obj.on('test', function (a, b) {
console.log(a + b);
});
obj.fire('test', 1, 2); // prints 3 to the console
const evt = obj.on('test', function (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.
Name of the event to bind the callback to.
Function that is called when event is fired. Note the callback is limited to 8 arguments.
Optional scope: object = ...Object to use as 'this' when the event is fired, defaults to current this.
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
Static Private __getStatic extendShorthand function to extend Script Type prototype with list of methods.
Object with methods, where key - is name of method, and value - is function.
var PlayerController = pc.createScript('playerController');
PlayerController.extend({
initialize: function () {
// called once on initialize
},
update: function (dt) {
// called each tick
}
});
Static EVENT_Fired when script attributes have changed. This event is available in two forms. They are as follows:
attr - Fired for any attribute change. The handler is passed the name of the attribute
that changed, the value of the attribute before the change and the value of the attribute
after the change.attr:[name] - Fired for a specific attribute change. The handler is passed the value of
the attribute before the change and the value of the attribute after the change.PlayerController.prototype.initialize = function () {
this.on('attr', (name, newValue, oldValue) => {
console.log(`Attribute '${name}' changed from '${oldValue}' to '${newValue}'`);
});
};
PlayerController.prototype.initialize = function () {
this.on('attr:speed', (newValue, oldValue) => {
console.log(`Attribute 'speed' changed from '${oldValue}' to '${newValue}'`);
});
};
Static EVENT_Fired when a script instance is destroyed and removed from component.
PlayerController.prototype.initialize = function () {
this.on('destroy', () => {
// no longer part of the entity
// this is a good place to clean up allocated resources used by the script
});
};
Static EVENT_Fired when a script instance becomes disabled.
PlayerController.prototype.initialize = function () {
this.on('disable', () => {
// Script Instance is now disabled
});
};
Static EVENT_Fired when a script instance becomes enabled.
PlayerController.prototype.initialize = function () {
this.on('enable', () => {
// Script Instance is now enabled
});
};
Static EVENT_Fired when a script instance had an exception. The script instance will be automatically disabled. The handler is passed an Error object containing the details of the exception and the name of the method that threw the exception.
PlayerController.prototype.initialize = function () {
this.on('error', (err, method) => {
// caught an exception
console.log(err.stack);
});
};
Static EVENT_Fired when a script instance changes state to enabled or disabled. The handler is passed a boolean parameter that states whether the script instance is now enabled or disabled.
PlayerController.prototype.initialize = function () {
this.on('state', (enabled) => {
console.log(`Script Instance is now ${enabled ? 'enabled' : 'disabled'}`);
});
};
The Script class is a base class that you must extend to receive various lifecycle updates from the engine.
You can create a Script using either createScript or by extending the class directly.
The following methods are called if they exist on the Script instance:
initializepostInitializeupdatepostUpdateswapinitializeandpostInitialize- are called (if defined) when a script is about to run for the first time -postInitializewill run after allinitializemethods are executed in the same tick or enabling chain of actions.updateandpostUpdate- are called (if defined) for enabled (running state) scripts on each tick.swap- is called when a Script that already exists in the registry gets redefined. If the new Script has aswapmethod in its prototype, then it will be executed to perform hot- reload at runtime.See
https://developer.playcanvas.com/user-manual/scripting/anatomy/ for more information.