Class Player

The actor controlled by the player.

Hierarchy (view full)

Constructors

constructor

Properties

_state active childrenAdded$ childrenRemoved$ componentAdded$ componentRemoved$ dying events id initialState? logger scene defaults

Accessors

acc actions anchor angularVelocity atArtifact body center children collider color draggable graphics height hurt isInitialized isOffScreen localCenter motion name oldAcc oldPos oldVel parent pointer pos rotation scale scaleTarget state tags transform types vel width z

Methods

_initialize _postkill _postupdate _prekill _preupdate _setName addChild addComponent addTag addTemplate clearComponents clone contains emit get getAncestors getComponents getDescendants getGlobalPos getGlobalRotation getGlobalScale has hasTag initializeActor isKilled kill killAfter off on onActivate onExitViewport onGameover onInitialize onPostCollision onPostKill onPostUpdate onPreKill onPreUpdate once reinitialize removeAllChildren removeChild removeComponent removeTag unkill unparent update within

Constructors

constructor

Properties

Protected _state

_state: PlayerState = ...

active

active: boolean

Whether this entity is active, if set to false it will be reclaimed

childrenAdded$

childrenAdded$: Observable<Entity>

childrenRemoved$

childrenRemoved$: Observable<Entity>

componentAdded$

componentAdded$: Observable<AddedComponent>

Observable that keeps track of component add or remove changes on the entity

componentRemoved$

componentRemoved$: Observable<RemovedComponent>

dying

dying: boolean = false

events

events: EventEmitter<ActorEvents>

id

id: number

The unique identifier for the entity

Optional initialState

initialState?: ActorState

logger

logger: Logger

Convenience reference to the global logger

scene

scene: Scene<unknown>

The scene that the entity is in, if any

Static defaults

defaults: {
    anchor: Vector;
}

Set defaults for all Actors

Type declaration

  • anchor: Vector

Accessors

acc

  • get acc(): Vector

  • Gets the acceleration vector of the actor in pixels/second/second. An acceleration pointing down such as (0, 100) may be useful to simulate a gravitational effect.

    Returns Vector

  • set acc(theAcc): void

  • Sets the acceleration vector of teh actor in pixels/second/second

    Parameters

    • theAcc: Vector

    Returns void

actions

  • get actions(): ActionsComponent

  • Useful for quickly scripting actor behavior, like moving to a place, patrolling back and forth, blinking, etc.

    Access to the Actor's built in [[ActionsComponent]] which forwards to the [[ActionContext|Action context]] of the actor.

    Returns ActionsComponent

anchor

  • get anchor(): Vector

  • Returns Vector

  • set anchor(vec): void

  • Parameters

    • vec: Vector

    Returns void

angularVelocity

  • get angularVelocity(): number

  • Gets the rotational velocity of the actor in radians/second

    Returns number

  • set angularVelocity(angularVelocity): void

  • Sets the rotational velocity of the actor in radians/sec

    Parameters

    • angularVelocity: number

    Returns void

atArtifact

body

  • get body(): BodyComponent

  • The physics body the is associated with this actor. The body is the container for all physical properties, like position, velocity, acceleration, mass, inertia, etc.

    Returns BodyComponent

center

  • get center(): Vector

  • Get the center point of an actor (global position)

    Returns Vector

children

  • get children(): readonly Entity[]

  • Get the direct children of this entity

    Returns readonly Entity[]

collider

  • get collider(): ColliderComponent

  • Access to the Actor's built in [[ColliderComponent]]

    Returns ColliderComponent

color

  • get color(): Color

  • Sets the color of the actor's current graphic

    Returns Color

  • set color(v): void

  • Parameters

    • v: Color

    Returns void

draggable

  • get draggable(): boolean

  • Returns boolean

  • set draggable(isDraggable): void

  • Parameters

    • isDraggable: boolean

    Returns void

graphics

  • get graphics(): GraphicsComponent

  • Access to the Actor's built in [[GraphicsComponent]]

    Returns GraphicsComponent

height

  • get height(): number

  • Returns number

hurt

isInitialized

  • get isInitialized(): boolean

  • Gets whether the actor is Initialized

    Returns boolean

