A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
fix(scene): reject transitions when completion callbacks fail
yhhf1d4f4df8ed3
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 0f07ea861..4d2743dea 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -22,6 +22,8 @@ published separately; it ships inside the editor.### Fixed+- **Scene completion errors settle the transition promise.** A throwing fade-completion callback rejects the caller's promise with its original error after clearing the old overlay, so callers can recover and later scene switches remain available. A callback that starts another fade keeps that new transition intact.+- **Input cancellation stops released scroll flings.** UI scrolling discards existing coast state when the host cancels input, so a list already gliding after release remains at its current offset when the app resumes. A new press can still start a fresh drag in the same frame.- **Native input resets when the host hides.** The native adapter cancels held touches, mouse buttons, keys and frame edges on hide or input teardown, resets the primary finger, removes its hide subscription and ignores late releases from the previous gesture.diff --git a/sdk/src/scene/SceneTransitionController.ts b/sdk/src/scene/SceneTransitionController.tsindex 1827cddd2..47a5c87d4 100644--- a/sdk/src/scene/SceneTransitionController.ts+++ b/sdk/src/scene/SceneTransitionController.ts@@ -63,7 +63,7 @@ export class SceneTransitionController {/*** Begin a fade transition. The returned promise resolves after fade-in* completes following a successful `performSwap`, or rejects with- * `performSwap`'s error. The controller drives the visual overlay via+ * a swap or lifecycle callback error. The controller drives the visual overlay via* `Draw.rect` on every frame until the state machine clears itself.*/start(options: FadeTransitionOptions, performSwap: () => Promise<void>): Promise<void> {@@ -129,10 +129,14 @@ export class SceneTransitionController {// Phase 3: fade-in done → resolve caller's promise.if (this.state_.phase === 'fade-in' && this.state_.elapsed >= halfDuration) {- const { resolve, onComplete } = this.state_;+ const { resolve, reject, onComplete } = this.state_;this.teardown_();- onComplete?.();- resolve();+ try {+ onComplete?.();+ resolve();+ } catch (error) {+ reject(error);+ }}}diff --git a/sdk/tests/scene-transition-callback-wasm.test.ts b/sdk/tests/scene-transition-callback-wasm.test.tsnew file mode 100644index 000000000..2a40acf1b--- /dev/null+++ b/sdk/tests/scene-transition-callback-wasm.test.ts@@ -0,0 +1,46 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+import { beforeAll, describe, expect, it } from 'vitest';+import { App } from '../src/app/app';+import { SceneManagerState } from '../src/scene/sceneManager';+import type { ESEngineModule } from '../src/wasm';+import { HAS_WASM, loadWasmModule } from './helpers/loadWasm';++describe.skipIf(!HAS_WASM)('scene completion failure on real WASM', () => {+ let engine: ESEngineModule;+ beforeAll(async () => { engine = await loadWasmModule(); });+ it('reports the callback error after swapping and releases the switch lock', async () => {+ const app = App.new();+ app.connectCpp(new engine.Registry(), engine, { ownedRegistry: true });+ const manager = new SceneManagerState(app);+ try {+ for (const name of ['first', 'second', 'third'])+ manager.register({ name, setup: ctx => { ctx.spawn(); } });+ const first = await manager.load('first');+ const previous = [...first.entities][0];+ const error = new Error('completion failed');+ let outcome: unknown;+ let settled = false;+ const failed = manager.switchTo('second', { transition: 'fade', duration: .1,+ onComplete: () => { throw error; } }).catch(value => { outcome = value; }).finally(() => { settled = true; });+ for (let i = 0; i < 100 && !settled; i++) {+ expect(() => manager.updateTransition(1 / 30)).not.toThrow();+ await Promise.resolve();+ }+ expect(settled).toBe(true); await failed;+ expect(outcome).toBe(error);+ expect(manager.getActive()).toBe('second');+ expect(app.world.valid(previous)).toBe(false);+ expect(app.world.getAllEntities()).toHaveLength(1);+ settled = false;+ const next = manager.switchTo('third', { transition: 'fade', duration: .1 })+ .finally(() => { settled = true; });+ for (let i = 0; i < 100 && !settled; i++) {+ manager.updateTransition(1 / 30); await Promise.resolve();+ }+ expect(settled).toBe(true); await next;+ expect(manager.getActive()).toBe('third');+ expect(app.world.getAllEntities()).toHaveLength(1);+ } finally { app.quit(); }+ });+});diff --git a/sdk/tests/scene-transition-controller.test.ts b/sdk/tests/scene-transition-controller.test.tsindex 431820982..fdd89a0f6 100644--- a/sdk/tests/scene-transition-controller.test.ts+++ b/sdk/tests/scene-transition-controller.test.ts@@ -28,6 +28,38 @@ vi.mock('../src/render/draw', () => ({import { SceneTransitionController } from '../src/scene/SceneTransitionController';describe('SceneTransitionController', () => {+ it('rejects a completion callback failure and permits the next transition', async () => {+ const ctrl = new SceneTransitionController();+ const error = new Error('completion failed');+ const options = { duration: 1, color: { r: 0, g: 0, b: 0, a: 1 } };+ const pending = ctrl.start({ ...options, onComplete: () => { throw error; } }, async () => {});+ const rejected = expect(pending).rejects.toBe(error);+ ctrl.update(.6); await Promise.resolve(); ctrl.update(0);+ expect(() => ctrl.update(.6)).not.toThrow();+ await rejected;+ expect(ctrl.isTransitioning()).toBe(false);+ const next = ctrl.start(options, async () => {});+ ctrl.update(.6); await Promise.resolve(); ctrl.update(0); ctrl.update(.6);+ await next;+ expect(ctrl.isTransitioning()).toBe(false);+ });+ it('a failing callback does not tear down the transition it just started', async () => {+ const ctrl = new SceneTransitionController();+ const error = new Error('completion failed');+ const options = { duration: 1, color: { r: 0, g: 0, b: 0, a: 1 } };+ let next!: Promise<void>;+ const pending = ctrl.start({ ...options, onComplete: () => {+ next = ctrl.start(options, async () => {});+ throw error;+ } }, async () => {});+ const rejected = expect(pending).rejects.toBe(error);+ ctrl.update(.6); await Promise.resolve(); ctrl.update(0); ctrl.update(.6);+ await rejected;+ expect(ctrl.isTransitioning()).toBe(true);+ ctrl.update(.6); await Promise.resolve(); ctrl.update(0); ctrl.update(.6);+ await next;+ expect(ctrl.isTransitioning()).toBe(false);+ });it('resolves after fade-out → loading → fade-in on a successful swap', async () => {drawCalls.register.mockClear();drawCalls.unregister.mockClear();diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjsindex 67b44a3ec..420fa65d0 100644--- a/tools/releaseNotes.mjs+++ b/tools/releaseNotes.mjs@@ -28,6 +28,8 @@ export const NOTES_FLOOR = 'v0.65.0';* the reader recognises anyway.*/export const NOTED = {+ 'fix(scene): reject transitions when completion callbacks fail':+ { note: 'Scene completion errors settle the transition promise.' },'feat(examples): demonstrate independent sprite playback controls':{ note: 'Sprite playback can be tried independently of its state machine.' },'fix(ui): stop released scroll flings on input cancellation':