breakpoint-mcp 1.0.0 → 1.1.0

package/dist/tools/editor/node.js

@@ -0,0 +1,171 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Scene-tree node authoring: add / delete / reparent / property / group ops. */
+export function registerNodeTools(server, call) {
+    server.registerTool("node_add", {
+        title: "Add node",
+        description: "Instance a node of the given class under a parent path (undoable). Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.string().describe("Node class to instance, e.g. Sprite2D, AudioStreamPlayer3D"),
+            name: z.string().optional().describe("Node name (defaults to the class name)"),
+        },
+    }, async ({ parent_path, type, name }) => call("node.add", { parent_path, type, name }));
+    server.registerTool("node_delete", {
+        title: "Delete node",
+        description: "Delete a node (undoable). DESTRUCTIVE — gated by confirmation. Refuses to delete the scene root.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, confirm }) => {
+        const blocked = await gate(server, confirm, `Delete node "${path}"`);
+        if (blocked)
+            return blocked;
+        return call("node.delete", { path });
+    });
+    server.registerTool("node_rename", {
+        title: "Rename node",
+        description: "Rename a node (undoable).",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            new_name: z.string().describe("New node name"),
+        },
+    }, async ({ path, new_name }) => call("node.rename", { path, new_name }));
+    server.registerTool("node_reparent", {
+        title: "Reparent node",
+        description: "Move a node under a new parent (undoable).",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            new_parent_path: z.string().describe("New parent path; \".\" for the root"),
+            keep_global_transform: z.boolean().optional().describe("Preserve global transform (default true)"),
+        },
+    }, async ({ path, new_parent_path, keep_global_transform }) => call("node.reparent", { path, new_parent_path, keep_global_transform: keep_global_transform ?? true }));
+    server.registerTool("node_set_property", {
+        title: "Set node property",
+        description: "Set a property on a node (undoable). Rich types use the {\"__type__\":\"Vector3\",\"x\":..} convention. " +
+            "Example value for position: {\"__type__\":\"Vector3\",\"x\":1,\"y\":0,\"z\":2}.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            property: z.string().describe("Property name, e.g. position, modulate, text"),
+            value: z.any().describe("New value (JSON scalar, array, object, or a __type__-tagged Variant)"),
+        },
+    }, async ({ path, property, value }) => call("node.set_property", { path, property, value }));
+    server.registerTool("node_get_property", {
+        title: "Get node property",
+        description: "Read a single property from a node. Rich types come back __type__-tagged.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            property: z.string().describe("Property name"),
+        },
+    }, async ({ path, property }) => call("node.get_property", { path, property }));
+    server.registerTool("node_duplicate", {
+        title: "Duplicate node",
+        description: "Duplicate a node and its children under the same parent (undoable). Returns the new node's path.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            name: z.string().optional().describe("Name for the duplicate (defaults to Godot's auto-numbered name)"),
+        },
+    }, async ({ path, name }) => call("node.duplicate", name !== undefined ? { path, name } : { path }));
+    server.registerTool("node_get_children", {
+        title: "Get node children",
+        description: "List the direct children of a node (name, type, path). Read-only.",
+        inputSchema: { path: z.string().describe("Node path relative to the scene root; \".\" for the root") },
+    }, async ({ path }) => call("node.get_children", { path }));
+    server.registerTool("node_find", {
+        title: "Find nodes",
+        description: "Search a node's descendants by class and/or name substring (case-insensitive). Read-only.",
+        inputSchema: {
+            root_path: z.string().optional().describe("Where to search from; \".\" or omitted for the scene root"),
+            type: z.string().optional().describe("Only match nodes of this class (is_class), e.g. Sprite2D"),
+            name_contains: z.string().optional().describe("Only match nodes whose name contains this substring"),
+            limit: z.number().int().positive().optional().describe("Max matches to return (default 200)"),
+        },
+    }, async ({ root_path, type, name_contains, limit }) => call("node.find", {
+        root_path: root_path ?? ".",
+        type: type ?? "",
+        name_contains: name_contains ?? "",
+        limit: limit ?? 200,
+    }));
+    server.registerTool("node_list_groups", {
+        title: "List node groups",
+        description: "List the groups a node belongs to. Read-only.",
+        inputSchema: { path: z.string().describe("Node path relative to the scene root") },
+    }, async ({ path }) => call("node.list_groups", { path }));
+    server.registerTool("node_add_to_group", {
+        title: "Add node to group",
+        description: "Add a node to a group (persistent, undoable). No-op if already a member.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            group: z.string().describe("Group name"),
+        },
+    }, async ({ path, group }) => call("node.add_to_group", { path, group }));
+    server.registerTool("node_remove_from_group", {
+        title: "Remove node from group",
+        description: "Remove a node from a group (undoable). No-op if not a member.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            group: z.string().describe("Group name"),
+        },
+    }, async ({ path, group }) => call("node.remove_from_group", { path, group }));
+    server.registerTool("node_instantiate_scene", {
+        title: "Instance scene under node",
+        description: "Instance an external PackedScene (res:// path) as an editable child of a parent node (undoable). Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            scene_path: z.string().describe("Scene to instance, e.g. res://actors/enemy.tscn"),
+            name: z.string().optional().describe("Node name (defaults to the instanced scene's root name)"),
+        },
+    }, async ({ parent_path, scene_path, name }) => call("node.instantiate_scene", name !== undefined ? { parent_path, scene_path, name } : { parent_path, scene_path }));
+    server.registerTool("node_move_child", {
+        title: "Move child",
+        description: "Reorder a node among its siblings by index (undoable). Negative indices count from the end (-1 = last).",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            to_index: z.number().int().describe("New sibling index (0-based; negative counts from the end)"),
+        },
+    }, async ({ path, to_index }) => call("node.move_child", { path, to_index }));
+    server.registerTool("node_change_type", {
+        title: "Change node type",
+        description: "Replace a node with a new node of a different class, carrying over compatible properties, children, and groups (undoable). Refuses the scene root.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            type: z.string().describe("New node class, e.g. Sprite2D, StaticBody3D"),
+        },
+    }, async ({ path, type }) => call("node.change_type", { path, type }));
+    server.registerTool("node_set_owner", {
+        title: "Set node owner",
+        description: "Set a node's owner (undoable). Owner must be an ancestor; \".\" or omitted sets the scene root. Ownership determines which scene a node is saved into.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            owner_path: z.string().optional().describe("Ancestor to own the node; \".\" or omitted for the scene root"),
+        },
+    }, async ({ path, owner_path }) => call("node.set_owner", owner_path !== undefined ? { path, owner_path } : { path }));
+    server.registerTool("node_call_method", {
+        title: "Call node method (edit-time)",
+        description: "Invoke a method on a node in the EDITED scene. DESTRUCTIVE (arbitrary invocation, not undoable) — gated by confirmation. " +
+            "Args use the tagged-Variant convention; the return value comes back tagged.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            method: z.string().describe("Method name"),
+            args: z.array(z.any()).optional().describe("Positional arguments (JSON scalars or __type__-tagged Variants)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, method, args, confirm }) => {
+        const blocked = await gate(server, confirm, `Call ${path}.${method}() in the edited scene`);
+        if (blocked)
+            return blocked;
+        return call("node.call_method", { path, method, args: args ?? [] });
+    });
+    server.registerTool("node_get_path", {
+        title: "Get node path",
+        description: "Return a node's scene-relative path, class, sibling index, parent path, and child count. Read-only.",
+        inputSchema: { path: z.string().describe("Node path relative to the scene root; \".\" for the root") },
+    }, async ({ path }) => call("node.get_path", { path }));
+    server.registerTool("node_list_properties", {
+        title: "List node properties",
+        description: "List a node's inspector-visible properties (name, Variant type, class_name, usage flags). Read-only. Use node_get_property to read a value.",
+        inputSchema: { path: z.string().describe("Node path relative to the scene root") },
+    }, async ({ path }) => call("node.list_properties", { path }));
+}
+//# sourceMappingURL=node.js.map