isOffScreen

  • get isOffScreen(): boolean

  • Indicates whether the actor is physically in the viewport

    Returns boolean

localCenter

  • get localCenter(): Vector

  • Get the local center point of an actor

    Returns Vector

motion

  • get motion(): MotionComponent

  • Access the Actor's built in [[MotionComponent]]

    Returns MotionComponent

name

  • get name(): string

  • Returns string

oldAcc

  • get oldAcc(): Vector

  • Gets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]].

    Returns Vector

  • set oldAcc(theAcc): void

  • Sets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]].

    Parameters

    • theAcc: Vector

    Returns void

oldPos

  • get oldPos(): Vector

  • Gets the position vector of the actor from the last frame

    Returns Vector

  • set oldPos(thePos): void

  • Sets the position vector of the actor in the last frame

    Parameters

    • thePos: Vector

    Returns void

oldVel

  • get oldVel(): Vector

  • Gets the velocity vector of the actor from the last frame

    Returns Vector

  • set oldVel(theVel): void

  • Sets the velocity vector of the actor from the last frame

    Parameters

    • theVel: Vector

    Returns void

parent

  • get parent(): Entity

  • Returns Entity

pointer

  • get pointer(): PointerComponent

  • Access to the Actor's built in [[PointerComponent]] config

    Returns PointerComponent

pos

  • get pos(): Vector

  • Gets the position vector of the actor in pixels

    Returns Vector

  • set pos(thePos): void

  • Sets the position vector of the actor in pixels

    Parameters

    • thePos: Vector

    Returns void

rotation

  • get rotation(): number

  • Gets the rotation of the actor in radians. 1 radian = 180/PI Degrees.

    Returns number

  • set rotation(theAngle): void

  • Sets the rotation of the actor in radians. 1 radian = 180/PI Degrees.

    Parameters

    • theAngle: number

    Returns void

scale

  • get scale(): Vector

  • Returns Vector

  • set scale(scale): void

  • Parameters

    • scale: Vector

    Returns void

scaleTarget

state

tags

  • get tags(): readonly string[]

  • Specifically get the tags on the entity from [[TagComponent]]

    Returns readonly string[]

transform

  • get transform(): TransformComponent

  • Access the Actor's built in [[TransformComponent]]

    Returns TransformComponent

types

  • get types(): string[]

  • The types of the components on the Entity

    Returns string[]

vel

  • get vel(): Vector

  • Gets the velocity vector of the actor in pixels/sec

    Returns Vector

  • set vel(theVel): void

  • Sets the velocity vector of the actor in pixels/sec

    Parameters

    • theVel: Vector

    Returns void

width

  • get width(): number

  • Returns number

z

  • get z(): number

  • Gets the z-index of an actor. The z-index determines the relative order an actor is drawn in. Actors with a higher z-index are drawn on top of actors with a lower z-index

    Returns number

  • set z(newZ): void

  • Sets the z-index of an actor and updates it in the drawing list for the scene. The z-index determines the relative order an actor is drawn in. Actors with a higher z-index are drawn on top of actors with a lower z-index

    Parameters

    • newZ: number

      new z-index to assign

    Returns void

Methods

_initialize

  • _initialize(engine): void
  • Internal

    Initializes this actor and all it's child actors, meant to be called by the Scene before first update not by users of Excalibur.

    It is not recommended that internal excalibur methods be overridden, do so at your own risk.

    Parameters

    • engine: Engine

    Returns void

_postkill

  • _postkill(_scene): void
  • Internal

    It is not recommended that internal excalibur methods be overridden, do so at your own risk.

    Internal _prekill handler for [[onPostKill]] lifecycle event

    Parameters

    • _scene: Scene<unknown>

    Returns void

_postupdate

  • _postupdate(engine, delta): void
  • Internal

    It is not recommended that internal excalibur methods be overridden, do so at your own risk.

    Internal _preupdate handler for [[onPostUpdate]] lifecycle event

    Parameters

    • engine: Engine
    • delta: number

    Returns void

