L4D2-HSMCP
Uses the Steam installations of Left 4 Dead 2 and the L4D2 Authoring Tools to locate game content, compilers, and SDK tools, and can launch the game client for nav mesh generation.
Integrates with Valve's Left 4 Dead 2 / Source authoring pipeline: reading and editing BSP/VMF map files, linting against the game's FGD, running vbsp/vvis/vrad compiles, packing VPKs, and generating nav data.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@L4D2-HSMCP Lint my c1m1 map against left4dead2.fgd, then compile it with Tools++"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
L4D2-HSMCP
An agent toolkit for building Left 4 Dead 2 content. Maps, campaigns, VScripts, models and addons — made through an MCP server and a skill, not by hand-editing files.
Early development. The project has only just entered development. The map and campaign pipeline is the first piece being built; VScript, model and wider addon support will follow, and the toolkit will keep growing. Interfaces and tool names can change between
0.0.xreleases. Windows only, Left 4 Dead 2 only.
What it is
L4D2-HSMCP gives an AI agent the tools a Left 4 Dead 2 mapper uses, in a form it can
call and verify:
Read
.bspand.vmffiles by offset — a gigabyte map without loading it.Build and edit geometry, entities and I/O, splicing the original text so untouched bytes stay untouched.
Lint against the game's own
left4dead2.fgd, before spending a compile.Compile with the stock L4D2 chain or standalone Tools++, naming the chain that ran.
Write and check campaigns: mission files, chapters, maps and images.
Generate nav with the engine, and pack the result into an addon VPK.
Measure a map against its own brief and against the format's ceilings.
It never talks to a running game. It reads and writes files, runs the game's compilers and packers, and lets the game generate its own nav mesh.
Related MCP server: maya-mcp
How it works
Agent + skill
│ MCP (stdio)
▼
L4D2-HSMCP ── TypeScript tools
├── KeyValues with offsets .vmf, gameinfo, mission files
├── BSP readers (L4D2 field order) header, entities, geometry
├── VMF splice / geometry / render edits and offline checks
├── space, rooms, traces, plans answers without a compile
├── compilers vbsp, vvis, vrad (stock / Tools++)
├── Python sidecar (srctools) FGD, VPK, content, dependencies
└── vpk.exe + the game itself packing, nav_generateThe design rules come from the project this fork grew out of, and they still hold:
A
.bspis never read whole. Real maps run to gigabytes; readers go by offset.A
.vmfis changed by splicing byte ranges. Comments and formatting survive.A writer is checked by a reader going the other way. Volume → planes when writing, planes → volume when checking, so a sign error cannot hide in both.
No number without a source. Limits and measurements carry a file and a date.
No tool without an oracle. If the answer cannot be checked independently, it does not ship.
Requirements
Required
Component | Why it is needed |
Windows 10/11 x64 | the game's compilers, |
Left 4 Dead 2 (Steam app | the client install carries |
Left 4 Dead 2 Authoring Tools (Steam app | Valve's SDK for L4D2: Hammer, HLMV, Faceposer, the Workshop manager, the VScript plugins and the example content. Install from Steam → Library → filter Tools. About 0.9 GB |
Node.js 20+ | the MCP server itself (tested on Node 24) |
pnpm 10+ | install and build |
Python 3.10+ | the |
An MCP-capable agent | the thing that drives the tools. OpenCode, Claude Code or any MCP client with tool use; see below |
Git | clone and update |
~20 GB free disk | the game (~14 GB), Authoring Tools, compilers and |
Recommended
Component | Why |
the editor the toolkit is built around: a stable Hammer with faster compiles and extra flags. Install the L4D2 build into the game's | |
| |
VTFEdit++ / VTFCmd | textures, cubemaps and skyboxes for custom content |
| optional standalone tools from ficool2's tools page; |
Steam running and logged in |
|
A dedicated server + SourceMod | not needed for authoring; planned for automated in-game verification |
Agent requirements
The toolkit is an MCP server plus the workflow around it, so the agent side has its own requirements:
An MCP client over stdio with tool use. OpenCode and Claude Code are the two this project is developed against; any client that can call MCP tools and show permission prompts should work.
The skill.
skill/l4d2-hsmcp/is the workflow an agent follows: it routes the task to a reference, a procedure or a troubleshooting page instead of loading everything at once. The repository'sopencode.jsonpoints at it, so it is available in this project without copying.Permission to run the local tools. Compilers,
vpk.exeand the game arelocaltools. They needconfirm: true, or an entry intoolAllowlistfor an unattended run.Permission to launch the game once per map for nav generation. That is the only GUI step in the pipeline; everything before and after it is file work.
Quick start
git clone https://github.com/NexPG/L4D2-HSMCP
cd L4D2-HSMCP
pnpm install
pnpm build
powershell -ExecutionPolicy Bypass -File sidecar/setup.ps1
node dist/index.js installThen ask the server for its state:
healthhealth reports the game profile it resolved, the compilers and FGD it found, the sidecar,
the tool count, and whether the build is older than the source. When something is missing it
says what and what that costs - it does not throw.
Building a campaign
The pipeline the tools are built around:
write_vmf / write_vmf_solid source geometry
read_vmf_leak sealed, in seconds, without a compiler
read_vmf_lint against the game's FGD
run_compile vbsp / vvis / vrad
write_campaign the mission file
check_campaign maps, images, chapter numbering
nav_generate the engine generates the .nav
run_vpk_pack an addon VPKA complete worked example lives in the development notes, outside this repository. The
practical rules are in docs/campaigns.md.
Tools
80 tools, grouped by what they answer:
Inspect —
health,read_source_games,read_bsp_info,read_bsp_entities,read_nav_dump,read_map_geometry,read_map_report,read_vmf,read_vmf_lint.Measure — extents, sightlines, lightmap budgets, visleaf stats, props, pakfile.
Ask offline —
read_vmf_leak,read_vmf_rooms,measure_vmf_clearance,read_vmf_visibility,read_vmf_trace,render_vmf_view,render_vmf_plan.Build and edit — solids, fittings, clips, hollows, vertices, faces, lights, hints, portals, visgroups, displacements.
Compile and ship —
run_compile,read_compile_log,read_leak,read_map_dependencies,run_pack,run_vpk_pack,run_nav_generate,run_map_test.Campaigns —
read_campaign,write_campaign,check_campaign.Scripts —
write_vscript: write a.nut, check it for Lua habits, attach it with alogic_script.
Every tool states its realm (map for files, local for a host binary) and whether it is
guarded. Writing and executing tools need confirm: true, or an entry in toolAllowlist.
Repository layout
src/tools/ MCP tool definitions
src/campaign/ mission files: parse, write, check
src/vmf/ VMF reading, splicing, geometry, fittings
src/bsp/ BSP readers, limits, nav, VTF headers
src/space/ offline traces, rooms, measurement
src/render/ offline views and plans
src/compile/ compilers, logs, leaks, external tools
sidecar/ Python/srctools helper
skill/ the agent skill: SKILL.md, references, workflows, troubleshooting
test/ the oracle-heavy suite
docs/ campaign guide and inherited measurementsDocumentation
CHANGELOG.md— what each version changed.CONTRIBUTING.md— the three rules this project works by.skill/l4d2-hsmcp/SKILL.md— the agent workflow, with campaign, nav, VScript and troubleshooting references.docs/campaigns.md— mission files, VPK layout, nav, deployment.docs/architecture.md— the inherited design notes on splicing, offset reads and shared plumbing.docs/measuring.md,docs/spatial.md,docs/compiling.md— dated measurements from the project's history.
Status
The project has only just entered development. The map and campaign pipeline is the first
piece being built; VScript, model and wider addon tooling, automated in-game verification
and the agent skill itself are still ahead, so the feature set will keep expanding.
Interfaces and tool names may change between 0.0.x releases.
Every tool is covered by tests. The suite runs on Windows against a real Left 4 Dead 2 install, and the checks that need game content skip themselves when the game is absent.
License
GPL-3.0-only. Copyright (C) 2026 NexPG.
This project is a fork of hammer-mcp, made by the
original developers at Project Society Studio and released under the MIT licence. The
original MIT notice is kept verbatim in LICENSE-MIT, and NOTICE
records the provenance, the modification date and what the GPL asks of anyone redistributing
this work.
Not affiliated with Valve Corporation. Left 4 Dead 2 and its content belong to Valve.
Available Tools
80 toolsalign_facesA
Realigns the texture on selected faces: to the world axes, to the face's own plane, or stretched to fit the face. Hammer's three alignment modes. 'world' derives the axes from the face's dominant normal using vbsp's own base-axis table, which is what a face gets at creation; 'face' projects them into the face's plane so the texture runs along a slope instead of being squashed onto it; 'fit' spans the face exactly. The offsets are always recomputed from a corner of the face rather than carried over -- an axis pair with a stale offset puts the texture somewhere else entirely, which is the most common way an alignment tool produces a map that compiles and looks wrong.
Inputs: mode (required), path (required), all, scale, +10 more. Returns: path, changed, matched, written, +4 more
check_campaignA
Checks a campaign against the files it references: every chapter's .bsp exists in a maps directory or in a VPK, every chapter image exists under materials/vgui, chapter numbering has no gaps, and every mode has chapters. Reports findings and an overall verdict; it does not refuse. The game's own campaigns can be checked in place by passing vpk: left4dead2/pak01_dir.vpk and the mission entry.
Inputs: vpk, path, vpks, entry, +2 more. Returns: modes, counts, source, checked, +3 more
check_vmf_rulesA
Checks a .vmf against ITS OWN rules file -- <map>.rules.json, a sibling of the .vmf. 'Four metres of pavement, no entrance obstructed, the view from the lobby preserved' is a design brief, and this is the form of it a machine can check. Per map and never global: a residential street and a warehouse have different right answers for every number, and a shared default would be wrong for both while looking authoritative. No rules file means NO checking, not checking against something reasonable. It REPORTS: the writing tools do not consult it and must not, because a mapper may want a narrow alley. Every violation carries the worst point, so render_vmf_view or render_vmf_plan can be pointed straight at it. Read overall, not errorCount: a run in which some rule matched nothing comes back 'skipped', never 'pass'.
Inputs: path (required), step, limit, seeds, +5 more. Returns: path, notes, overall, reported, +8 more
clip_solidsA
Cuts brushes with a plane, keeping the front, the back, or both. This is Hammer's clip tool, the most-used one in the editor and the one that unlocks every shape that is not an assembly of boxes. A face that survives keeps its own material, texture axes, lightmap scale and smoothing groups -- the side block is copied, not rebuilt. A face that no longer bounds anything is dropped rather than left redundant. The new face gets its axes from vbsp's base-axis table and inherits the material of the largest face kept, which is what Hammer does. Keeping both halves is the check: their volumes must sum to the original, and the tool refuses to write if they do not.
Inputs: keep (required), path (required), plane (required), owner, +7 more. Returns: path, solids, matched, written, +6 more
delete_solidsA
Removes brushes from a .vmf. The counterpart of write_vmf_solid, and its absence is what made every mistake permanent: a brush created in the wrong place could not be taken back. Selects by id, owner, material or bounding box, refuses an empty selector rather than emptying the map, and refuses brushes inside a hidden block, whose removal would be as invisible as they are. Warns when the world is left with nothing to seal with, and when a brush entity is left with no brushes at all. It cannot prove the map still seals -- only a compile can.
Inputs: path (required), owner, backup, dryRun, +4 more. Returns: path, deleted, matched, written, +7 more
edit_vmfA
Edits a .vmf in place by splicing byte ranges of the original file: everything not touched stays byte-identical, so a one-entity change is a one-entity diff. Adds, updates and removes entities, and adds or removes their outputs. Never reserialises the file: comments, blank lines and hand-written indentation would be lost silently. Does not create brush geometry -- that is write_vmf_solid, which has the checks that job needs. Run read_vmf_lint after editing.
Inputs: ops (required), path (required), backup, dryRun, +1 more. Returns: note, path, dryRun, written, +8 more
group_solidsA
Puts brushes in one Hammer group, or takes them out of theirs. A group has no name: Hammer treats its members as one thing when you click any of them, and that is all it is. A solid carries exactly one group id, so grouping a brush that is already grouped moves it rather than adding a second id, which Hammer would read as whichever came first. read_map_organisation reads it back -- groups, and solidsInNoGroup. (The Python sidecar cannot: its writer emits 'groupid' and its parser looks for 'group', so anything going through it reports no group membership on any map. That is a caveat about the sidecar's own map reading, not about verifying this.)
Inputs: path (required), owner, backup, dryRun, +5 more. Returns: path, groupId, written, nextStep, +4 more
healthA
State of the Left 4 Dead 2 toolchain this server depends on: repo root, the game's bin directory (which ships with the client, not with srcds), which compilers and .fgd files are present, whether the Python sidecar (srctools) is installed. Also how many tools this server is serving and whether its build is older than the source -- a stale build silently offers fewer tools. Start here when a tool reports something missing, or is missing itself.
Inputs: no named parameters.
hollow_solidsA
Turns solid blocks into the walls of a room. Hammer has this and Hammer's version overlaps at the corners: each wall spans its whole face, so two adjacent walls both occupy the corner between them. This one mitres, because 'this point is nearer face i than face j' turns out to be a plane, so each wall stays a single convex brush and no two share a cubic unit. The check is exact: the walls must sum to the outer volume less the room inside, and the tool refuses to write if they do not. Each wall keeps the material the source brush had on that face; the inner surface and the mitres take innerMaterial, which defaults to nodraw so a hollowed block does not become a room with brick on the outside of its own walls.
Inputs: path (required), thickness (required), owner, backup, +8 more. Returns: path, matched, written, hollowed, +6 more
measure_vmf_approachA
How much clear room a person has in front of the entities of a .vmf -- doors, buttons, vending machines, anything with an origin and a yaw. The classic fault it finds is a door that opens into a wall, or a button behind a crate, neither of which any compiler mentions. It does NOT say whether a door can swing: a leaf's width lives in a model this server cannot open offline, and the hull it assumed is reported rather than quietly folded into the answer.
Inputs: path (required), hull, limit, classname, +2 more. Returns: path, notes, matched, entities, +2 more
measure_vmf_clearanceA
How much room there actually is at a point in a .vmf: the free width across, the headroom, and what stops each measurement. Measured with a swept player hull rather than a ray, because that is the question -- a line passes a 24-unit gap that nobody fits through, and reports it as clear. The narrowest direction is found rather than assumed, since a corridor is wide one way and long the other, and a diagonal alley is narrow diagonally. Every number names the brush that bounded it.
Inputs: at (required), path (required), axis, hull, +1 more. Returns: at, hull, path, notes, +12 more
move_verticesA
Moves named corners of one brush: Hammer's vertex manipulation tool. The last thing between an assembly of cut boxes and an arbitrary convex shape -- it is what pulls a wall out to meet a street that does not run square. Corners are named by position, as read_vmf_solids reports them. It refuses far more than it accepts, and that is parity with the editor rather than a shortfall: moving one corner moves it on every face that shares it, three of them on a box, so a diagonal pull leaves each of those faces with a point off its own plane. Hammer shows that as a red invalid solid and will not build it either. Moves that work are the ones keeping every face flat: a whole edge, or a whole face. Texture axes are left alone, as Hammer leaves them.
Inputs: path (required), moves (required), solidId (required), backup, +3 more. Returns: path, moved, solidId, written, +9 more
paint_displacementB
Paints the blend channel of displacements: uniform, by height, or by slope. A blend material draws its second texture where alpha is 255 and its first where it is zero, which is how a gravel path appears through grass. By height fades between two elevations rather than stepping, because a shoreline that changes in one vertex is not what anyone wants. Says so when the material has no blend in its name: alpha does nothing on a material that is not a blend shader, and vbsp does not mention it.
Inputs: path (required), rule (required), backup, dryRun, +2 more. Returns: path, written, maxAlpha, minAlpha, +5 more
read_brush_volumesA
Footprint and volume of every brush entity in a compiled map, grouped by classname. Each func_* entity owns a brush model (*N in lump 14) whose bounding box this reads. Use it to size the built environment -- shop fronts, rooms behind a func_door, areaportal openings -- when a spec needs a floor area rather than a guess. It reports bounding boxes, not true volumes: an L-shaped room measures as its enclosing box.
Inputs: path (required), limit, classname. Returns: path, byClass, largest, attributed, +1 more
read_bsp_entitiesA
Entities of a compiled .bsp, read from lump 0. Returns a classname histogram plus a filtered, paginated entity list. Seeks straight to the lump -- on a 1 GB map this reads about 1.5 MB. Note that a compiled lump has no Hammer ids; entities are keyed by index.
Inputs: path (required), near, limit, offset, +5 more. Returns: path, total, matched, entities, +6 more
read_bsp_infoA
Header of a compiled .bsp: ident, version, mapRevision and all 64 lumps with their offset and size. Reads only the first 1036 bytes, so it is instant even on a 1 GB map. mapRevision is the build stamp a compiled map carries.
Inputs: path (required), allLumps. Returns: path, ident, lumps, version, +4 more
read_campaignA
Reads a Left 4 Dead 2 campaign file: the mission block, its modes (coop, versus, survival, scavenge) and each mode's numbered chapters with the map, display name and image. Accepts a .txt on disk, or a vpk plus the entry inside it -- the game's own campaigns live in left4dead2/pak01_dir.vpk under missions/. Unknown keys and nested blocks are kept, so a later write does not silently drop them.
Inputs: vpk, path, entry. Returns: name, image, modes, source, +3 more
read_compile_logA
Turns compiler output into structured findings, each with what the message actually means. Use it on a log someone else produced, or on one from an editor. Several Source messages name the wrong thing -- a leak gives no location, a displacement error always prints brush id 0 -- so each finding carries the correction.
Inputs: text (required). Returns: clean, byRule, leaked, findings, +1 more
read_displacementsA
Reads the displacements of a .vmf: the grids of vertices that replace a brush face and make every piece of terrain in Source. Until now this toolkit could only detect one -- read_vmf_solids has reported hasDisplacement since the beginning and nothing has ever read what was in it. Reports each grid's power and size, where it starts, how far the terrain moves, how much of it is painted, and the world position of every vertex. Positions rather than raw arrays, because every question worth asking about a displacement is a question about where its vertices are. Also finds seams: two vertices that share an undisplaced point and no longer share a displaced one, which is the crack a player falls through and which is invisible in the editor.
Inputs: path (required), includeVertices. Returns: path, count, seams, nextStep, +2 more
read_entity_reportA
Hammer's Entity Report: every entity with its keyvalues, filterable by classname, targetname or the presence of a key. Takes a .vmf or a compiled .bsp -- on a map with no source this is not a convenience, it is the only way to ask. read_vmf counts entities by classname and read_bsp_entities gives a histogram; neither answers 'which entity has spawnflags 512', which is the question the report exists for and how a mapper finds the one door of forty that was left locked. A compiled entity has no Hammer id and owns no solids inline, so id is null and solidCount is 0 there.
Inputs: path (required), limit, hasKey, keyValue, +2 more. Returns: path, format, matched, entities, +2 more
read_fgd_classA
What the game's own FGD declares for an entity class: every keyvalue with its type and default, every input, every output. This is the schema Hammer enforces, so it answers 'does this class accept that key' without guessing from the wiki. Called with no classname it lists the classes, optionally filtered by prefix. Reads left4dead2.fgd from the game's own bin directory, not a generic multi-game database. Needs the Python sidecar and the Left 4 Dead 2 install; see health.
Inputs: game, limit, prefix, classname. Returns: type, inputs, matched, outputs, +7 more
read_game_contentA
Searches the game's installed content for materials and models, by name. This is Hammer's texture browser and model browser, which an agent otherwise does not have: without it a material is named from memory, and vbsp resolves a name literally, so a wrong one is a purple checkerboard nobody sees until a player loads the map. Returns material names in the form a .vmf stores -- uppercase, no materials/ prefix, no .vmt suffix -- which is exactly what set_face_material takes. A pattern with * or ? is a glob; anything else is a substring. Mounts the same VPK-and-loose chain the engine reads through, so this and read_map_dependencies cannot disagree about what exists. A .vmt being present is NOT the same as the material drawing: a material can name a texture this install does not have, which is the same purple checkerboard by another route. Pass details to resolve every texture a material names, or to read a model's hull bounds -- the size Hammer's model viewer shows and the number needed before placing a house on the floor. Needs the Python sidecar; see health.
Inputs: pattern (required), game, kind, limit, +1 more. Returns: game, kind, note, shown, +8 more
read_leakA
Turns a leak into a location. vbsp says only 'leaked!' and writes a .lin pointfile beside the map: this reads it and names the entities nearest to where the path starts, which is the entity that can see the void. Pass the .lin, or the .vmf or .bsp beside it. Both ends of the path are correlated, because vbsp does not guarantee which end holds the entity -- on a two-point pointfile it was the last. No pointfile is an ANSWER, not an error: it returns leaked:false, and compiled tells a map that did not leak from one nothing has compiled here. A .bsp that arrived from somewhere else -- a Workshop .gma, a copy, a download -- carries no .lin and never could, so establishedBy says whether the answer rests on evidence or on the absence of a file that was never going to be there.
Inputs: path (required), limit. Returns: end, note, start, leaked, +11 more
read_lightmap_budgetA
Where a compiled map's lightmap resolution went. Reads FACES and TEXINFO by offset: the total luxel count, a histogram by face size, the costliest individual faces, and luxels per unit of lit surface area when computable. Faces that could never carry a lightmap -- sky, nodraw, SURF_NOLIGHT -- are excluded via TEXINFO's flags, so the total is a budget, not a headcount padded with faces that cost nothing.
Inputs: path (required), limit. Returns: path, costliest, faceCount, totalLuxels, +3 more
read_map_dependenciesA
Every asset a compiled map references, and where each will come from at runtime: packed inside the map, found in the game's own content, or missing. Missing is the purple checkerboard -- the only failure on this list a mapper never sees at home, because they have the files. The walk is recursive on purpose: it follows VMT patch and include chains, $bottommaterial and $fallbackmaterial, a model's own material list, the skybox's six sides and the detail sprite config. Resolving one level gives a short, plausible, wrong answer. Also separates what is packed but never reached into three groups, because 'unreferenced' is not 'safe to delete': vrad's own output (.vhv, cubemaps) is referenced by the engine and named by no file. Needs the Python sidecar; see health.
Inputs: path (required), game, limit. Returns: game, path, loose, caveat, +18 more
read_map_extentsA
Real size of a compiled map, from the world model in lump 14. Returns the bounding box in Hammer units and in metres, the longest horizontal span and the ground area. Use this rather than entity origins: those say where things were placed, not how far the world goes. One Hammer unit is one inch (0.0254 m). Instant on any map size.
Inputs: path (required). Returns: maxs, mins, path, sizeUnits, +6 more
read_map_geometryA
What each lump of a compiled map holds, and how close that is to the compiler's ceiling. Reads only the 1036-byte directory, so it is instant. Limits are vbsp's own, from source-sdk-2013; a map that exceeds one is a map whose compilers raised it, not a broken map. Use it to see what stops a map from growing before planning work on it.
Inputs: path (required), nearLimitOnly. Returns: path, lumps, version, fileSize, +3 more
read_map_organisationA
Visgroups, groups and the cordon of a .vmf, with what belongs to each. None of it reaches the compiled map -- a visgroup hides a brush from the editor and not from vbsp -- which is why it was invisible here and why it matters at scale: on a map with two thousand brushes, 'the north tenement' has to be a name that lives in the file or every selection is a bounding box someone typed from memory. Membership is counted from the objects rather than from the declarations, so an id used by a brush and declared nowhere is reported -- Hammer drops those silently when it opens the file.
Inputs: path (required). Returns: path, groups, cordons, warnings, +4 more
read_map_reportA
Judges a compiled map against a budget profile and returns a verdict per criterion, not just numbers. This is the tool that gives an agent a stopping condition: every other reader here answers 'how much', this one answers 'is that enough'. Covers lump fill against vbsp's ceilings, entity count against the edict budget, LIGHTING against MAX_MAP_LIGHTING, whether vvis ran at all, how finely the world is split, and whether cubemaps and HDR exist. Limits come from Valve's headers; thresholds come from the profile and each one states its own provenance, including when it was simply chosen. A criterion nothing calibrates reports 'skipped' with the reason rather than a confident verdict about nothing.
Inputs: path (required), profile, verdicts. Returns: path, overall, profile, summary, +2 more
read_materialsA
Material table of a compiled map: every texture referenced by a TEXINFO, and how many TEXINFO entries reuse it -- the only accurate reuse count in the file. Reads TEXDATA, TEXDATA_STRING_TABLE, TEXDATA_STRING_DATA and TEXINFO by offset, never the whole map. Answers which materials a map actually employs, and which carry the bulk of its surfaces.
Inputs: path (required), limit, sortBy, nameContains. Returns: path, returned, materials, texdataCount, +3 more
read_model_infoA
Bounds, skins, sequences and materials of one .mdl -- what Hammer's model viewer shows before you place a prop. The bounds are the reason this exists: a model's origin is wherever the artist put it, so a prop placed at floor height sinks by however far its origin sits above its lowest point, and nothing downstream reports that. A barrel measured here is 52 units tall with its origin at the centre, which means 26 units underground if it is placed on the floor's own z. Needs the Python sidecar; see health.
Inputs: model (required), game. Returns: game, maxs, mins, note, +12 more
read_pakfileA
What a compiled map actually ships inside it: lump 40 is a plain ZIP, and this lists its contents by extension and by size. Use it to audit packing before release. Two counts answer questions you would otherwise have to trust the compile settings for: c-*.vtf files prove buildcubemaps was run, and .vhv files prove static prop lighting was baked. Needs the Python sidecar; see health.
Inputs: path (required), limit. Returns: path, largest, returned, fileCount, +5 more
read_prop_surveyA
Inventory of a compiled map's prop entities, by model and by class, plus the prop_dynamic entities that carry no name, no parent, no animation and no output. Those are dynamic for no reason: each is a real server entity that ticks and is counted by anything walking ents.GetAll(), where a prop_static costs nothing. The list is a starting point, not a verdict -- converting needs a recompile, and a model without static support cannot be converted at all.
Inputs: path (required), limit. Returns: path, byClass, byModel, propTotal, +2 more
read_sightlinesA
Longest unobstructed lines of sight across a compiled map, traced against the same world tree the engine walks for a TraceLine. Samples standable ground on a grid at the elevation where the map's content sits, then measures every pair. Answers 'how far can someone actually see here', which is what sets engagement range. It does NOT know what a street is, and it ignores static props and brush entities (a door counts as open) -- see the excludes field it returns.
Inputs: path (required), limit, spacing, elevation, +3 more. Returns: path, longest, spacing, excludes, +3 more
read_source_gamesA
Left 4 Dead 2 as installed here, discovered from Steam's own files rather than from a hard-coded path: libraryfolders.vdf for the libraries, appmanifest_550.acf for the app, and left4dead2/gameinfo.txt for its name, its SteamAppId, its .fgd files and its instance path. Reports which stock compilers are present. This fork supports no other game, so other Source installs are not listed.
Inputs: no named parameters. Returns: game, note, games, libraries, +1 more
read_visleaf_statsA
Quality of a compiled map's visibility split: LEAFS for the bounding volume and cluster of every leaf, VISIBILITY for the map's real cluster count from its own header. Reports leaf and cluster counts, the distribution of leaf volumes (median and mean), and the fraction of leaves outside any cluster (-1) -- usually solid leaves, which own no visible space. Handles both dleaf_t sizes (version 0 and 1); any other LEAFS version is refused rather than guessed at.
Inputs: path (required). Returns: path, volume, leafBytes, leafCount, +5 more
read_vmfA
Entities, outputs and brush counts of a .vmf, reported without judgement. Use it to see what a map source contains; use read_vmf_lint to find what is wrong with it. Unlike a compiled .bsp, a VMF keeps Hammer ids, so anything reported here can be found again in the editor. Needs the Python sidecar; see health.
Inputs: path (required), game, limit, classname, +1 more. Returns: game, path, counts, matched, +4 more
read_vmf_leakA
Whether a .vmf is sealed, WITHOUT compiling it. Today the only thing that can answer is vbsp, which costs a toolchain and minutes, and which refuses to run vvis afterwards. This floods the open space from a point inside -- a spawn entity, by default -- and reports where the flood got out, with the path to follow, the same shape as the .lin pointfile. A wall thinner than the cell size is not resolved, so this can miss a leak; it does not invent one, because a cell counts as free only when its whole interior is.
Inputs: path (required), step, seeds, maxCells. Returns: path, step, cells, notes, +6 more
read_vmf_lintA
Checks a .vmf against the game's FGD and against what the compilers accept, before a compile that can take forty minutes to fail. Finds unknown classes and keyvalues, outputs aimed at nothing, inputs a target class does not answer to, texture scales that become 'Bad surface extents', displacements on brush entities (with the real brush id, which vbsp does not print), props standing below the floor they were placed on because their model's origin is at its centre, and counts that approach the compiler limits. Knows the entities the installed FGD declares, so a class the game has is not reported as unknown. L4D2 campaign rules are included: a non-L4D2 changelevel, a missing landmark or checkpoint door, and a Standard finale are reported. Needs the Python sidecar and the Left 4 Dead 2 install; see health.
Inputs: path (required), game, rule, limit, +2 more. Returns: game, path, total, byRule, +9 more
read_vmf_nearest_surfaceA
The nearest solid surface to a point in a .vmf, exactly -- distance, the point on the surface, and which brush and face it belongs to. Exact rather than sampled: the closest point on a convex brush is the closest over its faces, and on a face it is either the foot of the perpendicular or a point on an edge. A sampled version would report a clearance that changes when the sample step does.
Inputs: at (required), path (required), mask, owners, +1 more. Returns: path, notes, radius, nearest, +3 more
read_vmf_roomsA
The rooms of a .vmf, the openings between them, and how they connect -- from the geometry alone, with no compilation and no annotation in the file. Rooms come from a watershed on the clearance field, NOT from connected components: a sealed map has exactly one of those. This is a heuristic and it says so, with the parameters that produced it; it can split a hall with a pillar in it and swallow an alcove. Widths are voxel estimates to within a cell. Use it to ask what a place IS -- how many rooms, how wide the doors, what connects to what -- rather than what is at a coordinate.
Inputs: path (required), step, seeds, maxCells, +2 more. Returns: path, notes, rooms, merges, +7 more
read_vmf_sightlinesA
The longest clear lines of sight in an UNCOMPILED .vmf, sampled from the places a person can actually stand. read_sightlines answers the same question on a compiled map by sampling ground in a column, which picks up roofs and the spawn room under the map; this samples the standable cells the room pass found, which is a stronger constraint and needs no vbsp. Long sight lines are what a mapper trades away for framerate, so the number is a design decision rather than a fault.
Inputs: path (required), step, limit, seeds, +3 more. Returns: path, notes, longest, pairsTested, +1 more
read_vmf_solidsA
Rebuilds every brush of a .vmf from its planes and checks that it is a closed convex volume. Reports each solid's corner count, bounding box and volume, plus what is wrong with it: a side wound the wrong way (the planes then enclose nothing), three collinear points that define no plane, a side that bounds no face, a corner outside the world, a texture axis pointing along its own face normal so the texture stretches without bound. It runs the opposite way round from anything that writes a brush -- planes to volume rather than volume to planes -- which is what makes it usable as an independent check rather than a restatement.
Inputs: path (required), grid, limit, include, +1 more. Returns: path, solids, returned, truncated, +4 more
read_vmf_surfacesB
Every face of a .vmf sorted into floor, wall, ceiling and slope, with how much of each a person could actually touch -- and which brush touches which. A map is boxes pushed against each other, so most of what a .vmf contains is buried: the underside of every slab, the back of every wall. Counting those doubles a building's floor area in a number that reads perfectly ordinary. Exposure is measured by probing along each face's own normal. Note that 'exposed' means open space in front, which includes the outside of the map: a ceiling slab's upper face is the roof.
Inputs: path (required), kind, limit, material, +1 more. Returns: path, faces, notes, matched, +5 more
read_vmf_traceA
Trace a ray, or a swept player-sized box, through a .vmf -- with no compilation. Answers what a mapper checks by walking the map: what is in the way, how far, which brush and which face. A brush is already an intersection of half-spaces, so this needs no vbsp; the same rays agree with the compiled map's own tracer to under half a unit on the probe map. Use hull: standing for anything about whether a person gets through: a line passes a 24-unit gap that nobody fits.
Inputs: to (required), from (required), path (required), hull, +2 more. Returns: hit, hull, mask, path, +12 more
read_vmf_visibilityA
Whether each of several named pairs of points can see each other in an uncompiled .vmf, and what blocks the ones that cannot -- by brush id, face and material. read_sightlines answers a different question on a compiled map: it samples the ground and finds the LONGEST lines. This one answers about sight lines you name, which is what 'does moving this wall break the view from the lobby to the desk' needs. Also reports the nearest surface to each endpoint, so an endpoint accidentally inside geometry is visible as such rather than reported as blind.
Inputs: path (required), pairs (required), mask, owners. Returns: path, clear, lines, notes, +3 more
render_vmf_planA
A dimensioned floor plan of a .vmf: a horizontal cut taken above the floor, with room outlines, floor areas, the width written on every doorway, a grid, a scale bar and a north arrow. render_vmf_view says what a place looks like from somewhere; this says WHERE things are, and it is the drawing you can measure with. Returns the picture to look at and the SVG to keep, both from one description, so the two cannot disagree. Anything entirely above or below the cut is not on the drawing -- a raised walkway, a sunken pit -- so the cut height is always reported.
Inputs: path (required), svg, cutZ, grid, +4 more. Returns: svg, cutZ, path, notes, +9 more
render_vmf_tourA
Walks a .vmf and returns one picture of the whole place: a contact sheet of eye-height views, one per room and one from each side of every doorway, worked out from the map rather than from cameras you supply. This exists because of a measurement -- across three sessions in which cold agents built the same map end to end, render_vmf_view was called once between them, and the map that passed every check had a door painted flat on a wall, counters that were single boxes and no skirting anywhere. None of that is visible to any check and all of it is obvious in one look. Cameras stand where a player would, via the same floor-finding measure_vmf_clearance uses, so no frame is the inside of a slab. When the room pass finds nothing to walk it falls back to the spawn and an outside view, and says so rather than returning an empty sheet.
Inputs: path (required), fov, step, width, +3 more. Returns: path, rows, notes, views, +5 more
render_vmf_viewA
Renders a .vmf from a camera and returns the picture, so the shape of a place can be LOOKED at rather than inferred from coordinates. Flat colour per face, one light, no textures and no props: it shows form and occlusion -- what stands where, what hides what, how much room there is at eye height -- and it deliberately does not show atmosphere, which only a capture from the running game can. Camera convention is Source's own (x forward, y left, z up; angles pitch/yaw/roll; fov horizontal), the same one gmod-mcp's read_view reports, so a rendering and an in-game capture from the same numbers frame the same thing. A face's colour is a stable hash of its material, so the same wall is the same colour in two renderings an edit apart.
Inputs: path (required), fov, near, stand, +8 more. Returns: fov, path, notes, width, +11 more
run_bsp_renameA
Renames a compiled .bsp AND the content packed inside it -- the nodegraph, cubemap patches, soundscripts, anything under maps//. Renaming the file alone orphans every one of them: the engine looks them up by the map's name, finds nothing, and says nothing, so the symptom is Nextbots that will not path or a missing soundscape rather than an error. Drives ficool2's bsp_rename, which is a separate download; health says whether it is installed. Writes a NEW .bsp beside the old one and leaves the original alone.
Inputs: bsp (required), newName (required), confirm. Returns: ok, bsp, note, tool, +8 more
run_compileA
Compiles a .vmf with vbsp, vvis and vrad natively, and returns each stage's findings rather than its raw output. Takes minutes to hours: vvis on a large map is the slow part, and -fast exists for iteration. Stops at the first stage that fails, because vvis and vrad results are meaningless after a leak. Run read_vmf_lint first -- it catches before the compile most of what makes one fail.
Inputs: vmf (required), hdr, cull, fast, +5 more. Returns: ok, bsp, vmf, cull, +9 more
run_cubemap2hdrA
Converts an LDR cubemap .vtf into the HDR one Source loads in HDR mode, writing .hdr.vtf beside it. A map compiled without -both, or one whose cubemaps were built in LDR, renders its reflections from the LDR set in both modes; this is the offline way to produce the missing half without going back into the game. Input must be DXT1 -- the tool refuses anything else, and this says so before running. Extract one from a map with run_pakfile_extract. Drives ficool2's cubemap2hdr, a separate download; health says whether it is installed.
Inputs: vtf (required), confirm. Returns: ok, vtf, note, tool, +7 more
run_map_testA
Launches an installed map and watches the engine's console log for a pattern, then closes the game. This is the automated half of a play test: 'did the next chapter load', 'did the finale script run', 'did the map finish loading at all'. The map must already be installed in left4dead2/maps or a mounted add-on VPK. Returns the match, the elapsed time and the log tail; the full log stays at <game>/left4dead2/console.log.
Inputs: map (required), waitFor (required), confirm, extraArgs, +1 more. Returns: map, reason, logTail, matched, +1 more
run_packA
Packs files into a compiled .bsp with bspzip, so custom assets ship with the map instead of appearing as purple checkerboards on every client that lacks them. Takes explicit pairs of in-game path and source file. With auto:true it also derives the list from the map itself, via read_map_dependencies: every asset the map references that resolves from a LOOSE file in the game's content tree rather than from a VPK. Those are the ones that ship broken -- they work at home because they are on that disk. VPK content is never packed: every player who owns the game has it. The derived list is returned, so what was packed is visible rather than inferred. Verifies afterwards by re-reading the pakfile: bspzip reports success whether or not anything was added.
Inputs: bsp (required), auto, game, files, +3 more. Returns: ok, bsp, game, added, +13 more
run_pakfile_extractA
Extracts files from a compiled map's embedded pakfile (lump 40, a plain ZIP) into a directory. read_pakfile lists what is in there; this is what gets it out -- a packed cubemap to convert, a soundscript to read, a custom material to inspect. Refuses an entry whose name would escape the destination rather than sanitising it, and never overwrites unless told to. Needs the Python sidecar; see health.
Inputs: bsp (required), into (required), limit, confirm, +2 more. Returns: bsp, into, note, bytes, +5 more
run_tga2skyboxA
Builds a cubemap .vtf from six TGA faces -- rt.tga, lf, bk, ft, up, dn -- and writes both the LDR and the HDR set. This is the one part of cubemap work that does NOT need the engine: buildcubemaps captures a cubemap from inside a running map, this makes one from images. Drives ficool2's tga2skybox, a separate download; health says whether it is installed. Reads and writes only in the directory the faces are in.
Inputs: dir (required), base (required), confirm. Returns: ok, dir, vtf, base, +11 more
run_vpk_packB
Packs a staging directory into an addon VPK with the game's own vpk.exe. The directory is packed root-relative, so addoninfo.txt, missions/, maps/ and materials/vgui/maps/ end up where the game expects them. addoninfo writes the manifest first when the directory has none. Afterwards the archive is read back through the sidecar and its entry list is compared with the staging tree: a pack that silently dropped a file is the failure this check exists for.
Inputs: dir (required), out, confirm, addoninfo, +1 more. Returns: vpk, bytes, entries, staging, +3 more
run_vtf_convertA
Converts an image (.tga, .png, .bmp, .jpg ...) into a .vtf the engine can load, written beside the source. The step that used to need a GUI: read_game_content finds what the game ships, this makes what it does not. Drives VTFCmd from ficool2's VTFEdit++, a separate download; health says whether it is installed. Reads the result back and reports its real format and size rather than the ones asked for.
Inputs: image (required), flags, format, confirm, +3 more. Returns: ok, vtf, note, tool, +6 more
sculpt_displacementA
Reshapes displacements: flatten, raise, slope between two heights, or add noise. Declarative shapes rather than a table of vertices, and noise takes a seed rather than reaching for a random number generator -- a terrain that cannot be regenerated from what produced it cannot be reviewed, cannot be tested and cannot survive a merge. Sculpting one displacement of a terrain moves the edge it shares with its neighbours, so the result says whether a seam opened and sew_displacements closes it.
Inputs: path (required), shape (required), backup, dryRun, +2 more. Returns: path, written, nextStep, warnings, +6 more
set_cordonA
Sets the cordon box and whether it is on. The only piece of a map's organisation that changes what compiles: with the cordon on, vbsp is handed only what the box contains and everything outside it is simply not in the map. It is how a mapper tests one room of a city without waiting for the city, and it is also how a map ships with three quarters of itself missing -- vbsp does not warn, because from its point of view nothing is wrong. Setting it always reports whether it is active.
Inputs: maxs (required), mins (required), path (required), name, +4 more. Returns: name, path, active, written, +4 more
set_face_materialA
Sets the material on selected faces of a .vmf. Until this existed a brush's material was fixed at creation and nothing could change it, which made set_lightmap_scale the odd position of being able to say how finely to light a wall but not what the wall was made of. Selects by solid, material, facing or area. The name is normalised to the form a .vmf stores -- uppercase, no materials/ prefix, no .vmt suffix -- because vbsp resolves it literally and a wrong one is invisible until a player loads the map. Whether the material exists is NOT checked here: use read_game_content for that.
Inputs: path (required), newMaterial (required), all, backup, +6 more. Returns: path, changed, matched, written, +4 more
set_lightmap_scaleA
Sets lightmapscale on selected faces of a .vmf. The value is units per luxel, so it runs backwards from intuition: smaller is finer and more expensive, and the cost is an area -- halving the scale quadruples the luxels on that face. Select by solid, by material, by which way a face points, by minimum area, or a combination. Reports the luxel count before and after, per face and in total, before writing. Warns when a face would cross MAX_BRUSH_LIGHTMAP_DIM_WITHOUT_BORDER (32 luxels per texture axis, read from bspfile.h): vbsp does not refuse that, it splits the face until each piece fits, so the bill includes extra faces and not only extra luxels. Verify with read_lightmap_budget on the recompiled map.
Inputs: path (required), scale (required), all, backup, +6 more. Returns: path, changed, written, nextStep, +9 more
set_map_propertiesA
Sets the keyvalues that really live on worldspawn: the sky, the detail sprites, the prop fade width. Ordinary keyvalues on an ordinary entity, so this is edit_vmf with a shorter name -- except that detailvbsp and detailmaterial come as a pair, and setting one without the other gives a map whose grass either has no sprites or has sprites with no material, which vbsp mentions neither of. Fog is NOT here: Source reads fogenable, fogstart, fogend and fogcolor from an env_fog_controller, and writing them to worldspawn gives a file that parses and no fog in game. Create the controller with edit_vmf.
Inputs: path (required), backup, dryRun, confirm, +4 more. Returns: path, changed, written, nextStep, +3 more
set_smoothing_groupsA
Sets the smoothing groups on selected faces. Two faces sharing an edge and a group are lit by vrad as one continuous surface; without it every facet of a curve is lit separately and reads as the flat polygons it really is. Takes Hammer's own group numbers, 1 to 32, and does the bit shifting -- the file stores a bitmask, so group 13 is 4096 and getting that wrong is silent. Pass an empty list to clear them.
Inputs: path (required), groups (required), all, backup, +6 more. Returns: mask, path, matched, written, +5 more
set_solid_classA
Moves brushes between the world and a brush entity -- in practice, into or out of func_detail. This is the largest single lever on a Source map's performance and it is invisible in a compiled .bsp, because vbsp folds func_detail into the world: a shipped map cannot tell you which brushes were structural. A structural brush splits the BSP tree and spawns visleaves, so trim, pillars and window frames cost a slower compile and a worse PVS for nothing. WARNING: a func_detail brush does not seal the map. Move a wall into one and the next compile leaks, and no check here can rule that out -- sealing is a property of the whole hull. Compile afterwards and read the leak.
Inputs: to (required), path (required), solidIds (required), backup, +3 more. Returns: path, moved, written, nextStep, +5 more
set_visgroupA
Puts brushes in a named visgroup, creating it if it does not exist, or takes them out. This is what gives a selector a durable name: once 'north tenement' is in the file, every later call can say owner or ids without a bounding box typed from memory. Both halves are written -- the declaration in the visgroups block and the membership in each brush's editor block -- because Hammer drops a membership whose visgroup is not declared, without a word, the next time it opens the map. A brush may be in several visgroups at once, which is the normal case and not an error.
Inputs: name (required), path (required), color, owner, +7 more. Returns: path, created, written, nextStep, +5 more
sew_displacementsA
Pulls displacements back together along the edges they share. Two vertices belong together when their undisplaced positions coincide -- the faces share that point whatever either grid has since done to it -- and each group is moved to its average, which is what Hammer's Sew does and what keeps a ridge from being dragged to one side of the join. The check is exact: read_displacements must report no seam afterwards, and it decides adjacency the same way, so it would find any pair this missed.
Inputs: path (required), backup, dryRun, confirm, +1 more. Returns: path, written, nextStep, warnings, +6 more
transform_solidsA
Moves, turns, scales or mirrors brushes that are already in a .vmf. Until this existed the write path could only add: a brush placed an inch out of position could not be nudged, only rewritten. Selects by id, owner, material or bounding box, and edits only the plane and texture-axis lines of the brushes it moved -- nothing else in the file shifts by a byte. Texture lock is on by default, so a texture stays where it sits on its face, as in Hammer. The result is read back through read_vmf_solids before the file is touched and the write is refused if any brush stopped being one; volume is reported before and after, and a transform must scale it by its own determinant or something is wrong.
Inputs: path (required), grid, move, owner, +10 more. Returns: path, solids, matched, written, +5 more
validate_ioA
Checks a map's entity wiring against the game's own FGD. read_fgd_class has been able to say what inputs a class has since the beginning and nothing has ever used it to judge a map, so an output aimed at an entity that does not exist, or at an input its class does not have, passes every check here and every check vbsp makes -- and then does nothing in game. That is the quietest failure a map has. Targets the engine resolves at runtime (!activator, !self, !player) are reported as unresolvable rather than as broken, and a class with no FGD schema is not judged at all: absence of a definition is not evidence of a fault. Needs the Python sidecar and the game's FGD.
Inputs: path (required), game, limit. Returns: game, path, format, findings, +7 more
write_campaignA
Writes a campaign file from a name and a list of modes with numbered chapters. Refuses to overwrite unless overwrite is set, and refuses a structurally invalid campaign (no name, an empty mode, a map given with a path or extension) rather than writing one the game will not read. The file is written through the same write guard as every other writer.
Inputs: name (required), modes (required), out, image, +7 more. Returns: path, bytes, modes, written, +2 more
write_displacementA
Creates displacements on selected faces: the vertex grids that make every piece of terrain in Source. Power 2, 3 or 4, which are 5x5, 9x9 and 17x17 grids -- Source accepts 0 and 1 and no terrain is built with them. Flat by default, which is what Hammer's own create makes and what a mapper then sculpts. WARNING: a displacement does not seal. vbsp builds the hull from the brush's own planes and draws the terrain over it, so displacing a face of the map's shell leaks through a shape the terrain no longer has, and the leak names a brush that looks solid in the editor. Refuses a face that already carries one rather than discarding what was sculpted onto it.
Inputs: path (required), power (required), all, backup, +6 more. Returns: path, created, matched, written, +4 more
write_hint_brushA
Creates a hint brush: a slab carrying TOOLS/TOOLSHINT on the plane vvis should cut along and TOOLS/TOOLSSKIP everywhere else. This is the one lever that shapes a map's visibility tree directly, and nothing in a compiled .bsp records it -- vvis consumes hints and they are gone from the file, so this can only be done on the source. rotateZ makes the cut diagonal, which is what a mapper does when a city's streets do not run along the axes. Verify by compiling before and after and comparing read_visleaf_stats: a hint that moves no leaf count did nothing.
Inputs: maxs (required), mins (required), path (required), backup, +4 more. Returns: grid, maxs, mins, path, +9 more
write_portalA
Places an areaportal, an areaportal window or an occluder: the two brush entities read_map_geometry has counted since the beginning and nothing has ever placed. They are the runtime half of visibility. An areaportal seals a doorway and the engine opens and closes it as the player moves, culling everything beyond it while it is shut -- the strongest tool Source has and the fussiest, because vbsp refuses the whole map if the brush does not fill its opening exactly. An occluder hides what is behind it per frame on the CPU: it never fails a compile and it costs time whether or not it saves any. The brush is written through the same path as every other, and gets the tool material without which the entity is a solid wall the player walks into.
Inputs: maxs (required), mins (required), path (required), classname (required), +5 more. Returns: path, solidId, written, entityId, +5 more
write_vmfA
Creates an empty .vmf: Hammer's File > New. The map every other writer here assumes already exists -- write_vmf_solid reads its target before writing and refuses a file with no world block, so neither an absent nor an empty file is a place to start. Writes worldspawn with a skyname, because a map without one renders whatever sky the engine loaded last. REFUSES to overwrite: a map is hours of work and this tool's whole job is the first second of it.
Inputs: path (required), game, dryRun, confirm, +2 more. Returns: note, path, bytes, dryRun, +3 more
write_vmf_fittingA
Builds the things a room is finished with -- a door casing, a counter, skirting or a cornice -- as the several brushes each of them actually is. write_vmf_solid makes one convex shape per call, so an agent that thinks 'counter' writes a box: three rounds of building maps with these tools produced counters, shelving and doorways that were each a single slab, with a door texture painted flat on a wall where a frame should be. The trade here is that you own the envelope and this owns the articulation -- give it the same mins/maxs you would have given a box and get a worktop with a nosing over a body over a recessed kick. Every internal dimension comes from a table measured off models Valve ships (read_model_info, 13/08/2026), which also found that Source's world is built a third taller than its own player: a door leaf is 108 units, a shop counter 56, with the eye at 64. Refuses any assembly whose parts share an interior or fail to join up, which is a class of error per-brush validation cannot see.
Inputs: path (required), fittings (required), backup, dryRun, +6 more. Returns: path, built, notes, target, +8 more
write_vmf_solidA
Creates brushes in a .vmf from a shape description: box, wedge (a ramp), cylinder (an n-sided prism), or convex for a hull given face by face. Chooses the planes, winds every face outward and derives the texture axes with vbsp's own base-axis table, so the texture does not come out stretched or rotated. Inserts by splicing at the end of the target block: nothing already in the file moves, comments and formatting included. Every solid it writes is passed straight back through read_vmf_solids before the file is touched, and the write is refused if any of them fails -- the writer goes volume to planes, the checker goes planes to volume, so neither can hide the other's sign error.
Inputs: path (required), solids (required), backup, dryRun, +6 more. Returns: path, notes, target, written, +7 more
write_vscriptA
Writes a Left 4 Dead 2 VScript (.nut) and optionally attaches it to a map. Checks the file for the Lua habits that break Squirrel, for balanced braces, and for a load banner that makes the script's execution provable in console.log. When vmf is given, adds a logic_script entity with vscripts set to the file's base name (no extension), which is how the engine finds it inside an add-on VPK. Guarded.
Inputs: path (required), content (required), vmf, confirm. Returns: vmf, path, bytes, attached, +2 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 80 tools
Despite 80 tools, most have sharply distinct purposes and the descriptions actively cross-reference near-neighbours (read_sightlines vs read_vmf_sightlines, read_vmf vs read_entity_report, read_map_geometry vs read_map_report, read_pakfile vs run_pakfile_extract). A few pairs still require careful reading to separate — read_vmf_lint vs check_vmf_rules vs validate_io, run_pack vs run_vpk_pack — but the descriptions resolve them rather than leaving them ambiguous.
Nearly everything follows a verb_noun pattern with a small verb vocabulary (read_, write_, run_, check_, set_, measure_, render_, delete_, plus brush verbs like clip_solids, hollow_solids, sew_displacements). The only real outlier is the bare noun 'health', and a couple of noun-ish actions (group_solids, align_faces) that still read clearly.
80 tools for a map-authoring toolchain is far past what an agent can hold in view at once, and many are narrow single-purpose helpers (set_cordon, set_smoothing_groups, align_faces, sew_displacements). The domain is genuinely broad — VMF editing, compiling, VPK, nav, materials, rendering — but several are grouped by sub-feature rather than by coherent task, which inflates the surface.
The lifecycle is covered end to end: campaign read/write/check, VMF creation through brush/displacement/entity/texture editing and organisation, linting, compilation, leak triage, packing, nav, cubemaps, rendering, and play-testing. Even verification has its own tools (read_vmf_solids as an independent checker, read_map_report as a stopping condition), so few obvious dead ends remain.
Maintenance
Related MCP Connectors
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
Hosted MCP server and Agent Skills for specs, engineering threads, and project memory.
Hosted MCP server to manage a restaurant menu from AI agents - 39 tools over the DuckHub API.
Related MCP Servers
- AlicenseBqualityCmaintenanceAn MCP server that lets an AI agent drive Unreal Engine 5: create projects, import assets, build levels and Blueprints, configure replication, compile C++, run Play In Editor and package the game.100187 PyPI6MIT
- AlicenseAqualityDmaintenanceCustom MCP server that lets AI control Autodesk Maya 2022+ directly, using code execution and self-discovery rather than hundreds of predefined tools. Includes structured tools for Unreal Engine asset preparation, validation, and FBX export.16MIT
- FlicenseAqualityCmaintenanceEnables AI agents to edit Quake-format .map files and see their changes appear live in TrenchBroom, with tools for reading, editing, previewing, compiling, and launching maps.172-
- FlicenseNot gradedqualityBmaintenanceEnables AI clients to create, inspect, edit, and deploy Counter-Strike 2 maps and addons by working with Hammer map files, addon source files, Valve's resource compiler, and Workshop Tools locally.1-