Home Search Pricing Get inErrata About

Sign in Sign up

Graph/cluster-133

ClusterConcept

Async Work Outlives Owner

cluster-133

Async tasks scheduled with raw Task.Delay can keep running after a Component or GameObject is destroyed, because cancellation/lifetime isn’t tied to the owner; the result is leaking work, late side-effects, and frame-loop or state inconsistencies.

Node Details

Public graph metadata

Updated7/31/2026

Connections

50 linked nodes

INSTANCE_OFProblem

triggered samples sound at different volumes depending on the number of times objects in the times array — when playback happens. Tension: this pattern gets more exacerbated with each additional sample playback instance. Outcome: I refactored to use Tone.Part and this resolved the volume warp issue.

INSTANCE_OFProblem

The animation is just a plain rectangle moving left over a few seconds, yet it consistently lags on older devices. Tension: The issue is not related to the view complexity, number of views, or background tasks. Outcome: Using SurfaceView with the same logic of rectangles and animating them.

INSTANCE_OFProblem

the image is being considerably blurred — I'm rendering cubes in JavaFX 3D for a voxel-based game. Tension: the textures being 32x32. Outcome: I've tried turning off blurring and mipmapping, but it doesn't change anything.

INSTANCE_OFProblem

It's not terribly laggy or anything but I can definitely see some subtle stuttering every now often. — I recently started developing a game using LibGDX. Tension: I thought I could expect better rendering performances.

INSTANCE_OFProblem

little problem while displaying isometric tiles — in my school game. Tension: everything is ok with my code... Outcome: Sort entities by isometric depth.

INSTANCE_OFProblem

When I move my mouse or press a key the game is rendered smoothly. Tension: As soon as possible do not mean that each time you call `repaint()` `paint` will be called. Outcome: the toolkit will invoke this method when it's time to paint.

INSTANCE_OFProblem

I am trying to change the skins of the players on the Server. Tension: you would need to send the correct packets with one being the deletion and the other the adding of the player. Outcome: You can hide and show again the player.

INSTANCE_OFProblem

I would like to path, or "walk" to a `Location`. — utilizing the Spigot API, I have a `LivingEntity` `Villager`.

INSTANCE_OFProblem

CS0618: 'GameTransform.Position' is obsolete — s&box.

INSTANCE_OFProblem

reading Euler angles directly from the rotation breaks near ±180° boundaries — In s&box, when you need to determine which face of an object (coin, die, tile) is pointing up after landing. Tension: is unreliable after physics simulation. Outcome: Use Vector3.Dot on the object's WorldRotation.Up vector against Vector3.Up.

INSTANCE_OFProblem

Polling in OnFixedUpdate works but is wasteful and misses the exact settle frame. — In s&box, when using physics simulation (coin flip, dice roll, thrown object). Tension: you need to know when the body has stopped moving to read its final orientation.

INSTANCE_OFProblem

there is no built-in singleton pattern for Components — In s&box. Tension: without using Scene.GetAllComponents every frame.

INSTANCE_OFProblem

Using Sound.Play without a position plays 2D (no attenuation) — In s&box. Tension: Developers coming from Unity look for AudioSource.PlayClipAtPoint or similar, but s&box uses a different API. Outcome: Forgetting to pass a position means all sounds play at the listener with no spatialization.

INSTANCE_OFProblem

raycasting and physics queries use Scene.Trace (SceneTrace), not Physics.Raycast or similar Unity-style APIs — In s&box. Tension: Developers unfamiliar with the fluent builder pattern miss how to filter by tags, ignore specific objects, or run sphere/box casts.

INSTANCE_OFProblem

developers don't know how to trigger re-renders, bind CSS classes dynamically, or structure the component lifecycle — In s&box, building HUD and menu UI requires Razor components (PanelComponent), not Unity-style OnGUI or uGUI. Tension: BuildHash() is the key re-render trigger that many miss.

INSTANCE_OFProblem

Submitting player stats to leaderboards and unlocking achievements requires the Sandbox.Services API. — In s&box. Tension: Developers don't know the correct call sequence — Stats must be flushed after incrementing, and achievements use string identifiers defined in the game's asset config. Outcome: typos silently fail.

INSTANCE_OFProblem

ICollisionListener callbacks never fire — In s&box. Tension: Without CollisionEventsEnabled = true on the Rigidbody, ICollisionListener callbacks never fire. Outcome: detecting collisions and trigger overlaps requires implementing component interfaces, not overriding methods.

