RPG Maker MV Ultimate MCP

High-level helper: create a treasure chest on a map as a ready-to-play 2-page event — page 1 plays the open animation, gives the listed items, and turns on Self Switch A; page 2 shows the chest already opened so it cannot be looted twice. The map file is written to disk immediately. Returns the created event including its id. Fails with an error if the map does not exist; item IDs are NOT validated, so confirm them first with get_items/get_weapons/get_armors to avoid giving null items.

Create a new actor class (defines stat growth, EXP curve, learnable skills, and traits) and persist it to data/Classes.json immediately with the next free ID. Returns the complete created class object including its new id — assign it to actors via create_actor/update_actor classId. Fails with an error if Classes.json cannot be read or written.

Create a new common event and persist it to data/CommonEvents.json immediately with the next free ID. With trigger 0 it only runs when called from another event (command code 117); with trigger 1 (autorun, blocks the player) or 2 (parallel, background) it runs whenever its switchId is ON — so always pair trigger>0 with a real switch or it will loop forever from game start. Returns the complete created common event including its new id. Fails with an error if CommonEvents.json cannot be written.

Convenience wrapper around create_skill for offensive skills: creates an HP-damage, physical-hit, can-crit skill in data/Skills.json (written immediately) with the next free ID. Returns the complete created skill object including its new id. Fails with a validation error if required arguments are missing or malformed. Use create_skill instead when you need TP costs, multi-hit, drain, custom messages, or extra effects.

