@ericrisco/rsc 0.1.35 → 0.1.36

package/skills/gamedev-physics/evals/cases.yaml

@@ -0,0 +1,54 @@
+skill: gamedev-physics
+
+should_trigger:
+  - prompt: "My player keeps falling through the floor when he moves fast, but it's fine when he walks slowly. Godot 4."
+    why: "Classic tunneling symptom (speed-dependent fall-through); routes here for CCD / fixed-tick + shapecast-then-move, not a generic debugger."
+  - prompt: "Two crates that should bump into each other just pass straight through. How do I set up the collision layer and mask so they collide?"
+    why: "Direct collision layer/mask filtering question — the #1-confusion section this skill owns."
+  - prompt: "In Unity should I put my rigidbody movement in Update or FixedUpdate? My box vibrates against the ground."
+    why: "Fixed-timestep placement + jitter stability, both core determinism topics; also touches the Unity version contract."
+  - prompt: "What's the difference between AddForce with Impulse mode, VelocityChange, and just setting velocity on a rigidbody?"
+    why: "Forces vs impulses vs direct velocity is an explicit section with a per-engine table."
+  - prompt: "I want a coin pickup that detects when the player walks over it but doesn't physically block them. What component do I use?"
+    why: "Trigger/Area overlap-with-no-response — colliders/triggers section; must not be treated as solid collision."
+  - prompt: "Building a first-person character controller in Godot 4 — how do I do gravity, jumping, and slopes with CharacterBody3D?"
+    why: "Character controller with move_and_slide/velocity and slope/step handling; also exercises the Godot 4 no-args move_and_slide version contract."
+  - prompt: "My rigidbody physics 'explodes' whenever a heavy object rests on a light one, or when I move the object by setting its transform each frame."
+    why: "Mass-ratio instability + writing transform on a dynamic body — two determinism guardrails this skill owns."
+
+should_not_trigger:
+  - prompt: "My water surface shader is shimmering and the reflections flicker at grazing angles. Fix the material."
+    route_to: "gamedev-shaders"
+    why: "Visual/material jitter from a shader, not simulated physics; explicitly delegated in the NOT-when clause."
+  - prompt: "My enemies need to find a path around obstacles to the player using a navmesh and avoid each other."
+    route_to: "gamedev-pathing"
+    why: "Navigation/pathfinding decides where to go; physics only executes the move. Delegated to gamedev-pathing."
+  - prompt: "How do I set up the Godot editor, import my project, and configure export templates for Android?"
+    route_to: "godot"
+    why: "Engine setup/editor/export tooling belongs to the godot engine skill, not the cross-engine physics concept skill."
+  - prompt: "Sync player movement across clients with server-authoritative netcode and rollback so it stays consistent."
+    route_to: "gamedev-multiplayer"
+    why: "Netcode/rollback is multiplayer's domain; this skill only supplies the deterministic fixed-tick foundation."
+  - prompt: "Design the combat loop and difficulty curve for my roguelike."
+    route_to: "game-design"
+    why: "Gameplay/systems design, no physics simulation, colliders, or bodies involved."
+
+capability:
+  - scenario: "User's fast bullet tunnels through thin walls in Unity 6, and they ask why and how to fix it, including a code snippet."
+    must_include:
+      - "Explains tunneling: the body moves more than its own thickness in one physics tick so no overlap is tested (discrete collision)"
+      - "Recommends enabling Continuous Collision Detection via Rigidbody.collisionDetectionMode = Continuous (or ContinuousDynamic/ContinuousSpeculative) on the fast body"
+      - "Offers the raycast/shapecast-then-move alternative for very small, very fast projectiles as more reliable than CCD"
+      - "Places physics movement in FixedUpdate, not Update"
+      - "Uses linearVelocity (not the deprecated Rigidbody.velocity) if it sets velocity directly, per Unity 6"
+  - scenario: "User asks for a Godot 4 CharacterBody3D controller with gravity, jump, and slope handling."
+    must_include:
+      - "Uses CharacterBody3D with a velocity property and calls move_and_slide() with NO arguments (Godot 4), not the Godot 3 move_and_slide(velocity, ...) signature"
+      - "Runs the movement in _physics_process(delta), the fixed-tick callback"
+      - "Adds gravity as velocity += gravity * delta but does NOT multiply the whole velocity by delta before move_and_slide()"
+      - "Uses is_on_floor() for grounded/jump checks and mentions floor_max_angle and/or floor_snap_length for slopes/steps"
+  - scenario: "User cannot get a pickup trigger and a colliding wall filtered correctly and asks about layers/masks."
+    must_include:
+      - "States layer = what the object is, mask = what it scans for, as independent bit sets"
+      - "Gives the correct per-engine mechanism: Godot collision_layer/collision_mask (mask must include the other's layer), Unity Layer Collision Matrix + LayerMask, or Unreal object channels + Block/Overlap/Ignore responses"
+      - "Uses a trigger/Area (Godot Area, Unity IsTrigger, Unreal Overlap response) for the detect-but-don't-block pickup, and notes a Unity trigger needs a Rigidbody on one object"

