Enemy

Marks an entity as hostile. No data, no System — the whole component is the classification.

What it does

Enemy is a marker: a component class with no fields. Attaching it says one thing about an entity, that it is hostile, and every genre agrees on that much. A chase speed, a contact radius or a point value belongs to one subgenre's AI, so none of them live here.

Being a class rather than a string tag is what earns it a place. Code asks:

TypeScript

const hostile = entity.get(EnemyComponent);   // the component, or undefined

which cannot be typo'd the way entity.hasTag('enmey') can, and which the marketplace component graph can actually see.

Use it in a scene

A scene is just data — a list of entities, each with its components. At startup the SceneLoader turns this JSON into a live world; edit the file and reload to rebuild it.

Fastest path

bjs download scene Enemy

Pulls this exact scene into your project and runs it — no copy-paste. Add --all to grab the components and assets it needs too.

Or build it from scratch with the bjs CLI:

1Scaffold a project
```
npm create @babylonjsmarket/arcade@latest my-game
```
World, renderer, and dev server — ready to run.
2Install dependencies
```
cd my-game && npm install
```
3Add Enemy
```
bjs download Enemy
```
Copies its source into src/ so the scene resolves.
First time? Run bjs login once.
4Paste the scene into src/scenes/arcade-room.ts and run
```
npm run dev
```
SceneLoader builds the world from the JSON; reload to rebuild.

JSON

{
  "Enemy1": {
    "tags": ["enemy"],
    "components": {
      "Transform6DOF": { "x": 26, "y": 6, "z": 62 },
      "Enemy": {}
    }
  }
}

Props

None. "Enemy": {} is the whole declaration.

Events

Emits nothing and listens for nothing.

Dependencies

None.

Notes

There is no EnemySystem. A scene loader that finds no ${Name}System simply attaches the data, which is right for a marker: three unrelated consumers read it (targeting, impact, scoring) and none of them owns it.
Looking for the chase-and-bump swarm AI? That is TwinStickEnemy — it kept the behaviour and gave the bare name back to the marker.

Enemy.defs.ts

Enemy — definitions.

Holds the EnemyComponent class. No System lives here, which is the point: another component can name Enemy in a query, or type an event it listens for, without pulling Enemy's behaviour into its own bundle. Import from here, not from Enemy.ts.

Enemy.defs.ts

import { Component } from '@babylonjsmarket/ecs';
/** Marker for hostile entities. Pure classification — no data of its own. */
export class EnemyComponent extends Component {
  serialize(): Record<string, never> {
    return {}
  }
}

Enemy.ts

Enemy.ts — the hostile marker's public surface.

There is no EnemySystem, and that is the whole design: a marker declares a fact about an entity and leaves acting on it to whoever cares. In a space shooter the targeting code picks these ships as missile locks, the impact path decides whose rounds may hit them, and the kill path scores them — three consumers, no owner.

A scene loader that finds no ${Name}System for a component simply attaches the data, which is exactly right here.

Enemy.ts

export { EnemyComponent } from './Enemy.defs'

Enemy.defs.test.ts

3 ✓

EnemyComponent

is a marker: constructs with no arguments and holds no data
round-trips through serialize as an empty object
is queryable by class, which is why it is a component and not a tag

Last run 2026-08-22

Enemy.defs.test.ts

import { describe, it, expect } from 'vitest'
import { EnemyComponent } from './Enemy.defs'

describe('EnemyComponent', () => {
  it('is a marker: constructs with no arguments and holds no data', () => {
    const c = new EnemyComponent()
    expect(c).toBeInstanceOf(EnemyComponent)
    expect(Object.keys(c.serialize())).toHaveLength(0)
  })

  it('round-trips through serialize as an empty object', () => {
    // A scene declares it as `"Enemy": {}` and gets it back the same way, which
    // is what keeps a save file honest about a component that says one thing.
    const json = JSON.parse(JSON.stringify(new EnemyComponent().serialize()))
    expect(json).toEqual({})
  })

  it('is queryable by class, which is why it is a component and not a tag', () => {
    // The whole reason this exists: `get(EnemyComponent)` cannot be typo'd the
    // way a string tag can.
    const hostile: unknown = new EnemyComponent()
    expect(hostile instanceof EnemyComponent).toBe(true)
    expect(new (class Other {})() instanceof EnemyComponent).toBe(false)
  })
})

Enemy

Enemy

What it does

Use it in a scene

Props

Events

Dependencies

Notes

Enemy.defs.ts

Enemy.ts

Enemy.defs.test.ts

Enemy.defs.test.ts

More like this

Was this page helpful?