Create a new entry in an RPG Maker MV database with the next free ID; the data file is written immediately. Returns the complete created object including its new id. Two forms: with `entity` + `data` it creates a raw entry (omitted fields get engine defaults; data.name is expected); with `preset` it builds a ready-to-use entry from a recipe — damage_skill {name, mpCost, scope, formula, element?, animationId?}, healing_skill {name, mpCost, scope, formula}, buff_skill {name, mpCost, scope, paramId 0-7, turns}, state_skill {name, mpCost, scope, stateId, chance 0-1}, boss_enemy {name, battlerName?…

Create a new enemy and persist it to data/Enemies.json immediately with the next free ID. Returns the complete created enemy object including its new id. To make it appear in battle, add it to a troop afterwards (create_troop, add_enemy_to_troop, or create_random_encounter_troop). Fails with an error if Enemies.json cannot be read or written. For boss-tier enemies with a preset action pattern, create_boss_enemy is quicker.

Convenience wrapper around create_skill for restorative skills: creates an HP-recover skill usable in battle and menu, persisted to data/Skills.json immediately with the next free ID. Returns the complete created skill object including its new id. Fails with a validation error if required arguments are missing or malformed. Use create_skill instead for MP restoration, revival, or heal-plus-status combos.

High-level helper: create an innkeeper event with the classic inn flow — asks the player (Yes/No choice), checks gold, deducts the cost, fades out, fully recovers the party, and fades back in; refuses if the player cannot pay. The map file is written to disk immediately. Returns the created event including its id. Fails with an error if the map does not exist. For a general store use create_shop.

Create a new consumable item (potion, scroll, key item) and persist it to data/Items.json immediately with the next free ID. Omitted fields get engine defaults (consumable, usable from menu, scope = one ally). Returns the complete created item object including its new id — use that ID in create_chest, create_shop, or event commands. Fails with an error if Items.json cannot be read or written. Use create_weapon / create_armor for equipment instead.

Create a new map file (data/MapNNN.json) with the next free map ID and register it in MapInfos.json — both files are written to disk immediately. With a `theme`, also generates a tile layout; when `tilesetId` is provided with a theme, reads the tileset's real tile IDs for a coherent layout including shadow/region layers. Returns the new map's id, name, and dimensions — keep the id for create_npc, connect_maps, etc. Fails with an error if MapInfos.json cannot be written. Prefer generate_map_v3 for richer procedural generation (noise-based terrain, auto-placed events); use this for blank or simp…

Create a new low-level event on a map at the given position and persist the map file immediately; the event gets the next free event ID. If you pass no `pages`, the event is created with one empty page that does nothing until you add commands with add_event_command. Returns the created event object including its new id. Fails with an error if the map does not exist. For common patterns prefer the high-level helpers, which build correct multi-page events for you: create_npc, create_chest, create_teleport_event, create_shop, create_inn, create_boss_event.

High-level helper: create a talking NPC on a map as a ready-to-play 2-page event — page 1 shows the dialogue on action button and turns on Self Switch A; page 2 (active once A is on) shows the last dialogue line for repeat talks. The map file is written to disk immediately. Returns the created event including its id. Fails with a validation error if arguments are malformed or the map does not exist. Use create_map_event + add_event_command instead when you need custom triggers, conditions, or branching dialogue.

High-level helper: create a linked switch-and-door puzzle as TWO events on the same map — a floor switch that turns the given game switch ON when activated, and a door that only opens (becomes passable/teleports) while that switch is ON. The map file is written to disk immediately. Returns both created events with their ids. Fails with an error if the map does not exist. Reserve a dedicated game switch ID (check get_switches) — reusing a story switch will tangle quest logic.

Convenience wrapper around create_troop: creates a troop from a list of enemy IDs with battle positions computed automatically (evenly spread). Persisted to data/Troops.json immediately with the next free ID. Returns the complete created troop including its new id — add it to a map's encounter list or use it in events. Enemy IDs are not validated; confirm them with get_enemies first. Use create_troop when you need exact positioning or hidden members.

High-level helper: create a shopkeeper event that opens the buy/sell screen (Shop Processing) with the given goods when the player talks to it. The map file is written to disk immediately. Returns the created event including its id. Fails with an error if the map does not exist; item IDs in goods are NOT validated — confirm them with get_items/get_weapons/get_armors or the shop will sell null entries. For an innkeeper use create_inn; for a plain dialogue NPC use create_npc.

Create a new skill with full control over every property (damage formula, costs, scope, effects, traits) and persist it to data/Skills.json immediately with the next free ID. Returns the complete created skill object including its new id — link it to classes via create_class/update_class learnings or to enemies via action patterns. Fails with an error if Skills.json cannot be read or written. For common cases prefer the simpler helpers: create_damage_skill (attacks), create_healing_skill (heals), create_buff_skill (stat buffs), create_state_skill (poison/sleep/etc.).

Create a new status condition (ailment or buff) and persist it to data/States.json immediately with the next free ID. The state's gameplay impact comes from its `traits` (e.g. a poison state needs an HP-regen trait with a negative value: {code: 22, dataId: 7, value: -0.1} for -10% HP per turn) and `restriction`. Returns the complete created state object including its new id — inflict it via create_state_skill or skill effect code 21. Fails with an error if States.json cannot be written.

Convenience wrapper around create_skill for status-infliction skills (poison, sleep, paralysis): creates a magical-hit skill whose only effect is adding one state with a given chance. Persisted to data/Skills.json immediately with the next free ID. Returns the complete created skill object including its new id. Fails with a validation error if required arguments are missing. The state itself must already exist — create it first with create_state if needed. Use create_skill to combine damage and status in one skill.

High-level helper: create a one-way transfer event (door, stairs, cave entrance) that moves the player to a position on another map. The source map file is written to disk immediately. Returns the created event including its id. Fails with an error if the source map does not exist; the DESTINATION is not validated, so double-check destMapId/destX/destY or the player will teleport into a void — validate_map can catch transfers to map 0. For two-way passages between maps, connect_maps creates both directions in one call.

Create a new troop (enemy formation) with explicit member positions and persist it to data/Troops.json immediately with the next free ID. Returns the complete created troop object including its new id — use that ID in create_boss_event, map encounter lists, or Battle Processing commands. Enemy IDs in members are NOT validated; confirm them with get_enemies first. For auto-positioned members, create_random_encounter_troop is simpler; to extend an existing troop use add_enemy_to_troop.

Create a new weapon and persist it to data/Weapons.json immediately with the next free ID. Returns the complete created weapon object including its new id — use that ID in actor equips, create_chest, or create_shop. Fails with an error if Weapons.json cannot be read or written. Use create_item for consumables and create_armor for defensive gear.

DESTRUCTIVE: delete an actor by setting its entry in data/Actors.json to null (written immediately; not undoable — re-create it if needed). If the actor is in the starting party (System.json partyMembers) or referenced by events, those references break — update them first. The ID is never reused. Returns the deleted actor object for reference. Fails with an error if the ID does not exist.

DESTRUCTIVE: delete a class by setting its entry in data/Classes.json to null (written to disk immediately; not undoable — re-create it if needed). Actors still referencing this classId will break at runtime; reassign them with update_actor first. The ID is never reused by create_class. Returns the deleted class object for reference. Fails with an error if the ID does not exist.

DESTRUCTIVE: delete a database entry by nulling it out in its data file (written immediately; not undoable — re-create it if needed; IDs are never reused). The delete is refused while anything still references the entry, listing every place: events, common events, troop pages, page conditions, map encounters, the starting party, actor classes and starting equipment, class learnings, enemy actions and drops, troop members, traits, item and skill effects, animations. Fix those first, pass dryRun:true to preview the list, or force:true to delete anyway (the result then lists brokenReferences). Re…

DESTRUCTIVE: delete an enemy by setting its entry in data/Enemies.json to null (written immediately; not undoable). Troops that still include this enemy will reference a null entry and may break battles — check get_troops and update affected troops first. The ID is never reused. Returns the deleted enemy object for reference. Fails with an error if the ID does not exist.

DESTRUCTIVE: delete an item, weapon, or armor by setting its entry to null in the database chosen by `type` (Items.json, Weapons.json, or Armors.json; written immediately; not undoable). Chests, shops, actor equips, and events referencing the ID will give/sell nothing or break — update them first. The ID is never reused. Returns the deleted object for reference. Fails with an error if the ID does not exist in that database.

DESTRUCTIVE: remove an event from a map (written to disk immediately; not undoable — fetch it first with get_map_event if you may want it back). Other events that target it by ID (e.g. Set Event Location) will break. Returns the deleted event object for reference. Fails with an error if the map or event does not exist.

DESTRUCTIVE: delete a skill by setting its entry in data/Skills.json to null (written immediately; not undoable). Class learnings, enemy action patterns, and actors who already know the skill will reference a null entry — clean those up first (get_classes, get_enemies). Never delete skills 1 (Attack) or 2 (Guard); the engine uses them directly. The ID is never reused. Returns {deleted: <skill>} for reference. Fails with an error if the ID does not exist.

DESTRUCTIVE: delete a state by setting its entry in data/States.json to null (written immediately; not undoable). Skills, items, and traits referencing this state ID will silently stop working or error — search for references first. NEVER delete state 1 (KO); the battle engine requires it. The ID is never reused. Returns the deleted state object. Fails with an error if the ID does not exist.

Copy an existing map — tiles, events, and settings — into a brand-new map file with the next free map ID, registered in MapInfos.json (both files written immediately). The source map is not modified. Returns the new map's id and name; transfer events in the copy still point to their ORIGINAL destinations, so review them with get_map_events and fix with update_map_event. Fails with an error if the source map does not exist. Useful for map variants (day/night, before/after-story versions).

Modify existing maps; the affected map files / MapInfos.json are written immediately. `action` selects the edit: "fill_layer" overwrites an ENTIRE tile layer with one tile ID (destructive, not undoable; layers: 0-1 ground, 2-3 upper, 4 shadow bits 0-15, 5 region IDs 0-255; tileId 0 clears; find valid IDs with get_project_context detail "tileset"); "set_display_names" sets the player-visible displayName of several maps at once (entries whose map file is missing are reported in `skipped`, not errors); "organize_tree" re-parents maps in the editor tree (purely organizational, gameplay unaffected)…

Overwrite an ENTIRE tile layer of a map with one tile ID, replacing whatever was painted there before — destructive and not undoable, the map file is written immediately. Returns a confirmation with the map ID and layer filled. Fails with an error if the map does not exist or the layer index is out of range. Useful for laying base terrain before placing details; use tileId 0 to clear a layer. To inspect the result, call render_map_ascii.

Create a new map file (next free map ID, registered in MapInfos.json; both files written immediately). `mode` selects the generator: "blank" makes an empty map you paint later (edit_map fill_layer); "themed" generates a simple tile layout for a theme using the tileset's real tiles; "procedural" is the full generator — for themes with matching RTP reference templates (town, dungeon, interior, castle, world, etc.) it CLONES a hand-authored template from the 106 bundled maps (real 3D buildings, walls, furniture), auto-picking the closest size; for themes without templates (beach, swamp, etc.) it …

Generate several procedural maps in one call (same engine as generate_map_v3); each spec creates a new map file written to disk immediately. Returns an array of results with each map's key, mapId, and seed — use those mapIds with connect_maps to link them into a world. Fails with an error if any spec has an unknown theme; maps generated before the failure remain on disk. Prefer this over repeated generate_map_v3 calls when building a multi-map area.

Procedurally generate a complete map (terrain via Perlin noise / BSP dungeons / cellular-automata caves depending on theme) and write it to a new data/MapNNN.json plus MapInfos.json immediately. By default also places themed events (NPCs, chests, bosses, transfers). Returns {mapId, seed, width, height, eventCount}; save the seed to regenerate the identical map later. Fails with an error if the theme is unknown or files cannot be written. This is the most capable map generator — prefer it over create_map for playable content; use generate_map_batch to create several connected maps in one call.

Read-only: fetch a single actor object from data/Actors.json by its numeric ID. Returns the full actor (name, classId, equips, traits, etc.) or null if the ID is out of range or was deleted. Prefer this over get_actors when you already know the ID, to keep responses small.

Read-only: list every actor (playable character) defined in the project's data/Actors.json. Returns an array of full actor objects (null placeholder entries are filtered out); returns an empty array if no actors exist. Use this to discover actor IDs before calling get_actor, update_actor, or delete_actor; use search_actors if you only know part of a name.

Read-only: fetch one animation from data/Animations.json by ID, including its frame and timing data. Returns the animation object, or null if the ID is out of range. Prefer this over get_animations when you know the ID and want details like frame count.

Read-only: list every battle/skill animation from data/Animations.json (id, name, source image, frames, timings). Returns an array of animation objects; empty array if none. Use this to pick valid animationId values for skills, items, and events — this server cannot create new animations, so choose from the existing ones.

Read-only: list all armors from data/Armors.json (shields, headgear, body armor, accessories). Returns an array of full armor objects; empty array if none. Use search_items with type "armor" to filter by name instead of listing everything.

Read-only: fetch one class from data/Classes.json by ID, including its parameter curves, EXP formula, skill learnings, and traits. Returns the class object, or null if the ID is out of range or deleted. Prefer this over get_classes when you know the ID.

Read-only: list every class from data/Classes.json (stat growth curves, learnable skills, traits). Returns an array of full class objects; empty array if none. Use get_class for one entry or search_classes to find an ID by name.

Read-only: list every common event from data/CommonEvents.json (reusable command sequences callable from any event, or auto-running via a switch). Returns an array of full common event objects including their command lists; empty array if none. Use this to find IDs before update_common_event or add_common_event_command.

Read-only: list every enemy from data/Enemies.json (stats, drops, action patterns, traits). Returns an array of full enemy objects; empty array if none. Use get_enemy for one entry or search_enemies to find an ID by name. Note: enemies appear in battle only through troops (see get_troops).

Read-only: fetch one enemy from data/Enemies.json by ID, including stats, EXP/gold rewards, drop items, and action patterns. Returns the enemy object, or null if the ID is out of range or deleted. Prefer this over get_enemies when you know the ID.

Read-only: return just the game title string from System.json (the name shown on the title screen and window bar). Lighter than get_system when the title is all you need.

Read-only: list all consumable items from data/Items.json (potions, keys, quest items — not weapons or armors). Returns an array of full item objects; empty array if none. Use get_weapons / get_armors for equipment, or search_items to filter by name.

Read-only: load a complete map file (data/MapNNN.json) by ID: dimensions, tileset, the full tile data array (width × height × 6 layers), all events, encounter lists, and BGM settings. Returns the full map object — this can be large for big maps; if you only need events use get_map_events, and for a visual overview use render_map_ascii. Fails with an error if the map file does not exist.

Read-only: fetch a single event from a map by event ID, including all its pages, conditions, graphics, and command lists. Returns the event object, or null if the event ID does not exist on that map. Fails with an error if the map file itself does not exist. Use get_map_events to discover event IDs first.

Read-only: list all events on one map (NPCs, chests, doors, triggers) without the tile data, keeping the response small. Returns an array of event objects with id, name, x, y, and pages. Fails with an error if the map file does not exist. Use get_map_event for a single event, or search_map_events to find events by name.

Read-only: list the project's map tree from data/MapInfos.json — every map's id, name, parentId (folder structure), and editor ordering, but NOT tile or event data. Returns an array of map info objects. Use this to discover map IDs; then call get_map for a specific map's full contents.

Read-only: pre-digested project knowledge — CALL THIS FIRST in a session. `detail` selects the depth: "full" (default) returns id+name lists for every database, switch/variable names, starting position, and available sprite filenames per img/ folder — everything needed to create content without inventing broken references; "summary" is a cheap health check (entry counts per data file); "assets" scans img/ and Tilesets.json into a complete index (sheet dimensions, autotile kinds, categorized usable tiles, all PNG names); "tileset" returns the categorized usable tile IDs of ONE tileset (ground/w…

Read-only: return lightweight statistics about the current project — game title plus entry counts per database (actors, items, skills, maps, etc.). Returns a small summary object. Use this for a quick health check; use get_project_context when you need actual IDs and names to work with.

Read-only: fetch one skill object from data/Skills.json by its numeric ID, including damage formula, MP/TP cost, scope, and effects. Returns null (not an error) if the ID is out of range or the skill was deleted, so check the result before using it. Prefer this over get_skills when you know the ID; use search_skills to find an ID by name.

Read-only: list all skills from data/Skills.json (attack skills, magic, abilities usable by actors and enemies). Returns an array of full skill objects; empty array if none. Use get_skill when you already know the ID, or search_skills to filter by name or description.

Read-only: fetch one state from data/States.json by ID, including restriction, duration, removal conditions, and traits. Returns the state object, or null if the ID is out of range or deleted. Note: state 1 is the engine's KO/Death state — avoid repurposing it.

Read-only: list every state (status condition: poison, sleep, KO, buffs) from data/States.json. Returns an array of full state objects; empty array if none. Use get_state for one entry or search_states to find an ID by name. State IDs are referenced by skills (effect code 21) and traits.

Read-only: list all game switch names from System.json as an array indexed by switch ID (index 0 is unused; unnamed switches are empty strings). Switches are the project's global boolean flags used in event conditions. Use this to find a free or existing switch ID before set_switch_name, create_common_event, or create_puzzle_switch.

Read-only: return the entire data/System.json — game title, starting party and position, switch/variable name lists, vehicle settings, terms, sounds, and more. The response can be large; prefer the focused tools (get_switches, get_variables, get_game_title) when you need just one piece. Returns the full system object.

Read-only: return the usable tile IDs of ONE tileset, organized by category (ground, water, wallSide, wallTop, roof, decoration); each entry has the tileId, autotile kind index, and a short description. Use the returned IDs with fill_map_layer or manual tile edits — guessing tile IDs produces glitched maps. Fails with an error if the tileset ID does not exist. For all tilesets at once plus image listings, use scan_project_assets.

Read-only: fetch one tileset from data/Tilesets.json by ID, including its tilesetNames (image files from img/tilesets/), mode, and the flags array encoding passability per tile. Returns the tileset object, or null if the ID is out of range. For categorized, ready-to-use tile IDs prefer get_tile_ids_for_tileset.

Read-only: list every tileset configuration from data/Tilesets.json (which image sheets each map style uses, plus per-tile passability/terrain flags). Returns an array of full tileset objects; empty array if none. Use get_tileset for one entry, or scan_project_assets / get_tile_ids_for_tileset for a digested view of usable tile IDs.

Read-only: fetch one troop from data/Troops.json by ID, including its enemy members with screen positions and any battle event pages. Returns the troop object, or null if the ID is out of range or deleted. Prefer this over get_troops when you know the ID.

Read-only: list every troop (enemy formation used in battles) from data/Troops.json, including member enemy IDs/positions and battle event pages. Returns an array of full troop objects; empty array if none. Troop IDs are what battle commands and create_boss_event reference — enemies alone never appear in battle.

Read-only: list all game variable names from System.json as an array indexed by variable ID (index 0 is unused; unnamed variables are empty strings). Variables are the project's global numeric values used in event logic. Use this to find a free or existing variable ID before set_variable_name or event commands that reference variables.

Read-only: list all weapons from data/Weapons.json. Returns an array of full weapon objects including params (stat bonuses) and traits; empty array if none. Use search_items with type "weapon" to filter by name instead of listing everything.

Insert a complete event-command fragment into a map event page, common event, or troop battle page. Validates the fragment, insertion boundary, resulting list, and supported references before writing. Invalid data refuses the write. Omit position to append before the root end marker; an explicit position must be a safe command boundary (not inside a text continuation or between a block header and its branches). Fragments are rebased to the target indentation. dryRun:true validates and previews without writing or creating backups. Normal writes use the existing atomic backup-protected project w…

Create, change or remove map events; the map file is written immediately. action "create" without `preset` makes a bare event at x/y (empty page unless `pages`; then use add_command or insert_event_commands). With `preset` it builds a ready event: "npc" {name, dialogues[], characterName?, characterIndex?}; "chest" one-time loot {items: [{type item|weapon|armor, id, amount}]}; "teleport" walk-on transfer {destMapId, destX, destY, trigger?}; "door" action-button warp {destMapId, destX, destY, characterName?, characterIndex?, trigger?, lockedSwitchId?, lockedMessage?}, locked until that switch is…

Project-wide settings in data/System.json (writes are immediate), project lifecycle, and the live playtest bridge. action "get" returns `section`: "full" (large), "switches"/"variables" (names by ID; empty means free) or "title". "set_title" sets the game title. "name_switch"/"name_variable" label one by ID (names only). "resize_list" {section, size} sets the highest valid switch/variable id (MV ignores ids past it, silently). "list_backups" {file?} and "restore_backup" {file, backup?} list and restore the copies kept in .mcp-backups before every write; the newest undoes the last write. "set_s…

Re-parent maps in the editor's map tree by setting each map's parentId in MapInfos.json (written to disk immediately). Purely organizational — gameplay, transfers, and tile data are unaffected. Returns the updated tree entries. Map IDs that do not exist are skipped and reported. Tip: a map used as a folder is just a normal map; create one with create_map first if needed.

Bulk-add several events of one kind (npc, chest, or boss) to an existing map at automatically chosen walkable positions; the map file is written to disk immediately. Returns the list of created events with their IDs and positions. Fails with an error if the map does not exist or the eventType is unknown. Use the individual helpers (create_npc, create_chest, create_boss_event) when you need exact positions and contents.

Read-only: query any RPG Maker MV database (data/*.json). Three forms depending on arguments: no id/query lists every non-null entry of the entity; `id` fetches one entry (returns null, not an error, if it does not exist); `query` does a case-insensitive name search (items/weapons/armors/skills also match descriptions). Returns an array (list/search) or a single object/null (id). Use this to discover valid IDs before create/update/delete or before wiring references (class learnings, troop members, chest loot). For maps use query_map; for a digest of everything at once use get_project_context.

Read-only: inspect maps. `view` selects what you get: "infos" lists the map tree from MapInfos.json (ids, names, folder parentIds — no mapId needed); "full" returns one complete MapNNN.json (dimensions, 6-layer tile data, events — can be large); "events" lists a map's events (with `query`, filters by name, case-insensitive); "event" returns one event by eventId (null if absent); "validate" lints a map (invalid tile IDs per layer, missing page terminators, transfers to map 0, Self Switch OFF where ON was likely meant) returning {issueCount, issues[]}; "ascii" renders the map as a character grid…

Read-only utility: split a screenshot you provide as base64 PNG into 4 quadrants and return each quadrant's average RGB color — a cheap, offline way to sanity-check what is roughly on screen (e.g. mostly green = grass, mostly black = unlit). Returns {imageWidth, imageHeight, quadrants: {top-left|top-right|bottom-left|bottom-right: {r, g, b}}}. No files written, no network. For real content understanding use analyze_screenshot (requires a vision API); for precise map layout use render_map_ascii.

Start or stop recording the live RPG Maker MV playtest canvas through the authenticated MCP bridge. `action:"start"` begins a silent WebM capture inside the game runtime; `action:"stop"` saves it under `.mcp-cache/recordings/` and returns `{path, bytes, mimeType, durationMs, name}`. This captures only the game canvas, not the desktop or credentials. Requires the bridge plugin, a running bridge, and a connected playtest. Optional `name`, `fps` (default 30), and `bitrateKbps` (default 2500) control the artifact.

Read-only: render a map as an ASCII grid entirely offline — one character per tile (~ water, # wall, " bush, etc., with a legend) plus event positions marked by the first letter of their names. Returns {mapId, width, height, ascii, legend, events[], regionAscii?}. Use this to "see" a map's layout, verify generated terrain, or pick coordinates for events without any screenshot or API; it is the precise companion to validate_map. Fails with an error if the map does not exist; returns an error field if the map has no tile data.

Play the game headless from a script of steps and report what happened: does the door transfer, does the NPC say the right line, does the choice branch, is a tile blocked. Boots the project in Chromium with the real engine; no editor or running game needed, and project data is never changed (screenshots go to .mcp-cache/renders/). Steps by action: load {mapId,x,y,direction?,party?,level?,gold?,switches?,variables?,selfSwitches?,items?,equip?,encounters?} starts a fresh game there; startEvent {eventId} runs a map event until it shows text or goes idle; advanceText {maxMs?} presses OK until idle…

Read-only: scan the project's img/ folders and Tilesets.json to build a complete asset index — per-tileset sheet metadata (dimensions, tile counts, autotile kinds) with categorized usable tiles (ground, water, wallSide, wallTop, roof, decoration), plus every PNG filename per img/ subdirectory. Returns one large structured index object. Run it before map creation so create_map/generate_map_v3 themes can pick real tiles; for a single tileset, get_tile_ids_for_tileset is lighter.

Read-only: case-insensitive substring search over actor names and nicknames in data/Actors.json. Returns an array of matching actor objects (empty array if nothing matches — not an error). Use this when you know a name fragment but not the ID; use get_actors to list everything.

Read-only: case-insensitive substring search over class names in data/Classes.json. Returns an array of matching class objects; empty array if nothing matches. Use this to find a class ID by name; use get_classes for the full list.

Read-only: case-insensitive substring search over enemy names in data/Enemies.json. Returns an array of matching enemy objects; empty array if nothing matches. Use this to find an enemy ID by name; use get_enemies for the full list.

Read-only: case-insensitive substring search over names and descriptions in one equipment database (items, weapons, or armors — chosen by `type`, default "item"). Returns an array of matching objects; empty array if nothing matches. Use this to find IDs by name; use the get_items / get_weapons / get_armors tools to list a full database.

Read-only: case-insensitive substring search over event names on one map. Returns an array of matching event objects with their IDs and positions; empty array if nothing matches. Fails with an error if the map does not exist. Use this to locate an event for update_map_event or delete_map_event without dumping the whole map.

Read-only: case-insensitive substring search over skill names and descriptions in data/Skills.json. Returns an array of matching skill objects; empty array if nothing matches. Use this to find a skill ID by name; use get_skills for the full list or get_skill when you know the ID.

Read-only: case-insensitive substring search over state names in data/States.json. Returns an array of matching state objects; empty array if nothing matches. Use this to find a state ID by name before create_state_skill or skill effects.

Set the player-visible display name of several maps in one call (the name briefly shown on screen when entering a map). Each affected map file is written to disk immediately. Returns a summary of updated maps. Maps that do not exist are reported as errors in the result. Use update_map_event/organize_map_tree for other map metadata; this only touches displayName.

Switch this server to a DIFFERENT RPG Maker MV project directory for all subsequent tool calls (session-wide side effect; persists until changed again or the server restarts). Validates that the path contains data/System.json and fails with an error otherwise, leaving the previous project active. Returns the new active path. Without this tool, the RPGMAKER_PROJECT_PATH environment variable set at startup applies.

Rename a game switch in System.json (written to disk immediately). This is documentation only — it does not change any event logic or the switch's runtime value, but good names keep event conditions understandable. Returns the updated switch list entry. Fails with an error if the ID is out of the switch array's range.

Rename a game variable in System.json (written to disk immediately). This is documentation only — it does not change any event logic or the variable's runtime value. Returns the updated variable list entry. Fails with an error if the ID is out of the variable array's range.

Capture the current RPG Maker MV playtest frame through the authenticated MCP bridge and save it as a PNG under `.mcp-cache/screenshots/`. Returns `{path, bytes, mimeType, name}` and the PNG itself as an image block (up to 1.5 MB; RPGMV_INLINE_IMAGES=0 turns that off), so you can look at it. Requires `manage_system` actions `install_bridge_plugin`, `bridge_start`, and `playtest` first. Optional `name` becomes a safe filename prefix; each capture keeps a timestamp. `manage_system {action:"bridge_screenshot"}` remains available as a compatibility alias.

Partially update an existing actor in data/Actors.json: only the keys present in `fields` are overwritten, all other properties are preserved. The file is written to disk immediately and there is no undo, so read the actor first (get_actor) if you need to restore values later. Returns the full actor object after the update. Fails with an error if no actor exists with the given ID.

Partially update an existing class in data/Classes.json: only the keys present in `fields` are overwritten (note: passing `learnings` or `traits` replaces the whole array, it does not merge). The file is written to disk immediately; no undo. Returns the full class object after the update. Fails with an error if the class ID does not exist.

Partially update an existing common event in data/CommonEvents.json: only the keys present in `fields` are overwritten (passing `list` replaces the whole command list). Written to disk immediately; no undo. Returns the full common event after the update. Fails with an error if the ID does not exist. To append a single command instead of replacing the list, use add_common_event_command.

Partially update an existing database entry: only the keys in `fields` are overwritten (arrays like traits/learnings/actions are replaced wholesale, not merged); the data file is written immediately and there is no undo, so fetch current values with query_database first if you may revert. Returns the full entry after the update. Fails with an error if the ID does not exist. Special append forms that do not need `fields`: common_events + `appendCommand` inserts one event command before the list terminator; troops + `addEnemyId` adds a member at an auto-computed battle position; troops + `addPag…

Partially update an existing enemy in data/Enemies.json: only the keys present in `fields` are overwritten (array fields like actions and dropItems are replaced wholesale, not merged). Written to disk immediately; no undo. Returns the full enemy object after the update. Fails with an error if the enemy ID does not exist.

Change the game title in System.json (written to disk immediately); this is what appears on the title screen and the game window. Returns the new title. Other System.json fields are untouched — use update_starting_position for the start location.

Partially update an existing item, weapon, or armor: only the keys present in `fields` are overwritten. Writes the corresponding data file (Items.json, Weapons.json, or Armors.json) to disk immediately; there is no undo. Returns the full object after the update. Fails with an error if no entry exists with the given ID and type. The `type` argument selects which database file is modified — passing the wrong type updates the wrong entry or fails.

Partially update an existing map event: only the keys present in `fields` are overwritten (e.g. move it by setting x/y, rename it, or replace its pages). The map file is written to disk immediately; replacing `pages` discards the old pages entirely, so fetch them first with get_map_event if you need to merge. Returns the full event object after the update. Fails with an error if the map or event does not exist.

Partially update an existing skill in data/Skills.json: only the keys present in `fields` are overwritten, everything else is preserved. The file is written to disk immediately; there is no undo, so fetch the current values with get_skill first if you may need to revert. Returns the full skill object after the update. Fails with an error ("Skill with ID N not found") if the ID does not exist or was deleted.

Set where a new game begins: the player's starting map and tile coordinates in System.json (written to disk immediately). Returns the new starting position. The map ID and coordinates are NOT validated against existing maps, so verify with get_map_infos first — a bad value makes new games start in a void. Does not affect saved games.

Partially update an existing state in data/States.json: only the keys present in `fields` are overwritten (the traits array is replaced wholesale). Written to disk immediately; no undo. Returns the full state object after the update. Fails with an error if the state ID does not exist. Be careful editing state 1 (KO) — the engine depends on it.

Partially update a tileset in data/Tilesets.json: only the keys present in `fields` are overwritten (e.g. swap an image in tilesetNames or adjust flags). Written to disk immediately; no undo. CAUTION: every map using this tileset is visually affected, and malformed flags break passability project-wide — read the current object with get_tileset first. Returns the full tileset object after the update. Fails with an error if the tileset ID does not exist.

Read-only: lint one map for common defects — tile IDs out of range per layer, shadow/region values out of bounds, event pages missing their terminator command, Change Item with null item, Transfer Player to map 0, and Self Switches set OFF where ON was likely intended. Returns {mapId, eventCount, issueCount, issues: [{type, message, ...locators}]}; issueCount 0 means clean. Fails with an error if the map does not exist. Run this after generating or hand-editing maps, before testing in the engine.