_prekill

  • _prekill(_scene): void
  • Internal

    It is not recommended that internal excalibur methods be overridden, do so at your own risk.

    Internal _prekill handler for [[onPreKill]] lifecycle event

    Parameters

    • _scene: Scene<unknown>

    Returns void

_preupdate

  • _preupdate(engine, delta): void
  • Internal

    It is not recommended that internal excalibur methods be overridden, do so at your own risk.

    Internal _preupdate handler for [[onPreUpdate]] lifecycle event

    Parameters

    • engine: Engine
    • delta: number

    Returns void

Protected _setName

  • _setName(name): void

  • Parameters

    • name: string

    Returns void

addChild

  • addChild(entity): Entity

  • Adds an entity to be a child of this entity

    Parameters

    • entity: Entity

    Returns Entity

addComponent

  • addComponent<T>(component, force?): Entity

  • Adds a component to the entity

    Type Parameters

    • T extends Component<string>

    Parameters

    • component: T

      Component or Entity to add copy of components from

    • Optional force: boolean

      Optionally overwrite any existing components of the same type

    Returns Entity

addTag

  • addTag(tag): Entity

  • Adds a tag to an entity

    Parameters

    • tag: string

    Returns Entity

    Entity

addTemplate

  • addTemplate(templateEntity, force?): Entity

  • Adds a copy of all the components from another template entity as a "prefab"

    Parameters

    • templateEntity: Entity

      Entity to use as a template

    • Optional force: boolean

      Force component replacement if it already exists on the target entity

    Returns Entity

clearComponents

  • clearComponents(): void

  • Returns void

clone

  • clone(): Actor

  • Returns Actor

contains

  • contains(x, y, recurse?): boolean

  • Tests whether the x/y specified are contained in the actor

    Parameters

    • x: number

      X coordinate to test (in world coordinates)

    • y: number

      Y coordinate to test (in world coordinates)

    • Optional recurse: boolean

      checks whether the x/y are contained in any child actors (if they exist).

    Returns boolean

emit

  • emit<TEventName>(eventName, event): void

  • Type Parameters

    • TEventName extends EventKey<ActorEvents>

    Parameters

    Returns void

  • emit(eventName, event?): void

  • Parameters

    • eventName: string
    • Optional event: any

    Returns void

get

  • get<T>(type): null | T

  • Get a component by type with typecheck

    (Does not work on tag components, use .hasTag("mytag") instead)

    Type Parameters

    • T extends Component<string>

    Parameters

    • type: ComponentCtor<T>

    Returns null | T

  • get<T>(type): null | T

  • Type Parameters

    • T extends Component<string>

    Parameters

    • type: string

    Returns null | T

getAncestors

  • getAncestors(): Entity[]

  • Returns a list of parent entities starting with the topmost parent. Includes the current entity.

    Returns Entity[]

getComponents

  • getComponents(): Component<string>[]

  • Returns Component<string>[]

getDescendants

  • getDescendants(): Entity[]

  • Returns a list of all the entities that descend from this entity. Includes the current entity.

    Returns Entity[]

getGlobalPos

  • getGlobalPos(): Vector

  • Gets an actor's world position taking into account parent relationships, scaling, rotation, and translation

    Returns Vector

    Position in world coordinates

getGlobalRotation

  • getGlobalRotation(): number

  • Gets this actor's rotation taking into account any parent relationships

    Returns number

    Rotation angle in radians

getGlobalScale

  • getGlobalScale(): Vector

  • Gets the global scale of the Actor

    Returns Vector

has

  • has<T>(type): boolean

  • Check if a component type exists

    Type Parameters

    • T extends Component<string>

    Parameters

    • type: ComponentCtor<T>

    Returns boolean

  • has(type): boolean

  • Parameters

    • type: string

    Returns boolean

hasTag

  • hasTag(tag): boolean

  • Check if a tag exists on the entity

    Parameters

    • tag: string

      name to check for

    Returns boolean

initializeActor

isKilled

  • isKilled(): boolean

  • Indicates wether the actor has been killed.

    Returns boolean

kill

killAfter

  • killAfter(seconds, respawn?, cb?): boolean

  • Parameters

    • seconds: number
    • Optional respawn: number
    • Optional cb: (() => void)
        • (): void

        • Returns void

    Returns boolean

