Summer Engine

Measure the gap or overlap on each axis between two placed nodes, or check that one face of many nodes lies on one plane. Finds facade gaps and modules that stand out. Changes nothing. Guide: summer_docs_read {"id":"tool/measure"}

Check whether two world points are connected on the scene's navigation map: readiness, snapped end points, route length and route points. ready false means no evidence, not no route. Guide: summer_docs_read {"id":"tool/navigation-probe"}

Open the project's main scene (from project settings) in the editor, instead of guessing a scene file name. Guide: summer_docs_read {"id":"tool/open-main-scene"}

Open a scene file in the editor and show its tab. A visible tab change for the person, not a target for edits: edits take scenePath. Take paths from summer_get_project_context; never guess them. Guide: summer_docs_read {"id":"tool/open-scene"}

Move one node so its bounds face sits against another node's, lining up the other axes: modules edge to edge, storeys stacked. Saves the scene and verifies the gap. Guide: summer_docs_read {"id":"tool/place-adjacent"}

Play the game in the editor's real window (agents may; quiet: the editor keeps its tab and focus): main scene or a given one, embedded or a hidden offscreen instance, optional seed and fixed frame rate, or local multiplayer (players). Next: summer_is_running, summer_get_diagnostics. Guide: summer_docs_read {"id":"tool/play"}

Set one project.godot setting, such as application/run/main_scene, the window size, the renderer or the default gravity. Guide: summer_docs_read {"id":"tool/project-setting"}

Create a project on this computer. Writes a template (3d-basic by default) to a folder, no shell needed. Returns projectPath. Next: summer_projects_open_local.

