◐ Shell
clean mode source ↗

esengine - Overview

Modular Game Framework for TypeScript

npm build license stars TypeScript Discord

English | 中文

Documentation · API Reference · Examples

What is ESEngine?

ESEngine is a collection of engine-agnostic game development modules for TypeScript. Use them with Cocos Creator, Laya, Phaser, PixiJS, or any JavaScript game engine.

The core is a high-performance ECS (Entity-Component-System) framework, accompanied by optional modules for AI, networking, physics, and more.

npm install @esengine/ecs-framework

Features

Module Description
ECS Core Entity-Component-System framework with reactive queries
Behavior Tree AI behavior trees with visual editor support
Blueprint Visual scripting system
FSM Finite state machine
Timer Timer and cooldown systems
Spatial Spatial indexing and queries (QuadTree, Grid)
Pathfinding A* and navigation mesh pathfinding
Procgen Procedural generation (noise, random, sampling)
RPC High-performance RPC communication framework
Network Client networking with prediction, AOI, delta compression
Database Game database with Redis/Memory storage
World Streaming Open world chunk loading and streaming

All modules are engine-agnostic and work with any rendering engine.

Quick Start

Using CLI (Recommended)

The easiest way to add ECS to your existing project:

# In your project directory
npx @esengine/cli init

The CLI automatically detects your project type (Cocos Creator 2.x/3.x, LayaAir 3.x, or Node.js) and generates the necessary integration code.

Manual Setup

import {
    Core, Scene, Entity, Component, EntitySystem,
    Matcher, Time, ECSComponent, ECSSystem
} from '@esengine/ecs-framework';

// Define components (data only)
@ECSComponent('Position')
class Position extends Component {
    x = 0;
    y = 0;
}

@ECSComponent('Velocity')
class Velocity extends Component {
    dx = 0;
    dy = 0;
}

// Define system (logic)
@ECSSystem('Movement')
class MovementSystem extends EntitySystem {
    constructor() {
        super(Matcher.all(Position, Velocity));
    }

    protected process(entities: readonly Entity[]): void {
        for (const entity of entities) {
            const pos = entity.getComponent(Position);
            const vel = entity.getComponent(Velocity);
            pos.x += vel.dx * Time.deltaTime;
            pos.y += vel.dy * Time.deltaTime;
        }
    }
}

// Initialize
Core.create();
const scene = new Scene();
scene.addSystem(new MovementSystem());

const player = scene.createEntity('Player');
player.addComponent(new Position());
player.addComponent(new Velocity());

Core.setScene(scene);

// Integrate with your game loop
function gameLoop(currentTime: number) {
    Core.update(currentTime / 1000);
    requestAnimationFrame(gameLoop);
}
requestAnimationFrame(gameLoop);

Using with Other Engines

ESEngine's framework modules are designed to work alongside your preferred rendering engine:

With Cocos Creator

import { Component as CCComponent, _decorator } from 'cc';
import { Core, Scene, Matcher, EntitySystem } from '@esengine/ecs-framework';
import { BehaviorTreeExecutionSystem } from '@esengine/behavior-tree';

const { ccclass } = _decorator;

@ccclass('GameManager')
export class GameManager extends CCComponent {
    private ecsScene!: Scene;

    start() {
        Core.create();
        this.ecsScene = new Scene();

        // Add ECS systems
        this.ecsScene.addSystem(new BehaviorTreeExecutionSystem());
        this.ecsScene.addSystem(new MyGameSystem());

        Core.setScene(this.ecsScene);
    }

    update(dt: number) {
        Core.update(dt);
    }
}

With Laya 3.x

import { Core, Scene } from '@esengine/ecs-framework';
import { FSMSystem } from '@esengine/fsm';

const { regClass } = Laya;

@regClass()
export class ECSManager extends Laya.Script {
    private ecsScene = new Scene();

    onAwake(): void {
        Core.create();
        this.ecsScene.addSystem(new FSMSystem());
        Core.setScene(this.ecsScene);
    }

    onUpdate(): void {
        Core.update(Laya.timer.delta / 1000);
    }

    onDestroy(): void {
        Core.destroy();
    }
}

Packages

All packages are engine-agnostic with zero rendering dependencies:

npm install @esengine/ecs-framework      # Core ECS
npm install @esengine/ecs-framework-math # Math utilities
npm install @esengine/behavior-tree      # AI behavior trees
npm install @esengine/blueprint          # Visual scripting
npm install @esengine/fsm                # State machines
npm install @esengine/timer              # Timers & cooldowns
npm install @esengine/spatial            # Spatial indexing
npm install @esengine/pathfinding        # Pathfinding
npm install @esengine/procgen            # Procedural generation
npm install @esengine/rpc                # RPC framework
npm install @esengine/network            # Client networking
npm install @esengine/server             # Game server
npm install @esengine/database           # Database abstraction
npm install @esengine/transaction        # Transaction system
npm install @esengine/world-streaming    # World streaming

Building from Source

git clone https://github.com/esengine/esengine.git
cd esengine

pnpm install
pnpm build

# Type check framework packages
pnpm type-check:framework

# Run tests
pnpm test

Documentation

Community

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting a pull request.

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

ESEngine is licensed under the MIT License. Free for personal and commercial use.

Made with care by the ESEngine community