package/skills/gamedev-physics/references/character-controllers.md

@@ -0,0 +1,120 @@
+# Character controllers — kinematic vs dynamic, per engine
+
+A "character controller" is the code that turns intent (move left, jump) into collision-resolved
+motion. Two approaches; pick one and commit.
+
+## Kinematic vs dynamic — the trade
+
+| | Kinematic character | Dynamic (rigidbody) character |
+| --- | --- | --- |
+| Motion | you set velocity, a sweep resolves it | forces/impulses, solver resolves it |
+| Feel | precise, snappy, fully authored | physical, momentum-y, harder to make crisp |
+| Pushed by physics | no (you handle it) | yes, for free |
+| Pushes dynamics | yes | yes |
+| Gravity | you add it manually | automatic |
+| Typical use | platformers, shooters, most players | ragdoll-ish, vehicles, physics puzzles |
+| Pain points | you re-implement gravity/slopes/steps | tipping, sliding, jitter — needs constraints + friction |
+
+Default to **kinematic** for a controllable character. Reach for dynamic only when physical
+interaction *is* the gameplay.
+
+## Godot 4 — CharacterBody (kinematic)
+
+`CharacterBody2D/3D` exposes a `velocity` property and `move_and_slide()`, which sweeps by
+`velocity` (already delta-scaled) and slides along surfaces.
+
+```gdscript
+extends CharacterBody3D
+
+const SPEED := 5.0
+const JUMP_VELOCITY := 4.5
+
+func _physics_process(delta: float) -> void:
+    if not is_on_floor():
+        velocity += get_gravity() * delta          # get_gravity() is 4.3+; else read ProjectSettings
+    if Input.is_action_just_pressed("jump") and is_on_floor():
+        velocity.y = JUMP_VELOCITY
+    var input := Input.get_vector("left", "right", "up", "down")
+    var dir := (transform.basis * Vector3(input.x, 0, input.y)).normalized()
+    velocity.x = dir.x * SPEED
+    velocity.z = dir.z * SPEED
+    move_and_slide()
+```
+
+Tuning knobs on the node:
+- `up_direction` — defines "up" for floor/wall/ceiling classification (default `Vector3.UP`).
+- `floor_max_angle` — steepest slope treated as floor (radians; default 45°). Steeper = wall.
+- `floor_snap_length` — pulls the body to the ground while descending ramps/stairs (kills
+  launch-off-ramp and airborne-on-stairs). Requires `floor_stop_on_slope` behavior tuning.
+- `is_on_floor()` / `is_on_wall()` / `is_on_ceiling()`, `get_floor_normal()`,
+  `get_slide_collision_count()` + `get_slide_collision(i)` to inspect what was hit.
+- `move_and_collide(motion)` — lower-level single sweep returning a `KinematicCollision`; use when
+  you want full manual control (custom slide, wall-jump math).
+
+For one-off exact motion (dashes, kinematic bodies not needing slide) use `move_and_collide`.
+
+## Unity 6 — CharacterController (kinematic) and the dynamic alternative
+
+`CharacterController` is a built-in kinematic capsule with sweeping `Move`. It handles steps and
+slopes via `stepOffset` and `slopeLimit`; it does **not** apply gravity — you do.
+
+```csharp
+[RequireComponent(typeof(CharacterController))]
+public class Player : MonoBehaviour {
+    public float speed = 6f, jumpVelocity = 5f, gravity = -20f;
+    CharacterController cc;
+    Vector3 vel;               // world-space velocity we integrate ourselves
+
+    void Awake() => cc = GetComponent<CharacterController>();
+
+    void Update() {            // CharacterController is kinematic: Update is fine
+        if (cc.isGrounded && vel.y < 0f) vel.y = -2f;               // keep grounded
+        Vector3 wish = transform.right * Input.GetAxis("Horizontal")
+                     + transform.forward * Input.GetAxis("Vertical");
+        if (cc.isGrounded && Input.GetButtonDown("Jump")) vel.y = jumpVelocity;
+        vel.y += gravity * Time.deltaTime;                          // integrate gravity
+        cc.Move((wish * speed + Vector3.up * vel.y) * Time.deltaTime);
+    }
+}
+```
+
+Key fields: `isGrounded`, `slopeLimit` (max walkable slope), `stepOffset` (max step height),
+`skinWidth` (small penetration tolerance — keep ~10% of radius; too small causes jitter),
+`center`/`radius`/`height`. `Move` returns `CollisionFlags`; hook `OnControllerColliderHit` to push
+dynamic rigidbodies.
+
+**Dynamic rigidbody character** instead: `Rigidbody` with `freezeRotation = true` (or constrain
+X/Z rotation), a high-friction physics material, movement via `AddForce`/target-velocity in
+`FixedUpdate`, and a grounded raycast. More physical, more tuning.
+
+## Unreal (UE5) — Character + CharacterMovementComponent
+
+`ACharacter` bundles a capsule + `UCharacterMovementComponent` (CMC), a sophisticated kinematic
+controller. It sweeps, handles Walking / Falling / Swimming / Flying **movement modes**, and applies
+its own gravity scale.
+
+- **Input → movement:** `AddMovementInput(WorldDirection, ScaleValue)`; jump via `Jump()` /
+  `StopJumping()` (`ACharacter` overrides).
+- **Slopes/steps:** CMC `MaxStepHeight`, `SetWalkableFloorAngle` / `GetWalkableFloorAngle`,
+  `MaxWalkSpeed`, `GravityScale`, `JumpZVelocity`, `AirControl`.
+- **Ground state:** `Movement->IsMovingOnGround()`, `IsFalling()`; `CurrentFloor` holds the hit.
+- Moving platforms are handled by CMC's base-relative movement when the character stands on a
+  movable primitive set as its movement base.
+
+For non-Character pawns you can drive a movable component manually or add a `PawnMovementComponent`.
+
+## Ground detection, slopes, steps, moving platforms — the recurring problems
+
+- **Ground detection** must be robust: a single downward ray can miss on ledges. Use the built-in
+  `is_on_floor()` / `isGrounded` / `IsMovingOnGround()` where possible; if rolling your own, use a
+  short **shapecast** (capsule/sphere) slightly wider than the character, not a thin ray.
+- **Slopes:** set the max-walkable-angle knob so steep slopes read as walls; add slide-down on
+  too-steep surfaces if desired. Project intended velocity onto the floor plane to avoid bumpy speed
+  on ramps.
+- **Steps/stairs:** rely on `stepOffset` / `MaxStepHeight` / `floor_snap_length`. A capsule collider
+  climbs small steps far more smoothly than a box.
+- **Moving platforms:** the platform must be a **kinematic mover** that reports motion (Godot
+  `AnimatableBody` with `sync_to_physics = true`; Unity kinematic `Rigidbody.MovePosition` in
+  `FixedUpdate`; Unreal movable primitive as movement base). A **static** body will not carry a
+  character. For a kinematic character on a moving platform, add the platform's per-tick delta to the
+  character before moving, or parent to the platform's motion.