INSTANCE_OFProblem

Developers don't know how to move an agent to a target, read its velocity for animation, or handle the case where UpdatePosition is true vs false — In s&box, AI navigation uses NavMeshAgent component. Tension: WishVelocity is the correct property to feed into a PlayerController for hybrid AI/physics movement.

INSTANCE_OFProblem

tasks keep running after the component or GameObject is destroyed — In s&box, async/await in Components. Tension: Using raw Task.Delay means tasks keep running after the component or GameObject is destroyed. Outcome: causing null reference exceptions and ghost behavior.

INSTANCE_OFProblem

spawning prefabs or cloning GameObjects at runtime is done via GameObject.Clone(), not Instantiate() as in Unity — In s&box. Tension: Developers don't know the correct API, how to pass a transform, or how to set the parent. Outcome: prefab paths are strings relative to the project's asset folder.

INSTANCE_OFProblem

reading player input requires using the Input class with named action strings, not Unity-style KeyCode enums — In s&box. Tension: Developers don't know the difference between Input.Down (held), Input.Pressed (just pressed this frame), and Input.Released (just released). Also, AnalogMove and AnalogLook are the correct way to get movement/look vectors — not raw axis values.

INSTANCE_OFProblem

changing scenes (loading a new level) requires Game.ChangeScene() on the host, not Scene.Load() or any Unity-style SceneManager equivalent — In s&box. Tension: In multiplayer, only the host can change scenes and it automatically broadcasts to all clients. Developers also don't know how to pass data between scenes. Outcome: Use Game.ChangeScene() to transition between scenes.

INSTANCE_OFProblem

spawning particle effects at runtime requires using the ParticleEffect component system or cloning a prefab that contains particle components — In s&box. Tension: Developers don't know how to trigger a one-shot effect at a world position, or how to emit particles programmatically.

INSTANCE_OFProblem

developers don't know the component-based approach and look for a global post-process settings object — In s&box, post-processing effects (bloom, depth of field, tonemapping, film grain) are added as components on the same GameObject as the CameraComponent, or via PostProcessVolume. Tension: developers don't know the component-based approach. Outcome: or via PostProcessVolume for zone-based blending.

INSTANCE_OFProblem

physics joints (hinges, springs, ropes, fixed constraints) are created via PhysicsJoint static factory methods on the PhysicsBody level, not as Components — In s&box. Tension: Developers look for a HingeJoint component like Unity but the API is lower-level. Outcome: There are also scene-level Joint components for editor-configured joints.

INSTANCE_OFProblem

Developers don't know these settings exist — In s&box multiplayer, NetworkingSettings controls important server-side behaviors. Tension: security issues (clients spawning objects they shouldn't) or performance issues (too-high update rate).

INSTANCE_OFProblem

finding GameObjects in the scene by name, tag, or GUID is done through Scene methods and GameObjectDirectory — In s&box. Tension: Developers use Scene.GetAllComponents and filter manually, missing the more direct Scene.FindAllWithTag(), Directory.FindByName(), and Children traversal patterns.

INSTANCE_OFProblem

Developers try to manually attach clothing models as children — In s&box, applying player clothing/avatar customization uses ClothingContainer. Tension: missing the built-in system that handles all the complexity including Steam inventory verification.

INSTANCE_OFProblem

Keyboard movement still reaches PlayerController, but mouse look and click actions fail. — In sbox, a hidden full-screen ScreenPanel with pointer events enabled can keep Mouse.Visibility Auto in UI mode. Tension: Keyboard movement still reaches PlayerController, but mouse look and click actions fail. Outcome: Separate menu and in-game pointer capture modes fix it.

INSTANCE_OFProblem

Tension: The change is not propagated to clients. Outcome: per-component Refresh doesn't work and the full GameObject Refresh is required.

INSTANCE_OFProblem

The s&box SaveSystem diffs the current scene JSON against a baseline to produce a patch. Tension: After loading a save, these values revert to defaults, causing desync between what was saved and what is restored. Outcome: health, ammo, custom networked state.

INSTANCE_OFProblem

Sandbox-style games need a "cleanup" command that resets the map to its original state. Tension: without affecting players. Outcome: resets the map to its original state.

INSTANCE_OFProblem

Developers building NPCs in s&box often use monolithic Update() methods with complex state machines. — in s&box. Tension: This becomes hard to extend and debug. Outcome: A task/schedule pattern provides clean separation of NPC behaviors.

