# handle.onFinished() [Operation handles](https://rustic-game-engine.pages.dev/markdown/api/operation-handles.md) ## Compatibility **Supported languages:** C, C++, C#, Python, JavaScript, Lua 5.4, Luau, Java, PHP and HTML/inline JavaScript (binding spellings and return shapes differ). Use a compatible native engine build and the language tools required by your binding. This does not establish browser/mobile export or release qualification for every OS. The signature below is the shared reference notation; language examples show the actual binding syntax. Question marks mark optional arguments and explicit defaults are shown where recorded. Do not copy reference notation as a typed declaration. See [Feature status and compatibility](https://rustic-game-engine.pages.dev/markdown/reference/compatibility.md) for API 1.0/1.1 and per-method restrictions. Engine release tags and Docs v0.1 are independent versions. ## Signature `handle.onFinished(callback)` ## Setup and usage These engine-owned services work in Lua 5.4, Luau, JavaScript, Python, C, C++, C#, Java, PHP, and HTML inline JavaScript. Follow [Use gameplay actions](https://rustic-game-engine.pages.dev/markdown/guides/gameplay-actions.md) to create and attach a script, install external toolchains, and choose the correct language binding. PHP and HTML scripts belong under `ui/`; CSS alone runs no gameplay code. The Calls section uses JavaScript signatures. The function examples below include native syntax for all ten script types, including SDK-specific alternatives and limitations. Attach a JavaScript Object Component script to the specified target and press **Play**. Globals are supplied by the engine. Schedule actions from `Start` or a callback, rather than at script top level. Native languages use typed options and their own builder conventions; see the guide's language bindings. ## Parameters Use the handle returned from Tween, Movement, Animation, Path, Timer, Sequence, Camera or Effects, or an audio fade. OnFinished takes a no-argument completion callback. C uses Gameplay.state/pause/resume/cancel/reverse with an explicit handle. ## Return and timing JavaScript controls return the handle for chaining; state returns its retained status/error record, or undefined if absent from bounded history. Completion is queued during Update. Cancel and target destruction do not invoke onFinished. ## Execution behavior Core write timing differs between immediate Lua host calls, deferred JavaScript/Web commands and external SDK query flushes. Scheduled actions advance with the scene clock; synchronous queries evaluate at the call. Follow [execution rules](https://rustic-game-engine.pages.dev/markdown/guides/scripting.md#when-mutations-take-effect) and the return/timing notes for this category. ## Language examples Choose one snippet at a time and place it inside your language's Start/on_start callback. These are independent examples; each creates its own handles or builders. Follow [Gameplay language bindings](https://rustic-game-engine.pages.dev/markdown/guides/gameplay-actions/language-bindings.md) for imports and callback registration. Python must import the modules used in its snippet from rustic; C# uses using static Rustic; Java examples belong inside a Rustic subclass; PHP callbacks declare global $rustic. HTML snippets go inside an inline script in a ui/ HTML asset. Use an anchored Part for transform and effect examples, an unanchored collidable Part for forces, and a perspective camera named Camera for camera examples. Create Target for follow examples. Audio examples require assets/music.ogg in the Play snapshot. Replace scene paths with those listed by Game.scene.List(). Animation playback and sequence-animation examples require the Reveal fixture on the [Animation page](https://rustic-game-engine.pages.dev/markdown/api/animation.md); marker callbacks also require its Halfway marker. Run clock controls separately; a paused clock cannot advance a timer. C callback examples use these file-scope functions before on_start: ```c static void on_done(void) { rustic.log("info", "done"); } static void on_sample(RusticValue value) { (void)value; rustic.log("info", "sample received"); } static void on_event(const RusticValue *args, size_t count) { (void)args; (void)count; rustic.log("info", "event received"); } ``` ### Lua 5.4 ```lua local handle = Tween.move(rustic.entity_id(), {10,0,0}, 2, Ease.OutCubic) handle.onFinished(function() rustic.log("info", "done") end) ``` ### JavaScript ```javascript const handle = Tween.move(rustic.entity_id(), [10,0,0], 2, Ease.OutCubic); handle.onFinished(() => rustic.log("info", "done")); ``` ### Python ```python handle = Tween.move(rustic.entity_id(), [10,0,0], 2, Ease.OutCubic) handle.onFinished(lambda : rustic.log("info", "done")) ``` ### C++ ```cpp auto handle = Tween::move(rustic.entity_id(), {10,0,0}, 2, Ease::OutCubic); handle->onFinished([]() { rustic.log("info", "done"); }); ``` ### C# ```csharp var handle = Tween.move(rustic.entity_id(), new double[]{10,0,0}, 2, Ease.OutCubic); handle.onFinished(() => rustic.log("info", "done")); ``` ### Luau ```lua local handle = Tween.move(rustic.entity_id(), {10,0,0}, 2, Ease.OutCubic) handle.onFinished(function() rustic.log("info", "done") end) ``` ### C ```c RusticGameplayHandle handle = Tween.move(rustic.entity_id(), (RusticVector3){10,0,0}, 2, Ease.OutCubic, NULL); Gameplay.onFinished(handle, on_done); ``` ### Java ```java var handle = Tween.move(rustic.entity_id(), new double[]{10,0,0}, 2, Ease.OutCubic); handle.onFinished(() -> rustic.log("info", "done")); ``` ### PHP ```php $handle = Tween::move($rustic->entity_id(), [10,0,0], 2, Ease::OutCubic); $handle->onFinished(fn() => $rustic->log("info", "done")); ``` ### HTML / inline JS ```javascript const handle = Tween.move(rustic.entity_id(), [10,0,0], 2, Ease.OutCubic); handle.onFinished(() => rustic.log("info", "done")); ``` ## Shared Operation handles constraints - An anchored Part waits one scene second, resumes its two-second movement and prints finished when it reaches the destination. - Reverse supports tween/value/move/lookAt/path/orbit/wait actions. It is unsupported for sequence/parallel/follow/shake/animation handles. - At most 8192 operations and 65536 aggregate action nodes are retained; finished history is bounded to 1024 operations. Do not treat state as permanent storage. - Removing a target cancels referencing actions and queued completion callbacks. Disabling/destroying an owner, successful reload and scene disposal release its resources; a failed reload preserves the previous operations. - Animation playback adds stop (cancel), speed, loop and onMarker controls. Audio voices have their own pause/resume/stop controls and are distinct from fade handles. - Check script attachment, enabled state and the Console when an operation fails. Asynchronous errors also appear in operation state. Callback exceptions disable the owner and clean up its actions. - Owner destruction, disable, successful reload or Stop cleans up owned actions and subscriptions. Failed reload retains the previous behavior's operations. See [Operation handles](https://rustic-game-engine.pages.dev/markdown/api/operation-handles.md) for controls and lifetime details. ## Errors and debugging Read the constraints above and the Console diagnostic. Invalid types, non-finite values, stale targets or unavailable native services can fail validation. A failed callback disables the behavior; a failed source reload keeps the last good instance. Exact error messages depend on the language adapter. See [Troubleshooting](https://rustic-game-engine.pages.dev/markdown/troubleshooting.md). ## Related APIs - [handle.state()](https://rustic-game-engine.pages.dev/markdown/api/operation-handles/handle-state.md) - [handle.pause()](https://rustic-game-engine.pages.dev/markdown/api/operation-handles/handle-pause.md) - [handle.resume()](https://rustic-game-engine.pages.dev/markdown/api/operation-handles/handle-resume.md) - [handle.cancel()](https://rustic-game-engine.pages.dev/markdown/api/operation-handles/handle-cancel.md) - [handle.reverse()](https://rustic-game-engine.pages.dev/markdown/api/operation-handles/handle-reverse.md) [All operation-handles APIs](https://rustic-game-engine.pages.dev/markdown/api/operation-handles.md)