feat(engine/loop): Added pause and resume functions (#28)

README.md

@@ -54,6 +54,18 @@ Engine.onTick(({usage, ms, status}) => {
 // -> { ms: 2, usage: 0.02, actionId: 1 }
 ```
 
+With `Engine.pause` you can pause the entire engine loop. All systems will call `onPause` function before.
+
+```ts
+await Engine.pause()
+```
+
+With `Engine.resume` you can start again the engine loop. All systems will call `onResume` function after the loop restarts.
+
+```ts
+await Engine.resume()
+```
+
 #### Add Actions To Queue
 When we use `addEntity`, `removeEntity`, `entity.updateComponent` and `entity.removeComponent` we can specify if we want to perform the action immediately or assign it a priority.
 
@@ -237,9 +249,19 @@ const exampleSystem: SystemFunction<IComponents> = async () => {
     await Engine.removeEntity({ids: [entityId]})
   };
 
+  const onResume = async () => {
+    console.log('system wake up')
+  }
+
+  const onPause = async () => {
+    console.log('system paused')
+  }
+
   return {
     components: [IComponents.EXAMPLE_COMPONENT],
     onLoad,
+    onResume,
+    onPause,
     onDestroy,
     onAdd,
     onUpdate,
@@ -252,7 +274,7 @@ await Engine.load({
   ticksPerSecond: 2,
 })
 
-Engine.onTick(({usage, ms, status}) => {
-  console.log({ms, usage, actionId: status?.id})
+Engine.onTick(({usage, ms, status, tickCount}) => {
+  console.log({ ms, usage, status, tickCount})
 })
 ```

src/engine.ts

@@ -529,6 +529,25 @@ export const engine = <
 		}
 	};
 
+	const pause = async () => {
+		for await (const system of systems) {
+			await system?.onPause?.();
+		}
+
+		loopRunning = false;
+	};
+
+	const resume = async () => {
+		lastTick = Date.now();
+		idealTick = Date.now();
+		loopRunning = true;
+		loop();
+
+		for await (const system of systems) {
+			await system?.onResume?.();
+		}
+	};
+
 	const hardReload = async () => {
 		for await (const system of [...systems].reverse().filter(Boolean)) {
 			const entities = systemEntitiesMap[system.id];
@@ -625,8 +644,6 @@ export const engine = <
 	};
 
 	const loop = async () => {
-		if (!loopRunning) return;
-
 		const now = Date.now();
 		const deltaTime = now - lastTick;
 
@@ -644,6 +661,8 @@ export const engine = <
 		if (_onTick) _onTick({ status, ms, usage, tickCount });
 
 		tickCount++;
+
+		if (!loopRunning) return;
 		loopId = setTimeout(loop, nextTick);
 	};
 
@@ -662,6 +681,9 @@ export const engine = <
 		clear,
 
 		load,
+		pause,
+		resume,
+
 		hardReload,
 
 		onTick,

src/types.ts

@@ -60,6 +60,8 @@ export interface EngineType<I, C extends string | number, D> {
 	clear: () => void;
 
 	load: (config?: LoadConfig) => Promise<void>;
+	pause: () => Promise<void>;
+	resume: () => Promise<void>;
 	hardReload: () => Promise<void>;
 
 	onTick: (cb: OnTickFunction) => void;
@@ -86,6 +88,8 @@ export interface SystemType<C> {
 	onRemove?: (id: number) => Promise<void>;
 
 	onLoad?: () => Promise<void>;
+	onResume?: () => Promise<void>;
+	onPause?: () => Promise<void>;
 	onDestroy?: () => Promise<void>;
 }
 

tests/system.test.ts

@@ -28,6 +28,12 @@ Deno.test('System', async (test) => {
 	const onLoadSystemAMock = spy(async () => {});
 	const onLoadSystemBMock = spy(async () => {});
 
+	const onPauseSystemAMock = spy(async () => {});
+	const onPauseSystemBMock = spy(async () => {});
+
+	const onResumeSystemAMock = spy(async () => {});
+	const onResumeSystemBMock = spy(async () => {});
+
 	const onDestroySystemAMock = spy(async () => {});
 	const onDestroySystemBMock = spy(async () => {});
 
@@ -38,6 +44,8 @@ Deno.test('System', async (test) => {
 		onUpdate: onUpdateSystemAMock,
 		onRemove: onRemoveSystemAMock,
 		onLoad: onLoadSystemAMock,
+		onPause: onPauseSystemAMock,
+		onResume: onResumeSystemAMock,
 		onDestroy: onDestroySystemAMock,
 	});
 
@@ -48,6 +56,8 @@ Deno.test('System', async (test) => {
 		onUpdate: onUpdateSystemBMock,
 		onRemove: onRemoveSystemBMock,
 		onLoad: onLoadSystemBMock,
+		onPause: onPauseSystemBMock,
+		onResume: onResumeSystemBMock,
 		onDestroy: onDestroySystemBMock,
 	});
 	await Engine.setSystems(systemA, systemB);
@@ -174,4 +184,28 @@ Deno.test('System', async (test) => {
 			Engine.clear();
 		});
 	});
+
+	await test.step('onPause', async (t) => {
+		await t.step('expect onPause to be called inside system', async () => {
+			await Engine.setSystems(systemA, systemB);
+			await Engine.pause();
+
+			assertSpyCall(onPauseSystemAMock, 0);
+			assertSpyCall(onPauseSystemBMock, 0);
+
+			Engine.clear();
+		});
+	});
+
+	await test.step('onResume', async (t) => {
+		await t.step('expect onResume to be called inside system', async () => {
+			await Engine.setSystems(systemA, systemB);
+			await Engine.resume();
+
+			assertSpyCall(onResumeSystemAMock, 0);
+			assertSpyCall(onResumeSystemBMock, 0);
+
+			Engine.clear();
+		});
+	});
 });