package/dist/tools/editor/particles.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+/** GPUParticles authoring (process material, amount, lifetime, texture). */
+export function registerParticleTools(server, call) {
+    server.registerTool("particles_create", {
+        title: "Create particles",
+        description: "Add a GPUParticles2D/3D node under a parent in the edited scene (undoable). Optional initial amount (> 0), lifetime (> 0), emitting. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default, GPUParticles2D) or \"3d\" (GPUParticles3D)"),
+            name: z.string().optional().describe("Node name (default \"GPUParticles2D\"/\"GPUParticles3D\")"),
+            amount: z.number().optional().describe("Number of particles (> 0, default 8)"),
+            lifetime: z.number().optional().describe("Particle lifetime in seconds (> 0, default 1)"),
+            emitting: z.boolean().optional().describe("Whether the system is emitting (default true)"),
+        },
+    }, async ({ parent_path, dim, name, amount, lifetime, emitting }) => {
+        const params = { parent_path };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (amount !== undefined)
+            params.amount = amount;
+        if (lifetime !== undefined)
+            params.lifetime = lifetime;
+        if (emitting !== undefined)
+            params.emitting = emitting;
+        return call("particles.create", params);
+    });
+    server.registerTool("particles_set_process_material", {
+        title: "Set particles process material",
+        description: "Create a ParticleProcessMaterial and assign it as process_material on a GPUParticles2D/3D in the edited scene (undoable). Optional knobs: gravity [x, y, z], direction [x, y, z], spread, initial_velocity_min/max, scale_min/max, color [r, g, b, a]. GPU particles need a process material to emit. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            gravity: z.array(z.number()).optional().describe("Gravity vector [x, y, z]"),
+            direction: z.array(z.number()).optional().describe("Emission direction [x, y, z]"),
+            spread: z.number().optional().describe("Emission spread in degrees"),
+            initial_velocity_min: z.number().optional().describe("Minimum initial velocity"),
+            initial_velocity_max: z.number().optional().describe("Maximum initial velocity"),
+            scale_min: z.number().optional().describe("Minimum particle scale"),
+            scale_max: z.number().optional().describe("Maximum particle scale"),
+            color: z.array(z.number()).optional().describe("Base color [r, g, b] or [r, g, b, a] (0..1)"),
+        },
+    }, async ({ path, gravity, direction, spread, initial_velocity_min, initial_velocity_max, scale_min, scale_max, color }) => {
+        const params = { path };
+        if (gravity !== undefined)
+            params.gravity = gravity;
+        if (direction !== undefined)
+            params.direction = direction;
+        if (spread !== undefined)
+            params.spread = spread;
+        if (initial_velocity_min !== undefined)
+            params.initial_velocity_min = initial_velocity_min;
+        if (initial_velocity_max !== undefined)
+            params.initial_velocity_max = initial_velocity_max;
+        if (scale_min !== undefined)
+            params.scale_min = scale_min;
+        if (scale_max !== undefined)
+            params.scale_max = scale_max;
+        if (color !== undefined)
+            params.color = color;
+        return call("particles.set_process_material", params);
+    });
+    server.registerTool("particles_set_amount", {
+        title: "Set particles amount",
+        description: "Set the number of particles (amount, > 0) on a GPUParticles2D/3D in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            amount: z.number().describe("Number of particles (> 0)"),
+        },
+    }, async ({ path, amount }) => call("particles.set_amount", { path, amount }));
+    server.registerTool("particles_set_lifetime", {
+        title: "Set particles lifetime",
+        description: "Set the particle lifetime in seconds (> 0) on a GPUParticles2D/3D in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            lifetime: z.number().describe("Lifetime in seconds (> 0)"),
+        },
+    }, async ({ path, lifetime }) => call("particles.set_lifetime", { path, lifetime }));
+    server.registerTool("particles_set_emitting", {
+        title: "Set particles emitting",
+        description: "Toggle whether a GPUParticles2D/3D is emitting in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            emitting: z.boolean().describe("Whether the system is emitting"),
+        },
+    }, async ({ path, emitting }) => call("particles.set_emitting", { path, emitting }));
+    server.registerTool("particles_set_texture", {
+        title: "Set particles texture",
+        description: "Load a Texture2D from a res:// path and assign it as texture on a GPUParticles2D in the edited scene (undoable). GPUParticles2D only — GPUParticles3D draws meshes and has no texture (returns unsupported). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D node path relative to the scene root"),
+            texture_path: z.string().describe("res:// path to a Texture2D resource"),
+        },
+    }, async ({ path, texture_path }) => call("particles.set_texture", { path, texture_path }));
+}
+//# sourceMappingURL=particles.js.map

