CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增Coroutine

Browse Source
This commit is contained in:
yhh
2020-12-23 17:14:16 +08:00
parent 8ed3eb24c3
commit fa10d5d4d5
9 changed files with 449 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
README.md
View File

@@ -3,198 +3,16 @@
## 交流群
点击链接加入群聊【ecs游戏框架交流】：https://jq.qq.com/?_wv=1027&k=29w1Nud6
## Getting Start
1. 初始化核心
```typescript
// 传入舞台宽高确定屏幕大小
let core = new es.Core(768, 1366);
```
2. 派发核心事件
```typescript
// 必须派发该事件 否则核心内所有更新事件将不会执行 egret写法:
es.Core.emitter.emit(es.CoreEvents.FrameUpdated, egret.getTimer());
// 必须派发该事件 否则核心内所有更新事件将不会执行 laya写法:
// es.Core.emitter.emit(es.CoreEvents.FrameUpdated, Laya.systemTimer.currTimer);
```
3. 创建主场景
```typescript
// 继承es.Scene来确定这是一个场景
class MainScene extends es.Scene {
public initialize(){
// 当场景构造函数执行完成后执行
}
public async onStart() {
// 当场景被激活时执行
}
}
```
4. 创建组件
```typescript
// 敌人组件 继承es.Component确定他是一个组件
// 组件当中不应该含有具体逻辑 只存储数据/属性
class SpawnerComponent extends es.Component {
public cooldown: number = -1;
public minInterval: number = 2;
public maxInterval: number = 60;
public minCount: number = 1;
public maxCount: number = 1;
public enemyType: EnemyType = EnemyType.worm;
public numSpawned: number = 0;
public numAlive: number = 0;
constructor(enemyType: EnemyType) {
super();
this.enemyType = enemyType;
}
}
enum EnemyType {
worm
}
```
5. 创建系统
```typescript
// 每个组件应对应一个系统 系统中负责游戏逻辑
class SpawnerSystem extends es.EntityProcessingSystem {
// 必须实现的构造函数
constructor(matcher: es.Matcher){
super(matcher);
}
// 当满足条件的实体会被派发至这统一进行处理
// 条件在Matcher中进行设置
processEntity(entity: es.Entity){
let spawner = entity.getComponent<component.SpawnerComponent>(component.SpawnerComponent);
if (spawner.numAlive <= 0)
spawner.enabled = true;
if (!spawner.enabled)
return;
if (spawner.cooldown <= -1) {
this.scheduleSpawn(spawner);
console.log("冷却时间已到，进入下一轮刷新 冷却时间:", spawner.cooldown);
spawner.cooldown /= 4;
}
spawner.cooldown -= es.Time.deltaTime;
if (spawner.cooldown <= 0) {
this.scheduleSpawn(spawner);
for (let i = 0; i < RandomUtils.randint(spawner.minCount, spawner.maxCount); i ++) {
console.log("创建敌人", entity.position.x, entity.position.y, spawner.enemyType, entity);
spawner.numSpawned ++;
spawner.numAlive++;
}
if (spawner.numAlive > 0)
spawner.enabled = false;
}
}
private scheduleSpawn(spawner: component.SpawnerComponent) {
spawner.cooldown = RandomUtils.randint(spawner.minInterval, spawner.maxInterval);
}
}
```
6. 创建实体、添加组件、激活实体处理器
```typescript
class MainScene extends es.Scene {
public async onStart() {
// 创建实体
let spawn = this.createEntity("spawn");
// 添加组件
spawn.addComponent(new component.SpawnerComponent(component.EnemyType.worm));
// 添加实体处理
// Matcher.all 代表对带有该组件的实体进行处理
// Matcher.one 代表对至少有一个该组件的实体进行处理
// Matcher.exclude 代表对不带该组件的实体进行处理
this.addEntityProcessor(new system.SpawnerSystem(new es.Matcher().all(component.SpawnerComponent)));
}
}
```
7. 激活场景
```typescript
// 设置MainScene为当前激活的场景
es.Core.scene = new MainScene();
```
### 示例地址
- [laya-demo](https://github.com/esengine/ecs-laya-demo)
- [egret-demo](https://github.com/esengine/ecs-egret-demo)
- [ecs-modern-egret](https://github.com/esengine/ecs-modern-egret)
![GIF](https://github.com/esengine/ecs-framework/blob/master/screenshot/GIF.gif)
## 扩展库
- [基于ecs-framework开发的astar/BreadthFirst/Dijkstra/GOAP目标导向计划 路径寻找库](https://github.com/esengine/ecs-astar)
- [基于ecs-framework开发的AI（BehaviourTree、UtilityAI）系统](https://github.com/esengine/BehaviourTree-ai))
## 版本计划功能
- [x] 简易ECS框架
- [x] 组件列表
- [x] 碰撞组件
- [x] 移动组件
- [x] 组件池
- [x] 基础碰撞组件（矩形、圆形、多边形碰撞）
- [x] 场景组件
- [x] 系统列表
- [x] 被动系统
- [x] 协调系统
- [x] 实体系统
- [x] 实体解析系统
- [x] 扩展库
- [x] string扩展
- [x] time扩展
- [x] [array扩展（Extension）](https://github.com/esengine/egret-framework/wiki/Array-%E6%89%A9%E5%B1%95%E8%AF%B4%E6%98%8E)
- [x] base64扩展
- [x] Stopwatch计数器
- [x] List池对象
- [x] Emitter事件发射器
- [x] Random随机类帮助
- [x] Rectangle矩形帮助类
- [x] Vector2向量帮助类
- [x] 全局管理器
- [x] 向量集Bitset
- [x] 图形帮助
- [x] 场景过渡
- [x] 场景渲染器
- [x] 常用碰撞检测
- [x] 数学库
- [x] 矩形类（Rectangle）
- [x] 简易2D矩阵类（Matrix2D）
- [x] 简易2d 向量类（Vector2）
- [x] 数学扩展库（MathHelper）
- [x] 掩码实用类（Flags）
- [x] 贝塞尔曲线（Bezier）
- [x] 物理系统（简易）
- [x] Collision碰撞检测
- [x] ColliderTrigger帮助
- [x] [Ray2D射线检测](https://github.com/esengine/egret-framework/wiki/Ray2D-2D%E5%B0%84%E7%BA%BF)
- [x] ShapeCollision 多种形状检测
- [x] RealtimeCollisions 实时碰撞检测
- [x] SpatialHash 网格检测
- [x] 事件处理器
## 关于用ecs框架（typescript/javascript）
ecs 是功能强大的实体组件系统。typescript与其他语言不同，因此我对ecs的设计尽可能的支持typescript特性。虽然ecs拥有标准实体组件系统，但在细节上有很大不同。创建标准ecs通常处于原始速度、缓存位置和其他性能原因。使用typescript，我们没有struct，因为没有必要匹配标准实体组件系统的设计方式，因为我们对内存布局没有那种控制。

2
demo/egret_demo

Submodule demo/egret_demo updated: 8e6b8d97f5...678dd72ede

2
demo/laya_demo

Submodule demo/laya_demo updated: 00aa1cd596...e8df98d44e

78
source/bin/framework.d.ts vendored
View File

@@ -96,6 +96,7 @@ declare module es {
* 全局访问系统
*/
_globalManagers: GlobalManager[];
_coroutineManager: CoroutineManager;
_timerManager: TimerManager;
width: number;
height: number;
@@ -133,6 +134,12 @@ declare module es {
* @param type
*/
static getGlobalManager<T extends es.GlobalManager>(type: any): T;
/**
* 启动一个coroutine。Coroutine可以将number延时几秒或延时到其他startCoroutine.Yielding
* null将使coroutine在下一帧被执行。
* @param enumerator
*/
static startCoroutine(enumerator: any): ICoroutine;
/**
* 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
* @param timeInSeconds
@@ -3497,6 +3504,77 @@ declare module es {
areEqual(value1: T, value2: T): boolean;
}
}
declare module es {
/**
* startCoroutine返回的接口，它提供了中途停止coroutine的能力。
*/
interface ICoroutine {
/**
* 停止Coroutine
*/
stop(): any;
/**
* 设置Coroutine是否应该使用deltaTime或unscaledDeltaTime进行计时
* @param useUnscaledDeltaTime
*/
setUseUnscaledDeltaTime(useUnscaledDeltaTime: boolean): ICoroutine;
}
class Coroutine {
/**
* 导致Coroutine在指定的时间内暂停。在Coroutine.waitForSeconds的基础上，在Coroutine中使用Yield
* @param seconds
*/
static waitForSeconds(seconds: number): WaitForSeconds;
}
/**
* 帮助类，用于当一个coroutine想要暂停一段时间时。返回Coroutine.waitForSeconds返回其中一个
*/
class WaitForSeconds {
static waiter: WaitForSeconds;
waitTime: number;
wait(seconds: number): WaitForSeconds;
}
}
declare module es {
/**
* CoroutineManager用于隐藏Coroutine所需数据的内部类
*/
class CoroutineImpl implements ICoroutine, IPoolable {
enumerator: any;
/**
* 每当产生一个延迟，它就会被添加到跟踪延迟的waitTimer中
*/
waitTimer: number;
isDone: boolean;
waitForCoroutine: CoroutineImpl;
useUnscaledDeltaTime: boolean;
stop(): void;
setUseUnscaledDeltaTime(useUnscaledDeltaTime: boolean): this;
prepareForUse(): void;
reset(): void;
}
class CoroutineManager extends GlobalManager {
/**
* 标志来跟踪我们何时处于更新循环中。
* 如果在更新循环中启动了一个新的coroutine，我们必须将它贴在shouldRunNextFrame列表中，以避免在迭代时修改一个数组
*/
_isInUpdate: boolean;
_unblockedCoroutines: CoroutineImpl[];
_shouldRunNextFrame: CoroutineImpl[];
/**
* 将IEnumerator添加到CoroutineManager中
* Coroutine在每一帧调用Update之前被执行
* @param enumerator
*/
startCoroutine(enumerator: any): CoroutineImpl;
update(): void;
/**
* 勾选一个coroutine，如果该coroutine应该在下一帧继续运行，则返回true。本方法会将完成的coroutine放回Pool
* @param coroutine
*/
tickCoroutine(coroutine: CoroutineImpl): boolean;
}
}
declare class ArrayUtils {
/**
* 执行冒泡排序

168
source/bin/framework.js
View File

@@ -197,6 +197,7 @@ var es;
* 全局访问系统
*/
this._globalManagers = [];
this._coroutineManager = new es.CoroutineManager();
this._timerManager = new es.TimerManager();
this._frameCounterElapsedTime = 0;
this._frameCounter = 0;
@@ -206,6 +207,7 @@ var es;
Core._instance = this;
Core.emitter = new es.Emitter();
Core.emitter.addObserver(es.CoreEvents.FrameUpdated, this.update, this);
Core.registerGlobalManager(this._coroutineManager);
Core.registerGlobalManager(this._timerManager);
Core.entitySystemsEnabled = enableEntitySystems;
this.initialize();
@@ -278,6 +280,14 @@ var es;
}
return null;
};
/**
* 启动一个coroutine。Coroutine可以将number延时几秒或延时到其他startCoroutine.Yielding
* null将使coroutine在下一帧被执行。
* @param enumerator
*/
Core.startCoroutine = function (enumerator) {
return this._instance._coroutineManager.startCoroutine(enumerator);
};
/**
* 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
* @param timeInSeconds
@@ -8827,6 +8837,164 @@ var es;
}(Set));
es.HashSet = HashSet;
})(es || (es = {}));
var es;
(function (es) {
var Coroutine = /** @class */ (function () {
function Coroutine() {
}
/**
* 导致Coroutine在指定的时间内暂停。在Coroutine.waitForSeconds的基础上，在Coroutine中使用Yield
* @param seconds
*/
Coroutine.waitForSeconds = function (seconds) {
return WaitForSeconds.waiter.wait(seconds);
};
return Coroutine;
}());
es.Coroutine = Coroutine;
/**
* 帮助类，用于当一个coroutine想要暂停一段时间时。返回Coroutine.waitForSeconds返回其中一个
*/
var WaitForSeconds = /** @class */ (function () {
function WaitForSeconds() {
this.waitTime = 0;
}
WaitForSeconds.prototype.wait = function (seconds) {
WaitForSeconds.waiter.waitTime = seconds;
return WaitForSeconds.waiter;
};
WaitForSeconds.waiter = new WaitForSeconds();
return WaitForSeconds;
}());
es.WaitForSeconds = WaitForSeconds;
})(es || (es = {}));
var es;
(function (es) {
/**
* CoroutineManager用于隐藏Coroutine所需数据的内部类
*/
var CoroutineImpl = /** @class */ (function () {
function CoroutineImpl() {
/**
* 每当产生一个延迟，它就会被添加到跟踪延迟的waitTimer中
*/
this.waitTimer = 0;
this.useUnscaledDeltaTime = false;
}
CoroutineImpl.prototype.stop = function () {
this.isDone = true;
};
CoroutineImpl.prototype.setUseUnscaledDeltaTime = function (useUnscaledDeltaTime) {
this.useUnscaledDeltaTime = useUnscaledDeltaTime;
return this;
};
CoroutineImpl.prototype.prepareForUse = function () {
this.isDone = false;
};
CoroutineImpl.prototype.reset = function () {
this.isDone = true;
this.waitTimer = 0;
this.waitForCoroutine = null;
this.enumerator = null;
this.useUnscaledDeltaTime = false;
};
return CoroutineImpl;
}());
es.CoroutineImpl = CoroutineImpl;
var CoroutineManager = /** @class */ (function (_super) {
__extends(CoroutineManager, _super);
function CoroutineManager() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this._unblockedCoroutines = [];
_this._shouldRunNextFrame = [];
return _this;
}
/**
* 将IEnumerator添加到CoroutineManager中
* Coroutine在每一帧调用Update之前被执行
* @param enumerator
*/
CoroutineManager.prototype.startCoroutine = function (enumerator) {
// 找到或创建一个CoroutineImpl
var coroutine = es.Pool.obtain(CoroutineImpl);
coroutine.prepareForUse();
// 设置coroutine并添加它
coroutine.enumerator = enumerator;
var shouldContinueCoroutine = this.tickCoroutine(coroutine);
if (!shouldContinueCoroutine)
return null;
if (this._isInUpdate)
this._shouldRunNextFrame.push(coroutine);
else
this._unblockedCoroutines.push(coroutine);
return coroutine;
};
CoroutineManager.prototype.update = function () {
this._isInUpdate = true;
for (var i = 0; i < this._unblockedCoroutines.length; i++) {
var coroutine = this._unblockedCoroutines[i];
if (coroutine.isDone) {
es.Pool.free(coroutine);
continue;
}
if (coroutine.waitForCoroutine != null) {
if (coroutine.waitForCoroutine.isDone) {
coroutine.waitForCoroutine = null;
}
else {
this._shouldRunNextFrame.push(coroutine);
continue;
}
}
if (coroutine.waitTimer > 0) {
// 递减，然后再运行下一帧，确保用适当的deltaTime递减
coroutine.waitTimer -= coroutine.useUnscaledDeltaTime ? es.Time.unscaledDeltaTime : es.Time.deltaTime;
this._shouldRunNextFrame.push(coroutine);
continue;
}
if (this.tickCoroutine(coroutine))
this._shouldRunNextFrame.push(coroutine);
}
var linqCoroutines = new linq.List(this._unblockedCoroutines);
linqCoroutines.clear();
linqCoroutines.addRange(this._shouldRunNextFrame);
this._shouldRunNextFrame.length = 0;
this._isInUpdate = false;
};
/**
* 勾选一个coroutine，如果该coroutine应该在下一帧继续运行，则返回true。本方法会将完成的coroutine放回Pool
* @param coroutine
*/
CoroutineManager.prototype.tickCoroutine = function (coroutine) {
var chain = coroutine.enumerator.next();
if (chain.done || coroutine.isDone) {
es.Pool.free(coroutine);
return false;
}
if (chain.value == null) {
// 下一帧再运行
return true;
}
if (chain.value instanceof es.WaitForSeconds) {
coroutine.waitTimer = chain.value.waitTime;
return true;
}
if (typeof chain.value == 'number') {
coroutine.waitTimer = chain.value;
return true;
}
if (chain.value instanceof CoroutineImpl) {
coroutine.waitForCoroutine = chain.value;
return true;
}
else {
return true;
}
};
return CoroutineManager;
}(es.GlobalManager));
es.CoroutineManager = CoroutineManager;
})(es || (es = {}));
var ArrayUtils = /** @class */ (function () {
function ArrayUtils() {
}

2
source/bin/framework.min.js vendored
View File

File diff suppressed because one or more lines are too long

17
source/src/ECS/Core.ts
View File

@@ -33,6 +33,7 @@ module es {
* 全局访问系统
*/
public _globalManagers: GlobalManager[] = [];
public _coroutineManager: CoroutineManager = new CoroutineManager();
public _timerManager: TimerManager = new TimerManager();
public width: number;
public height: number;
@@ -45,6 +46,7 @@ module es {
Core.emitter = new Emitter<CoreEvents>();
Core.emitter.addObserver(CoreEvents.FrameUpdated, this.update, this);
Core.registerGlobalManager(this._coroutineManager);
Core.registerGlobalManager(this._timerManager);
Core.entitySystemsEnabled = enableEntitySystems;
@@ -123,6 +125,15 @@ module es {
return null;
}
/**
* 启动一个coroutine。Coroutine可以将number延时几秒或延时到其他startCoroutine.Yielding
* null将使coroutine在下一帧被执行。
* @param enumerator
*/
public static startCoroutine(enumerator): ICoroutine {
return this._instance._coroutineManager.startCoroutine(enumerator);
}
/**
* 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
* @param timeInSeconds
@@ -130,7 +141,7 @@ module es {
* @param context
* @param onTime
*/
public static schedule(timeInSeconds: number, repeats: boolean = false, context: any = null, onTime: (timer: ITimer)=>void){
public static schedule(timeInSeconds: number, repeats: boolean = false, context: any = null, onTime: (timer: ITimer) => void) {
return this._instance._timerManager.schedule(timeInSeconds, repeats, context, onTime);
}
@@ -139,7 +150,7 @@ module es {
}
public startDebugDraw() {
this._frameCounter ++;
this._frameCounter++;
this._frameCounterElapsedTime += Time.deltaTime;
if (this._frameCounterElapsedTime >= 1) {
let memoryInfo = window.performance["memory"];
@@ -165,7 +176,7 @@ module es {
*/
protected onGraphicsDeviceReset() {
// 我们用这些来避免垃圾事件的发生
if (this._graphicsDeviceChangeTimer != null){
if (this._graphicsDeviceChangeTimer != null) {
this._graphicsDeviceChangeTimer.reset();
} else {
this._graphicsDeviceChangeTimer = Core.schedule(0.05, false, this, t => {

39
source/src/Utils/Coroutines/Coroutine.ts Normal file
View File

@@ -0,0 +1,39 @@
module es {
/**
* startCoroutine返回的接口，它提供了中途停止coroutine的能力。
*/
export interface ICoroutine {
/**
* 停止Coroutine
*/
stop();
/**
* 设置Coroutine是否应该使用deltaTime或unscaledDeltaTime进行计时
* @param useUnscaledDeltaTime
*/
setUseUnscaledDeltaTime(useUnscaledDeltaTime: boolean): ICoroutine;
}
export class Coroutine {
/**
* 导致Coroutine在指定的时间内暂停。在Coroutine.waitForSeconds的基础上，在Coroutine中使用Yield
* @param seconds
*/
public static waitForSeconds(seconds: number) {
return WaitForSeconds.waiter.wait(seconds);
}
}
/**
* 帮助类，用于当一个coroutine想要暂停一段时间时。返回Coroutine.waitForSeconds返回其中一个
*/
export class WaitForSeconds {
public static waiter: WaitForSeconds = new WaitForSeconds();
public waitTime: number = 0;
public wait(seconds: number): WaitForSeconds {
WaitForSeconds.waiter.waitTime = seconds;
return WaitForSeconds.waiter;
}
}
}

146
source/src/Utils/Coroutines/CoroutineManager.ts Normal file
View File

@@ -0,0 +1,146 @@
module es {
/**
* CoroutineManager用于隐藏Coroutine所需数据的内部类
*/
export class CoroutineImpl implements ICoroutine, IPoolable {
public enumerator: any;
/**
* 每当产生一个延迟，它就会被添加到跟踪延迟的waitTimer中
*/
public waitTimer: number = 0;
public isDone: boolean;
public waitForCoroutine: CoroutineImpl;
public useUnscaledDeltaTime: boolean = false;
public stop() {
this.isDone = true;
}
public setUseUnscaledDeltaTime(useUnscaledDeltaTime: boolean) {
this.useUnscaledDeltaTime = useUnscaledDeltaTime;
return this;
}
public prepareForUse() {
this.isDone = false;
}
public reset() {
this.isDone = true;
this.waitTimer = 0;
this.waitForCoroutine = null;
this.enumerator = null;
this.useUnscaledDeltaTime = false;
}
}
export class CoroutineManager extends GlobalManager {
/**
* 标志来跟踪我们何时处于更新循环中。
* 如果在更新循环中启动了一个新的coroutine，我们必须将它贴在shouldRunNextFrame列表中，以避免在迭代时修改一个数组
*/
public _isInUpdate: boolean;
public _unblockedCoroutines: CoroutineImpl[] = [];
public _shouldRunNextFrame: CoroutineImpl[] = [];
/**
* 将IEnumerator添加到CoroutineManager中
* Coroutine在每一帧调用Update之前被执行
* @param enumerator
*/
public startCoroutine(enumerator: any) {
// 找到或创建一个CoroutineImpl
let coroutine = Pool.obtain<CoroutineImpl>(CoroutineImpl);
coroutine.prepareForUse();
// 设置coroutine并添加它
coroutine.enumerator = enumerator;
let shouldContinueCoroutine = this.tickCoroutine(coroutine);
if (!shouldContinueCoroutine)
return null;
if (this._isInUpdate)
this._shouldRunNextFrame.push(coroutine);
else
this._unblockedCoroutines.push(coroutine);
return coroutine;
}
public update() {
this._isInUpdate = true;
for (let i = 0; i < this._unblockedCoroutines.length; i++) {
let coroutine = this._unblockedCoroutines[i];
if (coroutine.isDone) {
Pool.free(coroutine);
continue;
}
if (coroutine.waitForCoroutine != null) {
if (coroutine.waitForCoroutine.isDone) {
coroutine.waitForCoroutine = null;
} else {
this._shouldRunNextFrame.push(coroutine);
continue;
}
}
if (coroutine.waitTimer > 0) {
// 递减，然后再运行下一帧，确保用适当的deltaTime递减
coroutine.waitTimer -= coroutine.useUnscaledDeltaTime ? Time.unscaledDeltaTime : Time.deltaTime;
this._shouldRunNextFrame.push(coroutine);
continue;
}
if (this.tickCoroutine(coroutine))
this._shouldRunNextFrame.push(coroutine);
}
let linqCoroutines = new linq.List(this._unblockedCoroutines);
linqCoroutines.clear();
linqCoroutines.addRange(this._shouldRunNextFrame);
this._shouldRunNextFrame.length = 0;
this._isInUpdate = false;
}
/**
* 勾选一个coroutine，如果该coroutine应该在下一帧继续运行，则返回true。本方法会将完成的coroutine放回Pool
* @param coroutine
*/
public tickCoroutine(coroutine: CoroutineImpl) {
let chain = coroutine.enumerator.next();
if (chain.done || coroutine.isDone) {
Pool.free(coroutine);
return false;
}
if (chain.value == null) {
// 下一帧再运行
return true;
}
if (chain.value instanceof WaitForSeconds) {
coroutine.waitTimer = chain.value.waitTime;
return true;
}
if (typeof chain.value == 'number') {
coroutine.waitTimer = chain.value;
return true;
}
if (chain.value instanceof CoroutineImpl) {
coroutine.waitForCoroutine = chain.value;
return true;
} else {
return true;
}
}
}
}