@cyclonium/core 0.0.103 → 0.0.105

package/lib/export/internal.d.ts

@@ -1,2 +1,3 @@
 export { cycloBuiltinClass } from '../decorator/legacy/legacy-decorator.ts';
+export { TimeAccumulator } from '../framework/time-accumulator.js';
 //# sourceMappingURL=internal.d.ts.map

package/lib/export/internal.js

@@ -1,2 +1,3 @@
 export { cycloBuiltinClass } from "../decorator/legacy/legacy-decorator.js";
+export { TimeAccumulator } from '../framework/time-accumulator.js';
 //# sourceMappingURL=internal.js.map

package/lib/framework/component.js

@@ -12,6 +12,7 @@ import { addFrameTask, TaskPriority } from "./tasking.js";
 import { CoroutineRunner, stopCoroutine as stopCoroutineRecord } from "./coroutine.js";
 import { retainIf } from '@cyclonium/algorithm/retain-if';
 import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+import { TimeAccumulator } from './time-accumulator.js';
 class ComponentScheduler {
     enableComponent(component) {
         const index = this._fixedUpdateRegistry.findIndex(({ component: c }) => c === component);
@@ -259,27 +260,22 @@ class FixedUpdateTask {
     update(deltaTime) {
         const scene = director.getScene();
         if (!scene) {
-            this._accumulatedTime = 0;
+            this._timeAccumulator.reset();
             return;
         }
-        const fixedTimeStep = this._fixedTimeStep;
+        const timeAccumulator = this._timeAccumulator;
+        const fixedTimeStep = timeAccumulator.timeStep;
         const maxSteps = this.maxSteps;
-        const accumulatedTime = this._accumulatedTime + deltaTime;
-        const expectedSteps = Math.floor(accumulatedTime / fixedTimeStep);
-        const overloading = expectedSteps > maxSteps;
+        const actualSteps = timeAccumulator.advance(deltaTime, maxSteps);
+        const overloading = deltaTime > maxSteps * fixedTimeStep;
         const previousOverloading = this._overloading;
         this._overloading = overloading;
-        let actualSteps = 0;
         if (overloading) {
-            actualSteps = maxSteps;
-            this._accumulatedTime = 0;
             if (overloading !== previousOverloading) {
-                this._emitOverloadingBegin(expectedSteps);
+                this._emitOverloadingBegin();
             }
         }
         else {
-            actualSteps = expectedSteps;
-            this._accumulatedTime = accumulatedTime - actualSteps * fixedTimeStep;
             if (overloading !== previousOverloading) {
                 this._emitOverloadingEnd();
             }
@@ -288,12 +284,10 @@ class FixedUpdateTask {
             globalComponentScheduler.invokeFixedUpdate(fixedTimeStep);
         }
     }
-    _fixedTimeStep = 1 / 60;
-    _accumulatedTime = 0;
+    _timeAccumulator = new TimeAccumulator(1 / 60);
     _overloading = false;
-    _emitOverloadingBegin(expectedSteps) {
+    _emitOverloadingBegin() {
         // todo
-        void expectedSteps;
     }
     _emitOverloadingEnd() {
         // todo

package/lib/framework/time-accumulator.d.ts

@@ -0,0 +1,10 @@
+export declare class TimeAccumulator {
+    constructor(timeStep: number);
+    get timeStep(): number;
+    /** Adds at most `maxSteps` worth of elapsed time and consumes complete steps. */
+    advance(deltaTime: number, maxSteps: number): number;
+    reset(): void;
+    private readonly _timeStep;
+    private _accumulatedTime;
+}
+//# sourceMappingURL=time-accumulator.d.ts.map

package/lib/framework/time-accumulator.js

@@ -0,0 +1,29 @@
+export class TimeAccumulator {
+    constructor(timeStep) {
+        this._timeStep = timeStep;
+    }
+    get timeStep() {
+        return this._timeStep;
+    }
+    /** Adds at most `maxSteps` worth of elapsed time and consumes complete steps. */
+    advance(deltaTime, maxSteps) {
+        const timeStep = this._timeStep;
+        const maximumDeltaTime = maxSteps * timeStep;
+        const acceptedDeltaTime = Math.min(deltaTime, maximumDeltaTime);
+        const accumulatedTime = this._accumulatedTime + acceptedDeltaTime;
+        const steps = Math.min(countCompleteSteps(accumulatedTime, timeStep), maxSteps);
+        this._accumulatedTime = Math.max(accumulatedTime - steps * timeStep, 0);
+        return steps;
+    }
+    reset() {
+        this._accumulatedTime = 0;
+    }
+    _timeStep;
+    _accumulatedTime = 0;
+}
+function countCompleteSteps(accumulatedTime, timeStep) {
+    const stepRatio = accumulatedTime / timeStep;
+    const tolerance = Number.EPSILON * Math.max(Math.abs(stepRatio), 1) * 4;
+    return Math.floor(stepRatio + tolerance);
+}
+//# sourceMappingURL=time-accumulator.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonium/core",
-  "version": "0.0.103",
+  "version": "0.0.105",
   "repository": {
     "type": "git",
     "url": "https://github.com/shrinktofit/cyclonium",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@cyclonium/abort-controller": "0.0.102",
     "@cyclonium/algorithm": "1.0.0",
-    "@cyclonium/math": "0.0.103"
+    "@cyclonium/math": "0.0.104"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",