Open a project in Summer Engine. Waits until it connects; installs the engine only with install: true (the person's yes). Next: summer_get_project_context.

Cast one ray from any point in a scene: the node it hits, the point and the normal. Physics first, visible bounds as a declared fallback. Changes nothing. Guide: summer_docs_read {"id":"tool/raycast"}

Read a text file of the project (res://), a line or byte window of it, or parts of a .json, with the whole file's sha256. Pass that sha256 to summer_write_file or summer_replace_text to change the file safely. Guide: summer_docs_read {"id":"tool/read-file"}

Read the newest engine events (saves, plays, op results, script errors, imports) at once, and next_seq, the cursor to pass to summer_wait_for_event. Guide: summer_docs_read {"id":"tool/recent-events"}

Remove a node and all its children from the scene at scenePath and save it. The root cannot be removed. One undo step. Remove top-level nodes only when the person asked for it. Guide: summer_docs_read {"id":"tool/remove-node"}

Place copies of one scene along a line in one call: fence posts, clamps, a row of windows (at most 64). Returns the created node paths and saves the scene once. Guide: summer_docs_read {"id":"tool/repeat-along"}

Replace a node with another scene or node type, keeping its parent, index, name, transform and children; the saved file is read back to prove it. Next: summer_get_scene_tree. Guide: summer_docs_read {"id":"tool/replace-node"}

Replace text in an existing project file. The text must match exactly once unless replace_all is set; the write is guarded by the file's sha256. Then check scripts with summer_get_script_errors. Guide: summer_docs_read {"id":"tool/replace-text"}

Run an EditorScript func _run() in a fresh headless editor against the project on disk: batch and project-wide jobs such as re-saving many scenes. It cannot see unsaved edits. For the open scene use summer_run_script. Guide: summer_docs_read {"id":"tool/run-editor-script"}

Run one GDScript func run(ctx) in the live editor on the scene at scenePath: the way to make 3 or more scene edits, loops, grids and procedural meshes. Returns reports, output and errors. Loop: summer_world_snapshot, this, summer_snapshot_diff, summer_screenshot. Guide: summer_docs_read {"id":"tool/run-script"}

Read and drive animation in the RUNNING game: AnimationPlayer clips, AnimationTree states and Skeleton3D bone poses. cmd state only reads. Prove motion with two reads around summer_game_control step. Guide: summer_docs_read {"id":"tool/runtime-animate"}

Call one method on a node in the RUNNING game and return its result, to trigger gameplay code directly. A call is an action, not proof: check what it did with summer_game_probe. Guide: summer_docs_read {"id":"tool/runtime-call"}

Set one property on a node in the RUNNING game (the live object, never the scene file) and read back whether it applied: move the player, set health, flip a flag. Then check with summer_game_probe. Guide: summer_docs_read {"id":"tool/runtime-set"}

Spawn a scene into the RUNNING game (action spawn) or free a live node (action free) to set up a test. The scene file is not touched. Then check with summer_game_probe. Guide: summer_docs_read {"id":"tool/runtime-spawn"}

Save the scene at scenePath, or save it under a new path. Scene edits already save once; use this for a standalone save or a save-as. Guide: summer_docs_read {"id":"tool/save-scene"}

Check a saved 3D scene for visual and placement problems: holes, exposed edges, floor gaps, floating or sunken props, overlaps, z-fighting, light limits. Returns issues by severity, each with the next tool. Changes nothing. Guide: summer_docs_read {"id":"tool/scene-audit"}

Return a frame as an image you see, to check your work by eye: the editor viewport, an offscreen render of a scene (preset, camera, bookmark or free pose, numbered marks) or the running game. A blank viewport frame means no redraw yet: capture again. Guide: summer_docs_read {"id":"tool/screenshot"}

Find any Summer operation by describing the job in plain words: engine, assets, store, pricing, analytics and the rest. Returns the best matches with their exact input schema, effect and approval. Next: summer_call with the name.

Select a node in the editor's scene tree and show it in the inspector, so the person sees it. The scene does not change. Guide: summer_docs_read {"id":"tool/select-node"}

Set one property of a node in the scene at scenePath and save it. Values use Godot syntax: "Vector3(0, 1, 0)", "Color(1, 0, 0, 1)", or a resource class such as "BoxMesh". For 3 or more edits, write one summer_run_script. Guide: summer_docs_read {"id":"tool/set-prop"}

Set a property inside a resource a node holds, such as a collision shape's size or a material's albedo_color, and save the scene. The resource must exist first: assign it with summer_set_prop. Guide: summer_docs_read {"id":"tool/set-resource-property"}

Render several bookmarks or poses into one labelled grid with real lighting, and compare each bookmark with its last render (difference map). The quick look at every hero view after a change. Guide: summer_docs_read {"id":"tool/shot-sheet"}

Move one 3D node along a ray until it sits at the given gap on the first surface (floor, ramp, shelf, table), then save the scene. Returns before and after transforms and the evidence. Guide: summer_docs_read {"id":"tool/snap-to-surface"}

Compare two scene snapshots: added, removed and changed nodes and count changes. The proof that a change did what you meant; an empty diff after a change means it did not land. Next: summer_screenshot. Guide: summer_docs_read {"id":"tool/snapshot-diff"}

Read the clearance around one 3D node in 26 directions: what blocks each side and how far, contact, grounding and nearby objects. Changes nothing. Use it before and after placing. Guide: summer_docs_read {"id":"tool/starcast"}

Stop the running game, or one offscreen instance by name. Scene edits stay as they are; nothing is undone or saved. Guide: summer_docs_read {"id":"tool/stop"}

The Summer store, publishing, board and Grow tools come from the hosted Summer Engine MCP and are not loaded. Call this to see why and how to fix it (usually: run "summer login --store" in a terminal); it loads them when the sign-in works.

Test one 3D node at a candidate world position and rotation without moving it: overlaps, grounded state and the gap to the floor. Changes nothing. Then place it with summer_set_prop or summer_snap_to_surface. Guide: summer_docs_read {"id":"tool/test-placement"}

Use one editor control by its tree path (press, toggle, focus, select a tab, type text, set a value) or dismiss a dialog; the control's state is read back. Only when no named action fits. Guide: summer_docs_read {"id":"tool/ui-activate"}

Return an image of the editor window, or of one dock, dialog or control: the last resort to look at the UI, never to pick click points. For scene views use summer_screenshot. Guide: summer_docs_read {"id":"tool/ui-screenshot"}

Read the live editor UI as a tree (controls, paths, text, state), or every visible dialog and whether one blocks input. Its paths are what summer_ui_activate takes. Guide: summer_docs_read {"id":"tool/ui-tree"}

Wait for an engine event (game started, op applied or failed, script error, scene saved) instead of sleeping; it says so honestly at the timeout. Take a cursor with summer_recent_events first. Guide: summer_docs_read {"id":"tool/wait-for-event"}

Take a structured snapshot of the edited scene: node paths, transforms, world bounds, fingerprints and counts, filtered by subtree, class or field. Returns snapshot_id, the baseline to diff after a change. Next: summer_snapshot_diff. Guide: summer_docs_read {"id":"tool/world-snapshot"}

Create a text file (create_only true) or overwrite one (expected_sha256 from summer_read_file); exactly one guard is required, so a stale write fails. Scripts, scenes, resources, JSON. Then check scripts with summer_get_script_errors. Guide: summer_docs_read {"id":"tool/write-file"}

Render a close-up of part of a frame (a region, or mark N of a marks render) at full resolution: real detail, seams and gaps, not enlarged pixels. Guide: summer_docs_read {"id":"tool/zoom"}