package/dist/tools/editor/physics.js

@@ -0,0 +1,236 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Physics & collision: bodies, shapes, areas, joints, rigidbody tuning, gravity. */
+export function registerPhysicsTools(server, call) {
+    server.registerTool("body_create", {
+        title: "Create physics body",
+        description: "Add a physics body node under a parent in the edited scene (undoable): a StaticBody, RigidBody, CharacterBody, or Area, in 2D or 3D. In-scene and undoable — not gated. Attach collision shapes with collisionshape_add.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.enum(["static", "rigid", "character", "area"]).describe("Body kind: static | rigid | character | area"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default the class name, e.g. \"StaticBody2D\")"),
+        },
+    }, async ({ parent_path, type, dim, name }) => {
+        const params = { parent_path, type };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        return call("body.create", params);
+    });
+    server.registerTool("collisionshape_add", {
+        title: "Add collision shape",
+        description: "Add a CollisionShape2D/3D node carrying a shape resource under a parent (usually a body) in the edited scene (undoable). shape is rect | circle | capsule | polygon; dim selects 2D (Rectangle/Circle/Capsule/ConvexPolygon 2D) or 3D (Box/Sphere/Capsule/ConvexPolygon 3D). In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path (usually a body) relative to the scene root; \".\" for the root"),
+            shape: z.enum(["rect", "circle", "capsule", "polygon"]).describe("Shape kind: rect | circle | capsule | polygon"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default \"CollisionShape2D\"/\"CollisionShape3D\")"),
+            size: z.array(z.number()).optional().describe("rect: [w, h] (2D) or [w, h, d] (3D)"),
+            radius: z.number().optional().describe("circle/capsule radius"),
+            height: z.number().optional().describe("capsule height"),
+            points: z.array(z.array(z.number())).optional().describe("polygon: convex-hull points, [[x, y], …] (2D, ≥3) or [[x, y, z], …] (3D, ≥4)"),
+        },
+    }, async ({ parent_path, shape, dim, name, size, radius, height, points }) => {
+        const params = { parent_path, shape };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (size !== undefined)
+            params.size = size;
+        if (radius !== undefined)
+            params.radius = radius;
+        if (height !== undefined)
+            params.height = height;
+        if (points !== undefined)
+            params.points = points;
+        return call("collisionshape.add", params);
+    });
+    server.registerTool("body_set_collision_layer", {
+        title: "Set collision layer",
+        description: "Set the collision_layer bitmask on a physics body or area (CollisionObject2D/3D) in the edited scene (undoable). layer is the integer bitmask of layers this object occupies.",
+        inputSchema: {
+            path: z.string().describe("Body/Area node path relative to the scene root"),
+            layer: z.number().int().describe("collision_layer bitmask (non-negative integer)"),
+        },
+    }, async ({ path, layer }) => call("body.set_collision_layer", { path, layer }));
+    server.registerTool("body_set_collision_mask", {
+        title: "Set collision mask",
+        description: "Set the collision_mask bitmask on a physics body or area (CollisionObject2D/3D) in the edited scene (undoable). mask is the integer bitmask of layers this object scans for collisions.",
+        inputSchema: {
+            path: z.string().describe("Body/Area node path relative to the scene root"),
+            mask: z.number().int().describe("collision_mask bitmask (non-negative integer)"),
+        },
+    }, async ({ path, mask }) => call("body.set_collision_mask", { path, mask }));
+    server.registerTool("area_set_monitoring", {
+        title: "Set area monitoring",
+        description: "Set monitoring and/or monitorable on an Area2D/3D in the edited scene (undoable). monitoring = the area detects overlapping bodies/areas; monitorable = other areas can detect it. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Area2D/3D node path relative to the scene root"),
+            monitoring: z.boolean().optional().describe("Whether the area detects overlapping bodies/areas"),
+            monitorable: z.boolean().optional().describe("Whether other areas can detect this area"),
+        },
+    }, async ({ path, monitoring, monitorable }) => {
+        const params = { path };
+        if (monitoring !== undefined)
+            params.monitoring = monitoring;
+        if (monitorable !== undefined)
+            params.monitorable = monitorable;
+        return call("area.set_monitoring", params);
+    });
+    server.registerTool("area_set_gravity", {
+        title: "Set area gravity",
+        description: "Set the local gravity override of an Area2D/3D in the edited scene (undoable): space_override mode, gravity magnitude, direction, and whether gravity points toward a center (point). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Area2D/3D node path relative to the scene root"),
+            space_override: z.enum(["disabled", "combine", "combine_replace", "replace", "replace_combine"]).optional().describe("How this area's gravity combines with the global/other areas"),
+            gravity: z.number().optional().describe("Gravity magnitude (units/s^2)"),
+            direction: z.array(z.number()).optional().describe("Gravity direction [x, y] (2D) or [x, y, z] (3D)"),
+            point: z.boolean().optional().describe("If true, gravity pulls toward the area's gravity point instead of a direction"),
+        },
+    }, async ({ path, space_override, gravity, direction, point }) => {
+        const params = { path };
+        if (space_override !== undefined)
+            params.space_override = space_override;
+        if (gravity !== undefined)
+            params.gravity = gravity;
+        if (direction !== undefined)
+            params.direction = direction;
+        if (point !== undefined)
+            params.point = point;
+        return call("area.set_gravity", params);
+    });
+    server.registerTool("joint_create", {
+        title: "Create physics joint",
+        description: "Add a physics joint node under a parent in the edited scene (undoable). 2D types: pin | groove | spring (PinJoint2D/GrooveJoint2D/DampedSpringJoint2D); 3D types: pin | hinge | slider | cone_twist | generic6dof (PinJoint3D/HingeJoint3D/SliderJoint3D/ConeTwistJoint3D/Generic6DOFJoint3D). Optionally wire node_a/node_b to the two bodies. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.enum(["pin", "groove", "spring", "hinge", "slider", "cone_twist", "generic6dof"]).describe("Joint kind; pin works in both dims, the rest are dim-specific"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default the class name, e.g. \"PinJoint2D\")"),
+            node_a: z.string().optional().describe("NodePath (relative to the joint) of the first body"),
+            node_b: z.string().optional().describe("NodePath (relative to the joint) of the second body"),
+        },
+    }, async ({ parent_path, type, dim, name, node_a, node_b }) => {
+        const params = { parent_path, type };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (node_a !== undefined)
+            params.node_a = node_a;
+        if (node_b !== undefined)
+            params.node_b = node_b;
+        return call("joint.create", params);
+    });
+    server.registerTool("joint_set_bodies", {
+        title: "Set joint bodies",
+        description: "Set node_a and/or node_b on an existing Joint2D/3D in the edited scene (undoable) — the NodePaths of the two bodies the joint connects, relative to the joint node. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Joint2D/3D node path relative to the scene root"),
+            node_a: z.string().optional().describe("NodePath (relative to the joint) of the first body"),
+            node_b: z.string().optional().describe("NodePath (relative to the joint) of the second body"),
+        },
+    }, async ({ path, node_a, node_b }) => {
+        const params = { path };
+        if (node_a !== undefined)
+            params.node_a = node_a;
+        if (node_b !== undefined)
+            params.node_b = node_b;
+        return call("joint.set_bodies", params);
+    });
+    server.registerTool("collisionpolygon_add", {
+        title: "Add collision polygon",
+        description: "Add a CollisionPolygon2D/3D node carrying a polygon under a parent (usually a body) in the edited scene (undoable). points is a 2D outline [[x, y], …] (≥3); for 3D it is extruded along Z by depth. 2D build_mode is solids | segments. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path (usually a body) relative to the scene root; \".\" for the root"),
+            points: z.array(z.array(z.number())).describe("Polygon outline points [[x, y], …] (≥3); a 2D outline even for 3D"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default \"CollisionPolygon2D\"/\"CollisionPolygon3D\")"),
+            build_mode: z.enum(["solids", "segments"]).optional().describe("2D only: solids (default) or segments"),
+            depth: z.number().optional().describe("3D only: extrusion depth along Z (default 1.0)"),
+        },
+    }, async ({ parent_path, points, dim, name, build_mode, depth }) => {
+        const params = { parent_path, points };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (build_mode !== undefined)
+            params.build_mode = build_mode;
+        if (depth !== undefined)
+            params.depth = depth;
+        return call("collisionpolygon.add", params);
+    });
+    server.registerTool("rigidbody_set_properties", {
+        title: "Set rigidbody properties",
+        description: "Tune a RigidBody2D/3D in the edited scene (undoable): mass (> 0), gravity_scale, linear_damp, angular_damp. Only the provided properties change. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("RigidBody2D/3D node path relative to the scene root"),
+            mass: z.number().optional().describe("Body mass (> 0)"),
+            gravity_scale: z.number().optional().describe("Multiplier on gravity (1 = normal, 0 = float)"),
+            linear_damp: z.number().optional().describe("Linear damping (≥ 0)"),
+            angular_damp: z.number().optional().describe("Angular damping (≥ 0)"),
+        },
+    }, async ({ path, mass, gravity_scale, linear_damp, angular_damp }) => {
+        const params = { path };
+        if (mass !== undefined)
+            params.mass = mass;
+        if (gravity_scale !== undefined)
+            params.gravity_scale = gravity_scale;
+        if (linear_damp !== undefined)
+            params.linear_damp = linear_damp;
+        if (angular_damp !== undefined)
+            params.angular_damp = angular_damp;
+        return call("rigidbody.set_properties", params);
+    });
+    server.registerTool("body_set_physics_material", {
+        title: "Set body physics material",
+        description: "Create a PhysicsMaterial and assign it as physics_material_override on a StaticBody/RigidBody (2D or 3D) in the edited scene (undoable): friction (default 1), bounce (default 0), rough, absorbent. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("StaticBody/RigidBody 2D/3D node path relative to the scene root"),
+            friction: z.number().optional().describe("Surface friction 0..1 (default 1)"),
+            bounce: z.number().optional().describe("Restitution/bounciness 0..1 (default 0)"),
+            rough: z.boolean().optional().describe("Rough friction combine mode (default false)"),
+            absorbent: z.boolean().optional().describe("Absorbent bounce combine mode (default false)"),
+        },
+    }, async ({ path, friction, bounce, rough, absorbent }) => {
+        const params = { path };
+        if (friction !== undefined)
+            params.friction = friction;
+        if (bounce !== undefined)
+            params.bounce = bounce;
+        if (rough !== undefined)
+            params.rough = rough;
+        if (absorbent !== undefined)
+            params.absorbent = absorbent;
+        return call("body.set_physics_material", params);
+    });
+    server.registerTool("physics_set_gravity", {
+        title: "Set project gravity",
+        description: "Write the project's default gravity for 2D or 3D (ProjectSettings physics/{2d,3d}/default_gravity + default_gravity_vector). Set save=true to persist to project.godot. DESTRUCTIVE (project-wide setting) — gated by confirmation.",
+        inputSchema: {
+            dim: z.enum(["2d", "3d"]).optional().describe("Which gravity to set: \"2d\" (default) or \"3d\""),
+            magnitude: z.number().optional().describe("Gravity magnitude (default 2D 980, 3D 9.8)"),
+            direction: z.array(z.number()).optional().describe("Gravity direction vector [x, y] (2D) or [x, y, z] (3D)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ dim, magnitude, direction, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Set project ${dim ?? "2d"} gravity${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = {};
+        if (dim !== undefined)
+            params.dim = dim;
+        if (magnitude !== undefined)
+            params.magnitude = magnitude;
+        if (direction !== undefined)
+            params.direction = direction;
+        params.save = save ?? false;
+        return call("physics.set_gravity", params);
+    });
+}
+//# sourceMappingURL=physics.js.map