package/skills/gamedev-physics/references/determinism-and-queries.md

@@ -0,0 +1,124 @@
+# Determinism, stability & queries
+
+Most "my physics is unstable" reports reduce to running simulation in the wrong loop, scaling by the
+wrong delta, or tunneling. This is the fix list plus the query APIs.
+
+## The fixed timestep — where physics must live
+
+Engines separate the **render frame** (variable rate, once per drawn image) from the **physics tick**
+(fixed rate, e.g. 60 Hz). The solver assumes a constant `dt`; feeding it a variable frame time makes
+behavior frame-rate-dependent — the same jump reaches different heights at 30 vs 144 fps.
+
+| Engine | Fixed-tick callback | Rate setting |
+| --- | --- | --- |
+| Godot 4 | `_physics_process(delta)` | `Engine.physics_ticks_per_second` / Project Settings → Physics → Physics Ticks per Second (default 60) |
+| Unity 6 | `FixedUpdate()` | `Time.fixedDeltaTime` / Project Settings → Time → Fixed Timestep |
+| Unreal | Chaos **substepping** / Async Physics Tick | Project Settings → Physics → Substepping (`Max Substep Delta Time`, `Max Substeps`) |
+
+**Pattern:** poll input in the frame update (`_process` / `Update` / `Tick`), cache intent, then
+*apply* forces/velocity and run physics queries in the fixed tick. Never move a physics body or read
+physics state from the render frame.
+
+In Unreal, enabling **Substepping** lets the solver take several fixed sub-steps within a long frame,
+keeping constraints stable at low fps; for hard determinism use the Chaos async physics tick, which
+runs your callback at a fixed rate off the game thread.
+
+## Scale by delta — but not twice
+
+- Manual position changes, accelerations, and continuous forces you integrate yourself: multiply by
+  the tick delta (`delta` / `fixedDeltaTime`).
+- Helpers that already integrate time: do **not** delta-scale their input. Godot `move_and_slide()`
+  takes a per-second `velocity` and applies the timestep internally. Unity `CharacterController.Move`
+  expects a per-*frame* displacement, so you pass `velocity * Time.deltaTime` (velocity is per
+  second) — the classic mistake is forgetting the delta there while double-applying it elsewhere.
+- Gravity done by hand: `velocity += gravity * delta` each tick (gravity is an acceleration).
+
+## Interpolation — smooth visuals without touching the sim
+
+At frame rates above the tick rate, rendering the raw physics position looks choppy. Turn on
+interpolation to render an in-between pose; it is **purely visual** and never alters the simulation.
+
+- Godot 4: physics interpolation (Project Settings → Physics → Common → Physics Interpolation, plus
+  per-node where applicable).
+- Unity: `Rigidbody.interpolation = RigidbodyInterpolation.Interpolate` (or `Extrapolate`).
+- Unreal: interpolation handled by the movement/render sync; async physics results are interpolated.
+
+## Tunneling & CCD
+
+A fast body moving more than its own thickness per tick can pass fully through a thin collider before
+any overlap is tested (discrete collision). Fixes, cheapest first:
+
+1. Make the wall/collider thicker than the fastest per-tick travel, or the projectile bigger.
+2. Enable **Continuous Collision Detection** on the *fast* body only (it is expensive):
+   - Godot: `continuous_cd` (RigidBody2D: Disabled / Cast Ray / Cast Shape; RigidBody3D: on/off).
+   - Unity: `Rigidbody.collisionDetectionMode = Continuous` / `ContinuousDynamic` /
+     `ContinuousSpeculative`.
+   - Unreal: **Use CCD** on the body instance.
+3. For bullets, prefer a **raycast/shapecast-then-move**: sweep from last position to next, and if it
+   hits, resolve at the hit point. This is more reliable than CCD for very small, very fast objects.
+
+## Other stability rules
+
+- **Mass ratios:** keep interacting/jointed bodies within ~10:1 (100:1 blows up). Very light bodies
+  under very heavy ones jitter or get ejected.
+- **Never scale a collider at runtime.** Scaling the transform of a body with a collider (especially
+  non-uniform scale) corrupts the shape and broadphase — swap the shape or size the shape resource
+  instead.
+- **Never write `transform`/`position`/`rotation` on a dynamic (simulated) body.** It teleports past
+  the solver, producing explosions, missed contacts, and ghost collisions. Move dynamics with
+  forces/impulses/velocity; move kinematics with the provided API (`MovePosition`,
+  `move_and_slide`, `SetWorldLocation` with sweep).
+- **Sleeping:** resting bodies sleep to save CPU and stop micro-jitter. Applying a force or a query
+  may need to wake them (`RigidBody.sleeping = false`, `Rigidbody.WakeUp()`); don't fight the sleep
+  system with tiny constant forces.
+- **Solver iterations:** if stacks/joints sag or jitter, raise solver iteration counts (Project/
+  physics settings) before hacking masses.
+
+## Queries — raycast, shapecast, overlap
+
+Run queries in the fixed tick so they see the simulated state, and filter by layer/mask/channel.
+
+**Godot 4** — via the space state (works in `_physics_process`):
+
+```gdscript
+var space := get_world_3d().direct_space_state
+var q := PhysicsRayQueryParameters3D.create(from, to)
+q.collision_mask = 0b0001                    # only scan layer 1
+q.exclude = [self]                           # ignore ourselves
+var hit := space.intersect_ray(q)            # {} if nothing; else position, normal, collider, ...
+```
+
+Shape sweep: `PhysicsShapeQueryParameters3D` + `intersect_shape` (overlap) or `cast_motion` (how far
+a shape can move before hitting). Node helpers `RayCast2D/3D` and `ShapeCast2D/3D` update every tick.
+
+**Unity 6:**
+
+```csharp
+int mask = LayerMask.GetMask("Ground");
+if (Physics.Raycast(origin, dir, out RaycastHit hit, dist, mask)) { /* hit.point, hit.normal */ }
+if (Physics.SphereCast(origin, radius, dir, out RaycastHit sh, dist, mask)) { /* swept */ }
+Collider[] hits = Physics.OverlapSphere(center, radius, mask);   // overlap test
+bool blocked = Physics.CheckSphere(center, radius, mask);        // cheap boolean
+```
+
+Use `RaycastNonAlloc` / `OverlapSphereNonAlloc` in hot paths to avoid garbage. 2D equivalents live on
+`Physics2D` (`Raycast`, `OverlapCircle`, `CircleCast`).
+
+**Unreal (UE5):**
+
+```cpp
+FHitResult Hit;
+FCollisionQueryParams Params(NAME_None, /*bTraceComplex=*/false, this);
+bool bHit = GetWorld()->LineTraceSingleByChannel(
+    Hit, Start, End, ECC_Visibility, Params);          // trace channel
+GetWorld()->SweepSingleByChannel(                      // shapecast
+    Hit, Start, End, FQuat::Identity, ECC_Pawn,
+    FCollisionShape::MakeSphere(30.f), Params);
+TArray<FOverlapResult> Overlaps;                       // overlap test
+GetWorld()->OverlapMultiByChannel(
+    Overlaps, Center, FQuat::Identity, ECC_WorldDynamic,
+    FCollisionShape::MakeBox(FVector(50)), Params);
+```
+
+Use `...ByObjectType` variants to query by object channels, `...ByChannel` for trace channels. Set
+`bTraceComplex = true` only when you need per-triangle precision (costly).