off

  • off<TEventName>(eventName, handler): void

  • Type Parameters

    • TEventName extends EventKey<ActorEvents>

    Parameters

    Returns void

  • off(eventName, handler): void

  • Parameters

    • eventName: string
    • handler: Handler<unknown>

    Returns void

  • off(eventName): void

  • Parameters

    • eventName: string

    Returns void

on

  • on<TEventName>(eventName, handler): Subscription

  • Type Parameters

    • TEventName extends EventKey<ActorEvents>

    Parameters

    Returns Subscription

  • on(eventName, handler): Subscription

  • Parameters

    • eventName: string
    • handler: Handler<unknown>

    Returns Subscription

onActivate

onExitViewport

onGameover

onInitialize

  • onInitialize(engine): void

  • onInitialize is called before the first update of the actor. This method is meant to be overridden. This is where initialization of child actors should take place.

    Synonymous with the event handler .on('initialize', (evt) => {...})

    Parameters

    • engine: Engine

    Returns void

onPostCollision

onPostKill

  • onPostKill(_scene): void

  • Safe to override onPostKill lifecycle event handler. Synonymous with .on('postkill', (evt) => {...})

    onPostKill is called directly after an actor is killed and remove from its current [[Scene]].

    Parameters

    • _scene: Scene<unknown>

    Returns void

onPostUpdate

  • onPostUpdate(_engine, _delta): void

  • Safe to override onPostUpdate lifecycle event handler. Synonymous with .on('postupdate', (evt) =>{...})

    onPostUpdate is called directly after an actor is updated.

    Parameters

    • _engine: Engine
    • _delta: number

    Returns void

onPreKill

  • onPreKill(_scene): void

  • Safe to override onPreKill lifecycle event handler. Synonymous with .on('prekill', (evt) =>{...})

    onPreKill is called directly before an actor is killed and removed from its current [[Scene]].

    Parameters

    • _scene: Scene<unknown>

    Returns void

onPreUpdate

  • onPreUpdate(engine, delta): void

  • Safe to override onPreUpdate lifecycle event handler. Synonymous with .on('preupdate', (evt) =>{...})

    onPreUpdate is called directly before an actor is updated.

    Parameters

    • engine: Engine
    • delta: number

    Returns void

once

  • once<TEventName>(eventName, handler): Subscription

  • Type Parameters

    • TEventName extends EventKey<ActorEvents>

    Parameters

    Returns Subscription

  • once(eventName, handler): Subscription

  • Parameters

    • eventName: string
    • handler: Handler<unknown>

    Returns Subscription

reinitialize

removeAllChildren

  • removeAllChildren(): Entity

  • Removes all children from this entity

    Returns Entity

removeChild

  • removeChild(entity): Entity

  • Remove an entity from children if it exists

    Parameters

    • entity: Entity

    Returns Entity

removeComponent

  • removeComponent<ComponentOrType>(componentOrType, force?): Entity

  • Removes a component from the entity, by default removals are deferred to the end of entity update to avoid consistency issues

    Components can be force removed with the force flag, the removal is not deferred and happens immediately

    Type Parameters

    • ComponentOrType extends string | Component<string>

    Parameters

    Returns Entity

removeTag

  • removeTag(tag, force?): Entity

  • Removes a tag on the entity

    Removals are deferred until the end of update

    Parameters

    • tag: string
    • Optional force: boolean

      Remove component immediately, no deferred

    Returns Entity

unkill

  • unkill(): void

  • If the current actor is killed, it will now not be killed.

    Returns void

unparent

  • unparent(): void

  • Unparents this entity, if there is a parent. Otherwise it does nothing.

    Returns void

update

  • update(engine, delta): void
  • Internal

    Called by the Engine, updates the state of the actor

    Parameters

    • engine: Engine

      The reference to the current game engine

    • delta: number

      The time elapsed since the last update in milliseconds

    Returns void

within

  • within(actor, distance): boolean

  • Returns true if the two actor.collider's surfaces are less than or equal to the distance specified from each other

    Parameters

    • actor: Actor

      Actor to test

    • distance: number

      Distance in pixels to test

    Returns boolean

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc