Multiple collider for actor?

[pixelprodukt]

Hi,

I recently found out about excalibur and wanted to give it a try. First impression is really nice but now I came to a point where I'm not sure if there's a reasonable solution already existing in excalibur.

Let's say I want to have an npc. This npc should have a normal collider, so the player can't pass through him. But I also want it to have another collider for a trigger for example. Let's say for a top down perspective and you come close to an npc and then an exclamation mark icon pops up over it's head and if you press 'e' or smth while in this 'sensor collider' you start talking to that npc. I hope it's understandable what I mean.

As far as I understand, an actor can only have one collider which also could be a CompositeCollider. But the CompositeCollider (or the actor itself) can only have one kind of collisionType.

And as far as I understand, every collider needs to have an actor.

So the first solution that came to my mind would be something like a class which holds several actors. One with the graphics for the npc and the 'movement blocking collisions' and another actor with the 'sensor collider'. But then you got somewhat of a problem adding this to the scene and also this meta class should provide some form of synchronization for the position of the actors meaning it would need it's own update loop etc. This would all be doable but it just doesn't feels right.

And maybe my idea with a 'sensor collider' isn't even that great, until now with other frameworks there was often a good, framework agnostic way to do this kind of things.

So I'm hoping someone has an idea or could hint me in a direction I may not be seeing?

[pixelprodukt]

Ok, my bad. I thougt the ECS was some sort of optional thing, but as far as I understand, I should implement my own SensorComponent and a System for it and add it to the actor (or own entities).

[eonarheim]

Hi @pixelprodukt thanks for the kind words glad the first impression of Excalibur is nice!

Ok, my bad. I thougt the ECS was some sort of optional thing, but as far as I understand, I should implement my own SensorComponent and a System for it and add it to the actor (or own entities).

You're correct! We intended the ECS style to be totally optional if you don't want to use it so there is no need to dig into that if you'd rather not (most of the underlying Excalibur behavior is implemented with ECS, but for consumers of Excalibur can avoid it if they want).

That said building a SensorComponent could work, but you would need to implement the sensing collision logic on your own. If you want to build your own ECS system I'd start by building a system that listens for your sensor type component, then loops through all entities that have a sensor and compare it to your player or a list of colliders that you want to sense.

Here is a potential lofi way to build a sensor system (buyer beware ECS sample code untested 😃), but I recommend the child actor approach below for the quickest path to what you want 👍

export class SensorComponent {
  public readonly type = 'sensor';
  public radius: number = 10; // pixels away
  public onSense = (actor: Actor) => {... }; // callback to do something
}
export class SensorSystem extends System<TransformComponent | SensorComponent> {
  public readonly types = ['ex.transform', 'sensor'] as const;
  public systemType = SystemType.Update;
  public priority = -1;
  private _actorsToSense: Actor[] = [];
  public registerActorsToSense(actors: Actor[]) {
    this._actorsToSense = actors;
  }

  public update(entities: Entity[], elapsedMs: number): void {
    for(let entity of entities) {
       const tx = entity.get(TransformComponent);
       const sensor = entity.get(SensorComponent);
       for (let actor of this._actorsToSense) {
          if (actor.pos.distance(tx.pos) <= sensor.radius) {
             sensor.onSense(actor);
          }
       }
    }
  } 
}

const game = new ex.Engine({...});

const player = new ex.Actor({...});
game.currentScene.add(player);

const sensorSystem = new SensorSystem();
sensorSystem.registerActorsToSense([player]);
// Add ECS system to the ECS world
// Systems are scene specific so you may want to add this to each Scene in your game
game.currentScene.world.add(sensorSystem);

const npc = new ex.Actor({...});
npc.addComponent(new SensorComponent);
game.currentScene.add(npc);

And as far as I understand, every collider needs to have an actor.

This is currently true, and actor's can only have 1 collider as you said. I think using child actors might be the way.

Let's say I want to have an npc. This npc should have a normal collider, so the player can't pass through him. But I also want it to have another collider for a trigger for example. Let's say for a top down perspective and you come close to an npc and then an exclamation mark icon pops up over it's head and if you press 'e' or smth while in this 'sensor collider' you start talking to that npc. I hope it's understandable what I mean.
As far as I understand, an actor can only have one collider which also could be a CompositeCollider. But the CompositeCollider (or the actor itself) can only have one kind of collisionType.

One possible way to achieve this effect might be to have your main NPC character Actor with it's solid collisionType collider, then add a child actor to the NPC with a separate sensor collider with the collisionType you desire (maybe ex.CollisionType.Passive). This is pretty close to the solution you proposed but Excalibur will keep things things parented and in sync for you 👍 there is a similar idea to this (Option #2 here), but it's used for platforming and sensing the ground.

const playerGroup = ex.CollisionGroupManager.create('player'); // things in the same group do not collide
const player = new Actor({
  x: engine.halfDrawWidth,
  y: engine.halfDrawHeight,
  width: 20,
  height: 20,
  color: Color.Chartreuse,
  collisionType: CollisionType.Active,
  collisionGroup: playerGroup
});

const groundColliderActor = new ex.Actor({
  x: 0,
  y: offsetBelowPlayer,
  width: playerWidth,
  height: 32,
  color: ex.Color.Green, // color there just to visualize where the collider is
  collisionType: ex.CollisionType.Passive,
  collisionGroup: playerGroup
});

let activeGroundCollisions = 0;
groundColliderActor.on('collisionstart', () => {
  activeGroundCollisions++;
});
groundColliderActor.on('collisionend', () => {
  activeGroundCollisions--;
});
player.addChild(groundColliderActor);

const isPlayerOnGround = () => {
  return activeGroundCollisions > 0;
}

Hope this helps! Let me know if you have any issues or more questions!

[pixelprodukt]

Hi @eonarheim thank you so much for your long and detailed answer.
I tried a system similiar to what you posted, but your child actor approach is exactly what I was looking for 👍
I feel a bit embarrassed as I've gone through the actor class several times, thinking 'it would be cool if I can add an actor to another actor', not considering looking at the entity ';D So yes, childactor was what I was looking for, thank you.