package/skills/gamedev-physics/references/layers-and-masks.md

@@ -0,0 +1,115 @@
+# Collision layers & masks — the filtering that trips everyone up
+
+The single most common physics bug that is not a crash: "these two things should collide and they
+don't," or "this ghost trigger fires on everything." Both are filtering. The concept is universal;
+only the words change.
+
+**Layer = what I *am*. Mask = what I *scan for*.** They are independent bit sets. A body being in
+layer 3 says nothing about what it collides with — that is the mask's job.
+
+## Godot 4
+
+Two properties on every `CollisionObject2D/3D` (StaticBody, RigidBody, CharacterBody, Area):
+
+- `collision_layer` — the layer bits this body occupies (what it *is*).
+- `collision_mask` — the layer bits this body scans (what it *looks for*).
+
+**The rule:** a contact is registered when **either** body's `collision_mask` intersects the
+other's `collision_layer`. It is an **OR**, which is why detection can be *asymmetric* — body A can
+detect body B even if B does not scan for A. This is deliberate (one-way triggers, sensors) but is
+also the classic footgun. **Keep layer/mask symmetric for solid collisions** unless you truly want
+one-way behavior.
+
+For an `Area2D/3D`, the split matters: the Area's **mask** determines which bodies/areas it
+*detects* (fires `body_entered` / `area_entered`); the Area's **layer** determines whether something
+else can detect the Area. A detector-only Area often has a mask set and layer cleared.
+
+Name your layers in **Project Settings → Layer Names → 2D/3D Physics** so the inspector shows
+"player / enemy / world / pickup" instead of bare numbers. Set bits from code with the helpers, not
+raw math:
+
+```gdscript
+set_collision_layer_value(2, true)   # I am on layer 2
+set_collision_mask_value(1, true)    # I scan layer 1
+set_collision_mask_value(3, true)    # ...and layer 3
+```
+
+Bits are 1-indexed in these helpers; the raw `collision_layer` int is a bitmask (layer 1 = value 1,
+layer 2 = value 2, layer 3 = value 4, ...). `collision_layer = 0b101` means layers 1 and 3.
+
+## Unity 6
+
+Physics filtering is layer-pair based, not per-object masks:
+
+1. Assign each GameObject a **Layer** (Inspector top-right; define names in Tags & Layers). Physics
+   layers are the same 32 layers used everywhere.
+2. **Project Settings → Physics → Layer Collision Matrix** (and Physics 2D separately) is a
+   checkbox grid: an unticked cell means those two layers **never** collide or trigger. This is the
+   global filter.
+3. Toggle a single pair at runtime: `Physics.IgnoreLayerCollision(layerA, layerB, true)` — or
+   `Physics.IgnoreCollision(colliderA, colliderB)` for two specific colliders.
+
+Queries take a **`LayerMask`** argument, which is a *different* use of the same layers — it says
+which layers the ray/overlap considers:
+
+```csharp
+// Build a mask from names, then raycast only against Ground + Enemy.
+int mask = LayerMask.GetMask("Ground", "Enemy");
+if (Physics.Raycast(origin, dir, out RaycastHit hit, 50f, mask)) { /* ... */ }
+```
+
+A `LayerMask` is a bitfield: `1 << layerIndex`. Combine with `|`, exclude with `~`. A common mistake
+is passing a layer *index* where a *mask* is expected — always shift or use `LayerMask.GetMask`.
+
+## Unreal (UE5, Chaos)
+
+Two axes per primitive component, configured via **Collision Presets** (Details → Collision):
+
+- **Object Type** — the single channel this component *is* (WorldStatic, WorldDynamic, Pawn,
+  PhysicsBody, or a custom object channel). This is "what I am."
+- **Collision Responses** — for every channel, one of **Block / Overlap / Ignore**. This is "how I
+  react to each kind of thing."
+
+For two components to physically **block**, *both* must respond Block to the other's object type. For
+an **overlap** event, at least one responds Overlap (and the other not Ignore) and **Generate
+Overlap Events** is enabled on both. Bundle a configuration into a named **Collision Preset**
+(Project Settings → Collision) so a whole class of actors shares it — e.g. a `Trigger` preset that
+overlaps Pawns and ignores everything else.
+
+**Trace channels** (Visibility, Camera, or custom) are a *separate* set used only by line/shape
+traces, distinct from object channels used for physical collision. A common error is tracing on an
+object channel or vice versa.
+
+```cpp
+// Custom object channel example (defined in DefaultEngine.ini as ECC_GameTraceChannel1).
+Comp->SetCollisionObjectType(ECC_Pawn);
+Comp->SetCollisionResponseToAllChannels(ECR_Ignore);
+Comp->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);
+Comp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
+Comp->SetGenerateOverlapEvents(true);
+```
+
+## Worked example — player / enemy / pickup / wall
+
+Desired: player and enemies collide with walls and each other; the pickup collides with nothing but
+detects the player touching it.
+
+| Thing | Godot layer | Godot mask | Unity layer / matrix | Unreal preset |
+| --- | --- | --- | --- | --- |
+| Wall | World | (none needed) | World; collides with Player, Enemy | BlockAll |
+| Player | Player | World, Enemy, Pickup | Player; collides World, Enemy | Pawn (blocks World/Pawn) |
+| Enemy | Enemy | World, Player, Enemy | Enemy; collides World, Player, Enemy | Pawn |
+| Pickup (Area/Trigger) | Pickup | Player | Pickup; **only** Player pair ticked, `IsTrigger` | Custom `Pickup`: overlap Pawn, ignore all else |
+
+The pickup is a **trigger/Area**: it scans only for the Player layer and produces an overlap event,
+never a solid collision.
+
+## Debug checklist when a collision "doesn't happen"
+
+- Do the layer/mask bits actually overlap? (Godot: is one body's mask covering the other's layer?)
+- Unity: is the pair ticked in the **Layer Collision Matrix**, and did you use 2D matrix for 2D?
+- Unity trigger: is there a **Rigidbody** on at least one of the two objects? Trigger events need one.
+- Unreal: are **both** set to Block (for solid) or is Generate Overlap Events on **both** (for overlap)?
+- Query returns nothing: are you passing a **mask/channel** that includes the target? Passing a raw
+  layer index instead of a shifted mask silently matches the wrong layer.
+- One-way collision you did not intend → Godot asymmetric mask; make it symmetric.