Agent skill · Audited from source
godot-physics
skill · gamedev-skills/awesome-gamedev-agent-skillsApache-2.0 licenceAudited 13 Nov 2026 · source c974b5ce8f0d
Is it safe? Yes — SAFE, grade B (89/100). We read this skill's source at commit c974b5ce8f0d and found no filesystem, network or shell access and no hard-coded secrets. What it does: Godot 4.7 physics API in 2D and 3D: body and Area types, collision_layer and mask bits, Area signals for hurtboxes, RayCast and space queries, and Jolt (3D default since 4.6). Use when objects pass through each other,…
Cite
Cite this page
ModelsAtlas. “godot-physics (gamedev-skills/awesome-gamedev-agent-skills)”. Retrieved 13 Nov 2026. https://modelsatlas.com/skills/gamedev-skills/godot-physics
Trust audit
Audit 0.4.1 · source read 13 Nov 2026
SAFE means nothing in the source contradicts what the skill says it does. Grade B is shared by 17,406 of 18,389 audited skills.
What the source does
- FilesystemNone observedNo reads or writes in the source
- NetworkNone observedNo outbound calls in the source
- ShellNone observedNo commands run in the source
- DependenciesPinnedNothing floats
- SecretsNone foundNo keys in source
Five audit layers
| Layer | What we check | Result | Findings |
|---|---|---|---|
L0 Provenance | Repo owner, licence, archive status, activity | PASS | 0 |
L1 Static source | Secrets, path traversal, supply chain, hidden code | NA | 0 |
L2 Instructions | Prompt injection, authority framing, hidden directives | PASS | 0 |
L3 Inventory | The files and declarations match the source | PASS | 0 |
L4 Sandbox | Run in isolation and watch behaviour | SKIPPED why | 0 |
Gates applied: no behavioural pass.
Findings (0)
No findings at any severity. We re-audit when the source changes.
Audit 0.4.1 · source sha c974b5ce8f0d · 13 Nov 2026Report an issue or request a re-scan
Provenance
Who published it, and what the verdict is pinned to
- Publishergamedev-skills GitHub organizationOwner of the repository this skill is read from
- Source foldergamedev-skills/awesome-gamedev-agent-skills/skills/godot/godot-physicsThe exact folder we audited
- LicenceApache-2.0As the repository states it
- Commit pinned for this verdictc974b5ce8f0dA new audit runs when the source changes
- Repository statusNot archivedPushed today
- Sandboxed runNot runSkills are read, not executed; layer L4 is skipped
What it tells the agent
Full source on GitHub ↗Its description: Godot 4.7 physics API in 2D and 3D: body and Area types, collision_layer and mask bits, Area signals for hurtboxes, RayCast and space queries, and Jolt (3D default since 4.6). Use when objects pass through each other,…
---
name: godot-physics
description: >
Godot 4.7 physics API in 2D and 3D: body and Area types, collision_layer and mask bits, Area
signals for hurtboxes, RayCast and space queries, and Jolt (3D default since 4.6). Use when
objects pass through each other, body_entered never fires or a raycast hits itself. Not for
engine-neutral jitter and tunnelling (`physics-tuning`) or CharacterBody movement
(`godot-2d-movement`).
---
# Godot Physics (4.x, 2D + 3D)
Pick the body type, wire collision layers and masks, detect overlaps, cast rays, and know
where Jolt differs. Swap the `2D`/`3D` suffix as needed. Targets **Godot 4.7** (see Version
notes). 2D always uses Godot's own 2D engine.
## When to use
- Choosing a body type, setting layers/masks so the right things collide, overlap
detection (triggers, hurtboxes) with `Area`, forces/impulses on a `RigidBody`, or rays
for line-of-sight and ground checks.
**When *not* to use:** `move_and_slide` controllers → `godot-2d-movement`; tile collision
setup → `godot-tilemap`; engine-neutral feel (timestep, mass, jitter, CCD strategy) →
`physics-tuning`.
## Core workflow
1. **For 3D, read which engine runs** before debugging behavior. In `project.godot`,
`[physics]` `3d/physics_engine="Jolt Physics"` means Jolt; no line (`DEFAULT`) means
GodotPhysics3D. New 4.6+ projects write the Jolt line. The API is the same, but joints,
ray face indices, kinematic contacts and margins differ (see Gotchas).
2. **Choose the body type:** `StaticBody` never moves; `AnimatableBody` is moved by code or
animation and pushes others (platforms, doors); `RigidBody` is simulated (move it with
forces, impulses or `linear_velocity`, never `position`); `CharacterBody` is
script-driven; `Area` only detects and can override gravity/damping. Every body needs a
non-empty `CollisionShape`/`CollisionPolygon` child.
3. **Configure layers and masks.** Layers are what a body *is*; masks are what it *scans*.
A detects B only if B's layer bit is in A's mask. Name the bits in `project.godot` so
the `.tscn` values are readable:
```ini
[layer_names]
2d_physics/layer_1="player"
2d_physics/layer_2="walls"
2d_physics/layer_3="enemies"
```
In a `.tscn`, `collision_layer = 1` and `collision_mask = 6` (bits 2 and 3) are plain
integers; bit *n* is `1 << (n - 1)`. In code, `set_collision_mask_value(3, true)` uses
the same 1-based numbers as the editor checkboxes.
4. **Detect overlaps** with `Area` signals (`body_entered`, `area_entered`); `monitoring`
on the detecting Area, `monitorable` on the detected one.
5. **Cast rays** with a `RayCast2D/3D` node (polled each physics frame) or a one-shot
`direct_space_state` query (Pattern 2).
6. **Check before you finish.** Physics runs normally under `--headless`, so prove the
behavior with a test runner instead of describing it (Pattern 3). Run
`godot --headless --path . --script res://tests/test_physics.gd` and read the exit code
and any `SCRIPT ERROR`/`ERROR:` lines. With no Godot binary (`godot`, `godot4` or
`$GODOT_BIN`), ask the user to run it and paste the output. For a visual check, ask the
user to run `godot --path . --debug-collisions` and report what overlaps. If you edited
`.tscn` files by hand, also run the `godot-nodes-scenes` skill's
`scripts/check_godot_project.py <project-dir>`.
## Patterns
### 1. RigidBody: impulse, force, and a safe teleport
```gdscript
extends RigidBody3D
var _teleport_to: Variant = null
func push(direction: Vector3) -> void:
apply_central_impulse(direction * 8.0) # one-off velocity change
func teleport(to: Transform3D) -> void:
_teleport_to = to # applied inside the solver step
func _integrate_forces(state: PhysicsDirectBodyState3D) -> void:
if _teleport_to != null:
state.transform = _teleport_to
state.linear_velocity = Vector3.ZERO
state.angular_velocity = Vector3.ZERO
_teleport_to = null
```
### 2. One-shot ray that skips the caster
```gdscript
func ground_under(from: Vector2) -> Dictionary:
var space := get_world_2d().direct_space_state
var query := PhysicsRayQueryParameters2D.create(from, from + Vector2(0, 64))
query.collision_mask = 0b10 # layer 2 only ("walls")
query.exclude = [get_rid()] # Array[RID], not nodes
return space.intersect_ray(query) # {} on miss, else collider/position/normal
```
Call it from `_physics_process`; space-state data is only valid during the physics step.
### 3. Headless test that an Area sees a body
```gdscript
# res://tests/test_physics.gd
extends SceneTree
func _initialize() -> void:
var level: Node = load("res://levels/test_arena.tscn").instantiate()
root.add_child(level)
for _i in 3:
await physics_frame # overlap lists update once per step
var hurtbox: Area2D = level.get_node("Hurtbox")
var player: Node2D = level.get_node("Player")
var ok := hurtbox.overlaps_body(player)
print("hurtbox sees player: ", ok)
quit(0 if ok else 1)
```
Place the two nodes so they overlap in the test scene. The same shape works for "the crate
lands on the floor" (compare `global_position.y` after N frames) or "the ray hits the
wall". Add counters as in `godot-gdscript-headless-testing` once there is more than one
assertion.
## Gotchas
- **Layer vs mask confusion** is the most common bug. Detection can be one-directional:
A sees B if B's layer is in A's mask, whatever B's mask says.
- **Moving a RigidBody by `position`** fights the solver and causes tunnelling or jitter.
Use impulses, forces, `linear_velocity`, `freeze`, or set `state.transform` in
`_integrate_forces` (Pattern 1).
- **A RigidBody's own `body_entered` never fires** unless `contact_monitor = true` and
`max_contacts_reported > 0`.
- **`Area` doesn't fire** when `monitoring` is off on it, `monitorable` is off on the other
Area, or tExcerpt, first 6,000 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.
Install
Pinned to the audited commit c974b5c
git clone https://github.com/gamedev-skills/awesome-gamedev-agent-skills git -C awesome-gamedev-agent-skills checkout c974b5ce8f0d
The author documents no install command, so this uses the repository directly. Our verdict covers commit c974b5ce8f0d only.
Works in
The author has not said which agents this skill supports, and we have not tested it in any.
Audit history
Every audit, every source change
- ✓SAFE B 89 / 100
first audit · source
c974b5ce8f0d
README badge
For maintainers · shows the latest audit
[](https://modelsatlas.com/skills/gamedev-skills/godot-physics/)
The badge shows our verdict and grade for this skill, and links back to this page. It changes when the audit does.
Similar skills
gamedev-skills/awesome-gamedev-agent-skills
Godot 4.7 Shading Language syntax and pipeline: canvas_item, spatial and particle shaders, built-ins, ShaderMaterial wiring, a headless compile check and 3.x porting. Use for a .gdshader, a SHADER ERROR, shader…
gamedev-skills/awesome-gamedev-agent-skills
Godot 4.7 data-driven design with custom Resources: class_name and @export fields, .tres files, shared references vs duplicate_deep(), uids and threaded loading. Use for items, stats or enemy configs as data, or when…
gamedev-skills/awesome-gamedev-agent-skills
Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpc_id()), set per-node multiplayer authority, and replicate…
gamedev-skills/awesome-gamedev-agent-skills
Structure a Godot 4.7 project with the scene tree and node composition: build reusable scenes, instance PackedScenes at runtime, navigate the tree safely, and register autoload singletons. Use when designing .tscn…
gamedev-skills/awesome-gamedev-agent-skills
Export and build a Godot 4.7 project for distribution: install export templates, define export presets (Windows/macOS/Linux/Web/Android), run headless command-line exports for CI, and handle web (HTML5) COOP/COEP and…
gamedev-skills/awesome-gamedev-agent-skills
Write idiomatic GDScript for Godot 4.7: static typing, the node lifecycle (_ready/_process/_physics_process), @export/@onready/@tool annotations, signals, and await for asynchronous flow. Use when editing .gd scripts in…
Add this badge to your README
[](https://modelsatlas.com/skills/gamedev-skills/godot-physics/)
<a href="https://modelsatlas.com/skills/gamedev-skills/godot-physics/"><img src="https://modelsatlas.com/skills/gamedev-skills/godot-physics/badge.svg" alt="ModelsAtlas: SAFE B"></a>
Questions about godot-physics
What does the godot-physics skill do?
Is godot-physics safe to install?
What can godot-physics access on my machine?
How current is this page?
Sources
- github.com/gamedev-skills/awesome-gamedev-agent-skills/tree/main — the audited source at commit c974b5ce8f0d and every finding aboveObserved · 13 Nov 2026
Spotted something wrong? Report a correction · Methodology
Keep going in your AI
Opens with this page as the source. We add nothing else to the prompt.
- What does the godot-physics skill do?
- Is godot-physics safe to install?
- What can godot-physics access on my machine?