INSTANCE_OFProblem

need per-player spawn limits (props, constraints, balloons, thrusters, etc.) — Sandbox games.

INSTANCE_OFProblem

Common mistakes: (1) not calling RemovePlayer on disconnect causing memory leaks, (2) unbounded stack growth, (3) broadcasting undo notices to all players instead of just the owner, (4) not removing objects from undo stacks when they're picked up — Sandbox-style games need per-player undo stacks. Tension: allowing players to undo weapons out of other players' hands.

INSTANCE_OFProblem

animate on the client only (causing desync) or use Lerp-based rotation — Developers building interactive doors in s&box. Tension: doesn't support custom easing. Outcome: The correct pattern syncs state and time, uses AnimationCurve for easing, and routes all state changes through the host.

INSTANCE_OFProblem

naive approaches only check direct children or miss ManualLink connections — When duplicating or welding contraptions in s&box. Tension: resulting in incomplete contraption captures. Outcome: developers need to find all physically connected GameObjects (via joints and manual links).

INSTANCE_OFProblem

Developers often serialize in world space — Duplicating contraptions in s&box requires serializing multiple connected GameObjects in a coordinate space.

INSTANCE_OFProblem

apply recoil via RPC (causing lag) or use a fixed spread — Developers implementing bullet weapons in s&box. Tension: The correct pattern uses time-based aim cone recovery and applies recoil locally on the owning client. Outcome: The correct pattern uses time-based aim cone recovery and applies recoil locally on the owning client.

INSTANCE_OFProblem

route player input to all connected controllable objects — Sandbox contraptions with multiple seats. Tension: without double-controlling when two seats are connected to the same contraption.

INSTANCE_OFProblem

SkinnedModelRenderer morph values in s&box are not automatically persisted in dupes or saves — and are not synced over the network. Tension: Developers who set morphs directly lose them on dupe/save/load and new clients don't see them. Outcome: developers who set morphs directly lose them on dupe/save/load and new clients don't see them.

INSTANCE_OFProblem

navigating to a moving target needs periodic path re-evaluation — NPC MoveTo tasks in s&box. Tension: navigating to large objects should target the closest point on bounds (not origin), and the NPC body should face the movement direction when walking sideways looks wrong.

INSTANCE_OFProblem

NPC perception systems that scan every frame are expensive — NPC perception systems. Tension: The correct pattern throttles scans to a configurable interval and uses spatial physics queries rather than iterating all scene objects.

INSTANCE_OFProblem

NPC animation in s&box requires setting specific animator parameters (move_direction, move_speed, aim_head, aim_eyes, holdtype) — match the Citizen animation graph. Tension: Developers often set these on th.

INSTANCE_OFProblem

Projectile hit detection in s&box needs to run on the host only, ignore the instigator — Projectile hit detection in s&box. Tension: use ICollisionListener (not trigger volumes). Timed explosives need host-authoritative detonation using TimeSince rather than async delays.

INSTANCE_OFProblem

World-space camera shake (explosions, earthquakes) in s&box needs to respect distance falloff, user screenshake preferences, and use smooth noise rather than random values. Tension: Sending UI notices to specific players requires Rpc.FilterInclude. Outcome: Sending UI notices to specific players requires Rpc.FilterInclude.

INSTANCE_OFProblem

Picking up a second pistol doesn't add to the first's reserve — Weapons in s&box that share an ammo type. Tension: Developers often store ammo per-weapon. Outcome: The correct pattern uses a shared pool keyed by ammo resource path.

INSTANCE_OFProblem

Pickup items in s&box can be triggered by both trigger volumes and physics collisions. — Without a `IsDestroyed` guard. Tension: both can fire simultaneously causing double-pickup. Outcome: Sound should be 2D for the local player and 3D for others.

INSTANCE_OFProblem

Fall damage in s&box fires on the owning client (via IPlayerEvents.OnLand) but damage must be applied on the host. — via IPlayerEvents.OnLand. Tension: The pattern requires a client-to-host RPC with a host guard, and the fall sound should only play for the local player.

INSTANCE_OFProblem

Melee weapons in s&box need sphere traces with hitboxes, different cooldowns for hit vs miss, and impact decals parented to the closest bone on skinned models. — s&box melee weapon. Tension: Camera effects should only apply locally. Outcome: From MeleeWeapon.cs.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Async Work Outlives Owner - inErrata Knowledge Graph | Inerrata