Elenca le installazioni di Unreal Engine trovate sulla macchina.

Cerca in: variabile UE_MCP_ENGINE_DIRS, elenco dell'Epic Games Launcher, registro di Windows. Da chiamare per prima quando non c'è ancora un progetto.

Elenca i template ufficiali disponibili nell'installazione (TP_Blank, TP_ThirdPerson, ...).

Crea un progetto Unreal da specifica, pronto per il bridge MCP.

Scrive .uproject (con PythonScriptPlugin, RemoteControl e Metasound già abilitati), Config/DefaultEngine.ini con l'autostart del web server Remote Control, Config/DefaultGame.ini e Content/Python/init_unreal.py.

Args: name: nome progetto (identificatore valido, es. "MyGame"). directory: cartella genitore, es. "C:/UnrealProjects". engine_version: es. "5.4"; se omesso usa la più recente installata. template: "blank" (generato da zero) o il nome di un template del motore (vedi ue_engine_templates), es. "TP_ThirdPerson". blueprint_only: esclude la cartella Source del template (niente compilazione C++). plugins: plugin extra da abilitare oltre a quelli di default. default_map: mappa di avvio, es. "/Game/MyGame/Levels/L_Main". default_game_mode: GameMode di default (path della classe ..._C). force: procede anche se la cartella di destinazione esiste già. engine_root: percorso del motore, quando la ricerca automatica non lo trova (es. "C:/Program Files/Epic Games/UE_5.8").

Cerca file .uproject sotto una cartella.

Legge un .uproject: versione motore associata, plugin attivi e se il bridge è pronto.

Abilita/disabilita plugin scrivendo nel .uproject (utile su progetti esistenti).

Per usare il bridge servono almeno PythonScriptPlugin e RemoteControl. L'editor va riavviato se era già aperto.

Apre un progetto nell'editor e attende che il bridge risponda.

L'attesa predefinita è breve di proposito: molti client MCP interrompono una richiesta dopo 60 secondi, e un wait_seconds più lungo faceva fallire la chiamata con "Request timed out" anche quando l'editor era partito benissimo. Se il bridge non è ancora pronto la risposta lo dice e basta richiamare ue_editor_status finché running diventa bridge_ready.

Args: uproject: percorso del file .uproject. engine_version: forza una versione del motore diversa da quella associata. wait_seconds: quanto attendere il bridge. Il primo avvio compila gli shader e può volerci molto di più: in quel caso non alzarlo oltre il timeout del client, si fa polling con ue_editor_status. extra_args: argomenti aggiuntivi per la riga di comando dell'editor. engine_root: percorso del motore, quando non è registrato nel sistema. skip_module_check: lancia anche se i moduli C++ non corrispondono al motore (l'editor resterà bloccato su una modale dietro allo splash).

Genera una classe C++ compilabile nel modulo del progetto.

È la risposta al limite principale di questo MCP: i grafi Blueprint non sono scrivibili da Python, ma la logica può stare in C++ e arrivare ai Blueprint per ereditarietà. Flusso completo:

ue_cpp_class_create -> ue_editor_close -> ue_build_start ->
ue_build_status (finché running=false) -> ue_editor_open ->
ue_reparent_blueprint

Se il progetto è Blueprint-only, il modulo C++ (Build.cs, Target.cs, IMPLEMENT_PRIMARY_GAME_MODULE, voce Modules nel .uproject) viene creato.

Args: uproject: percorso del file .uproject. class_name: nome senza prefisso, es. "DoorBase" -> ADoorBase. parent_class: "Actor", "Pawn", "Character", "ActorComponent", "GameModeBase", "PlayerState", ... module: nome del modulo C++; default il nome del progetto. properties: lista di dict con name, type (es. "float", "FVector", "TObjectPtr"), e opzionali category, default, replicated, rep_notify, read_only. Le proprietà replicate generano anche GetLifetimeReplicatedProps e i DOREPLIFETIME. functions: lista di dict con name, return_type, params, specifiers (default BlueprintCallable), body. Le funzioni BlueprintCallable diventano chiamabili dai grafi Blueprint. with_tick: abilita il Tick (di default è spento, come conviene). force: sovrascrive i file se esistono già.

Avvia la compilazione del modulo C++ del progetto (in background).

L'editor deve essere chiuso: con Live Coding attivo UnrealBuildTool si rifiuta di scrivere le DLL, e per un modulo nuovo Live Coding non è sufficiente. Sequenza tipica: ue_editor_close -> ue_build_start -> ue_build_status (finché running=false) -> ue_editor_open.

Args: uproject: percorso del file .uproject. engine_version: forza una versione del motore diversa da quella associata. target: default "Editor". configuration: "Development" | "DebugGame" | "Shipping". engine_root: percorso del motore, quando non è registrato nel sistema e la ricerca automatica non lo trova. force: avvia anche se risulta già una compilazione in corso. Serve solo quando la precedente è rimasta bloccata e ne hai chiuso i processi: due Build.bat insieme si accodano sullo stesso mutex.

Stato della compilazione avviata con ue_build_start: in corso, errori, coda del log.

Args: tail_lines: quante righe finali del log restituire. uproject: a quale progetto si riferisce; se omesso, l'ultima compilazione avviata. wait_seconds: se > 0 attende la fine della compilazione fino a questo limite, riportando l'avanzamento, invece di restituire subito. Una build completa dura minuti: meglio un'attesa sola che venti letture.

Ricompila il C++ senza chiudere l'editor, tramite Live Coding.

È la via veloce per iterare: nessuna chiusura, nessun riavvio, il gioco riparte con il codice nuovo. Funziona però solo sulle modifiche al corpo delle funzioni: aggiungere o cambiare UCLASS, UFUNCTION o UPROPERTY altera i dati di reflection e richiede ue_build_start a editor chiuso.

Args: max_wait_seconds: quanto attendere l'esito prima di restituire "in corso" (la compilazione prosegue comunque).

Crea il pacchetto giocabile del gioco (cook + build + stage + pak).

Produce un eseguibile autonomo, avviabile senza l'editor. Operazione lunga (decine di minuti al primo giro, molto meno dopo): parte in background, lo stato si consulta con ue_package_status.

L'editor deve essere chiuso. Sequenza: ue_editor_close -> ue_package_start -> ue_package_status (finché running=false).

Args: uproject: percorso del file .uproject. configuration: "Development" (con log e console, per il prototipo) o "Shipping" (ottimizzato, senza log, per la distribuzione). maps: mappe da cuocere, es. ["/Game/MyGame/Levels/L_Main"]. Se omesso cuoce secondo le impostazioni di progetto, che è più lento. output_dir: cartella di destinazione; default /Packaged. dedicated_server: produce anche un server dedicato per le partite LAN. engine_root: percorso del motore, se la ricerca automatica non lo trova. target_platform: "Win64" | "Linux" | "Mac"; default la piattaforma corrente.

Stato del packaging avviato con ue_package_start.

Riporta la fase corrente (Cook, Stage, Package, Archive), gli errori e, a fine corsa, il percorso dell'eseguibile prodotto.

Args: tail_lines: quante righe finali del log restituire. uproject: a quale progetto si riferisce; se omesso, l'ultimo packaging avviato. wait_seconds: se > 0 attende la fine del packaging fino a questo limite, riportando la fase corrente, invece di restituire subito.

Trova — e se vuoi termina — i processi che tengono occupato il lock di build.

Serve quando ue_build_status riporta blocked: gli script di Epic prendono un lock globale e un'istanza rimasta orfana non lo rilascia mai, quindi Build.bat aspetta all'infinito e ogni nuovo tentativo si accoda.

La ricerca è sulla riga di comando, non sul nome dell'immagine: su UE 5 UnrealBuildTool è un assembly .NET dentro dotnet.exe e gli script girano dentro cmd.exe, quindi nessuno dei due si trova con taskkill /IM UnrealBuildTool.exe — ed è il motivo per cui il lock sembra inestirpabile.

Args: dry_run: con True (default) elenca soltanto. La ricerca per riga di comando può intercettare un dotnet.exe che sta facendo altro: guarda l'elenco prima di terminarlo. engine_version, engine_root: quale motore, per sapere quale file di lock controllare (%TMP%\<percorso di Build.bat>.lock).

Stato del processo editor avviato da questo MCP e del bridge Remote Control.

Chiude l'editor.

Prima tenta la chiusura pulita (salvataggio + quit_editor via bridge); se fallisce o se force=True, termina il processo.

Args: save_all: salva livello e asset modificati prima di chiudere. force: salta il tentativo pulito e termina direttamente il processo.

Elenca i file già scaricati nella libreria locale (default: ~/UnrealAssetLibrary).

I percorsi restituiti si passano direttamente a ue_import_assets.

Scarica un file da un URL diretto (zip, glb, fbx, wav) nella libreria locale.

Se è un archivio zip/tar e extract=True, lo estrae subito.

Estrae un archivio zip/tar già presente sul disco (i .rar non sono supportati).

Cerca asset CC0 su Poly Haven.

Args: asset_type: "hdris" | "textures" | "models". categories: filtri, es. ["brick"], ["outdoor"]. limit: massimo di risultati.

Scarica un asset Poly Haven (CC0) nella libreria locale.

Args: asset_id: id dell'asset, es. "brick_wall_02". resolution: "1k" | "2k" | "4k" | "8k". formats: ["jpg"] per texture, ["gltf"] per modelli, ["hdr"] per HDRI. destination: cartella alternativa alla libreria.

Cerca materiali/HDRI/modelli CC0 su ambientCG.

Args: query: parole chiave, es. "concrete". asset_type: "Material" | "HDRI" | "3DModel" | "Decal" | "Atlas" | "Terrain".

Scarica ed estrae un asset ambientCG (CC0).

Args: asset_id: es. "PavingStones036". variant: es. "1K-JPG", "2K-JPG", "4K-PNG".

Scarica ed estrae un pack Kenney (CC0) risolvendo il link dalla pagina.

Args: slug: ultima parte dell'URL, es. "mini-characters-1" per kenney.nl/assets/mini-characters-1.

Elenca il contenuto Unreal acquistato sull'account Epic (Fab/Marketplace).

Non esiste un'API pubblica: serve il client community legendary (pip install legendary-gl + legendary auth). Senza di esso il tool spiega come procedere dall'Epic Games Launcher.

Scarica un asset del vault Epic tramite legendary.

Args: app_name: identificativo restituito da preset_fab_list_vault.

Verifica la connessione all'editor Unreal e restituisce versione motore, progetto aperto, livello corrente, numero di attori e trasporto in uso. Da usare per prima.

Legge la coda del log di Unreal: è il modo per vedere cosa è andato storto dopo un'operazione che non ha sollevato eccezioni.

Args: lines: quante righe finali restituire (default 80). only_errors: se True filtra solo righe con Error/Warning.

Esegue codice Python arbitrario dentro l'editor Unreal (escape hatch).

Il modulo unreal e tutti gli helper mcp_* sono disponibili. Assegna il valore da restituire alla variabile result.

Args: code: snippet Python, es. "result = len(mcp_actor_subsystem().get_all_level_actors())".

Salva il livello corrente e tutti gli asset modificati.

Importa file 3D/audio (.glb, .gltf, .fbx, .wav) nel Content Browser.

I .glb/.gltf passano dal framework Interchange nativo. Per i personaggi con scheletro usare .fbx con import_as_skeletal=True.

Args: files: percorsi assoluti sul disco (es. ["C:/Assets/Rocks/rock_01.glb"]). destination: cartella Unreal di destinazione (/Game/...). replace_existing: sovrascrive asset con lo stesso nome. import_as_skeletal: per .fbx, importa come Skeletal Mesh con animazioni.

Elenca gli asset presenti sotto un path del Content Browser.

Args: path: cartella Unreal (es. "/Game/MyGame"). recursive: include le sottocartelle. class_filter: filtro parziale sul nome classe (es. "Blueprint", "StaticMesh").

Elimina un asset o una cartella dal Content Browser.

Serve per rimediare a un import sbagliato senza aprire l'editor a mano. Di default rifiuta la cancellazione se qualcosa referenzia l'asset: cancellarlo comunque lascia riferimenti rotti nei livelli e nei Blueprint.

Args: path: es. "/Game/Imported/rock_01" oppure una cartella "/Game/Imported". force: cancella anche se referenziato.

Sposta o rinomina un asset aggiornando i riferimenti.

Args: path: percorso attuale, es. "/Game/Imported/SM_rock". new_path: percorso nuovo, es. "/Game/MyGame/Meshes/SM_Roccia".

Duplica un asset: la via rapida per crearne una variante da modificare.

Crea una cartella nel Content Browser. Idempotente.

Args: path: es. "/Game/MyGame/Meshes".

Aggancia un attore a un altro: muovendo il padre si muove il figlio.

È il modo in cui si compone una scena (le luci a un lampione, le casse su un pallet) invece di lasciare oggetti slegati da riposizionare uno per uno.

Args: child_label: label dell'attore da agganciare. parent_label: label dell'attore padre. socket: nome del socket sul padre, se ne ha. attach_rule: "KEEP_WORLD" (resta dov'è), "KEEP_RELATIVE" o "SNAP_TO_TARGET" (si allinea al padre).

Sgancia un attore dal suo padre.

Args: label: label dell'attore. keep_world: mantiene la posizione nel mondo invece di quella relativa.

Albero padre/figli degli attori del livello.

Args: label: se indicato, parte da quell'attore invece che dalle radici.

Crea un nuovo livello e lo apre.

Args: path: path completo del livello, es. "/Game/MyGame/Levels/L_Main". template: livello sorgente da duplicare (opzionale).

Apre un livello esistente nell'editor.

Args: path: es. "/Game/MyGame/Levels/L_Main".

Spawna un attore nel livello corrente.

Args: class_ref: "StaticMeshActor", "/Script/Engine.PointLight", "/Game/MyGame/BP_Enemy", oppure il path di uno StaticMesh importato (spawn diretto della mesh). location: [x, y, z] in cm. rotation: [pitch, yaw, roll] in gradi. scale: [x, y, z] moltiplicatore. label: etichetta leggibile nell'Outliner (usata dagli altri tool per ritrovarlo).

Elenca gli attori del livello corrente, con filtri opzionali su nome e classe.

Spawna molti attori in una sola chiamata e in una sola transazione undo.

Costruire un livello con ue_spawn_actor costa un round-trip HTTP per attore: per una scena di qualche decina di elementi conviene questo.

Args: actors: lista di dict con class_ref (obbligatorio) e, opzionali, location [x,y,z], rotation [pitch,yaw,roll], scale [x,y,z], label. Esempio: [{"class_ref": "PointLight", "location": [0,0,300]}].

Modifica posizione/rotazione/scala di un attore identificato dalla sua label.

Imposta proprietà su un attore già piazzato, o su un suo componente.

Copre tutto ciò che non sono i Class Defaults di un Blueprint: assegnare una mesh a uno StaticMeshActor, l'intensità di una luce, il raggio di un trigger. I valori seguono il JSON: un vettore è {"x":0,"y":0,"z":0}, un colore {"r":1,"g":0,"b":0}, e il path di un asset (/Game/...) viene caricato in automatico.

Args: label: etichetta dell'attore nell'Outliner. properties: mappa nome_proprieta -> valore. component: nome o classe del componente su cui scrivere (es. "StaticMeshComponent"); se omesso scrive sull'attore.

Elenca i componenti di un attore piazzato, con nome e classe.

Serve a sapere cosa passare come component a ue_set_actor_property.

Elimina dal livello corrente l'attore con la label indicata.

Crea un Blueprint.

Args: package_path: cartella, es. "/Game/MyGame/Blueprints". name: nome asset, es. "BP_CornerSlot". parent_class: "Actor", "Character", "Pawn", "GameModeBase", "PlayerState", "GameStateBase", "AIController" o un path completo.

Aggiunge un componente a un Blueprint e lo ricompila.

Args: blueprint_path: es. "/Game/MyGame/Blueprints/BP_Door". component_class: es. "StaticMeshComponent", "BoxComponent", "PointLightComponent". name: nome del componente nel Blueprint.

Aggiunge una variabile membro a un Blueprint e ricompila. Richiede UE 5.4+ (l'API Python per le variabili non esiste nei motori precedenti; ue_status riporta in capabilities cosa supporta il motore corrente).

Args: blueprint_path: path del Blueprint. var_name: nome variabile, es. "OccupiedBy". var_type: bool | int | int64 | float | string | name | text | struct | object | class. sub_type: per struct ("Vector", "Rotator", "Transform", "LinearColor") o per object/class il nome della classe ("Actor", "PlayerState"). replicated: marca la variabile come replicata (networking). instance_editable: esposta e modificabile sulle istanze nel livello. default_value: valore di default scritto nei Class Defaults (solo tipi semplici).

Imposta i Class Defaults (CDO) di un Blueprint.

Args: blueprint_path: path del Blueprint. properties: mappa nome_proprieta -> valore, es. {"replicates": true}.

Compila e salva un Blueprint. Usare dopo modifiche manuali nell'editor.

Riassegna il parent di un Blueprint, tipicamente a una classe C++.

È la via per dare logica eseguibile a un Blueprint: i grafi non sono scrivibili da Python, ma la logica può stare nella classe C++ padre (creata con ue_cpp_class_create) mentre il Blueprint resta il contenitore di componenti e valori.

Le variabili del Blueprint con lo stesso nome di una UPROPERTY del nuovo padre vengono assorbite; le altre sopravvivono rinominate con _0.

Args: blueprint_path: es. "/Game/MyGame/Blueprints/BP_Door". new_parent: nome o path della nuova classe padre, es. "ADoorBase" oppure "/Script/MyGame.DoorBase". remove_unused_variables: ripulisce le variabili rimaste orfane.

Crea un materiale collegando le texture ai canali PBR.

A differenza dei grafi Blueprint, il grafo materiale è pienamente scriptabile: qui i nodi vengono creati e collegati davvero.

Args: package_path: cartella, es. "/Game/MyGame/Materials". name: nome asset, es. "M_Brick". textures: mappa canale -> path della texture importata. Canali: base_color, normal, roughness, metallic, ambient_occlusion, emissive, opacity. Usa la chiave "auto" con il path per far dedurre il canale dal nome file (convenzioni ambientCG/Poly Haven). scalars: costanti sui canali senza texture, es. {"roughness": 0.4}. two_sided: disattiva il backface culling.

Crea una Material Instance da un materiale padre e ne imposta i parametri.

Variare un materiale via istanza non ricompila il grafo: è la via economica per avere molte varianti dello stesso materiale.

Args: package_path: cartella di destinazione. name: es. "MI_Brick_Red". parent_path: materiale padre, es. "/Game/MyGame/Materials/M_Brick". parameters: mappa nome -> valore. Numero = scalare, dict {"r","g","b"} = colore, bool = static switch, path /Game/... = texture.

Assegna un materiale a un attore piazzato.

Args: label: etichetta dell'attore nell'Outliner. material_path: es. "/Game/MyGame/Materials/M_Brick". slot: indice dello slot materiale sulla mesh. component: componente su cui scrivere; default il primo MeshComponent.

Esegue un comando della console dell'editor e restituisce ciò che stampa.

I comandi di console non restituiscono valori: scrivono nel log. Questo tool misura il log prima e dopo e riporta solo le righe nuove, altrimenti la risposta sarebbe "fatto" e nient'altro.

Utile per stat unit, r.ScreenPercentage 50, showflag.*, DumpConsoleCommands. Passa dall'interprete Python dell'editor, non dal gate bAllowConsoleCommandRemoteExecution della Remote Control API, che resta spento: da qui si può fare tutto quello che si fa dalla console, quit compreso.

Args: command: il comando, es. "stat fps". wait_seconds: quanto attendere che il motore scriva nel log.

Renderizza una Level Sequence con la Movie Render Queue, in background.

Gira in un processo UnrealEditor-Cmd headless, non nell'editor aperto: la MRQ in-editor è asincrona e terrebbe l'editor occupato per tutta la durata, senza un modo pulito di attenderla dal bridge. Come per le build, si avvia e si consulta ue_render_status.

Args: uproject: percorso del file .uproject. sequence: la Level Sequence, es. "/Game/Cinematics/LS_Intro". config: preset di Movie Pipeline salvato, es. "/Game/Cinematics/MRQ_Preset". È il modo di scegliere formato, risoluzione e cartella di uscita: senza, la MRQ usa le impostazioni predefinite del progetto e potrebbe non scrivere nulla. map_path: livello da caricare; default quello di avvio del progetto. output_dir: dove cercare i file prodotti; default /Saved/MovieRenders. resolution: [larghezza, altezza]; default [1920, 1080]. force: avvia anche se risulta già un render in corso.

Stato del render avviato con ue_render_sequence.

succeeded guarda i file prodotti, non il codice di uscita: la MRQ headless può chiudere con 0 senza aver scritto un fotogramma, se la config non aveva nodi di output.

Args: tail_lines: quante righe finali del log restituire. uproject: a quale progetto si riferisce; se omesso, l'ultimo render avviato. wait_seconds: se > 0 attende la fine fino a questo limite riportando l'avanzamento, invece di restituire subito.

Posizione e orientamento della camera della viewport dell'editor.

Da chiamare prima di spawnare: i livelli veri sono spesso costruiti a migliaia di unità dall'origine, e un attore messo a [0,0,0] finisce fuori campo, invisibile a chi guarda l'editor.

Sposta la camera della viewport.

Args: location: [x, y, z] in cm. rotation: [pitch, yaw, roll] in gradi.

Inquadra un attore con la camera, come il tasto F nell'editor.

È il complemento di ue_screenshot: senza, si fotografa quello che la camera stava già guardando, che di rado è quello appena costruito.

Args: label: attore da inquadrare; se omesso usa la selezione corrente. distance: distanza della camera in cm (default 500).

Cattura la viewport dell'editor e restituisce l'immagine all'agente.

Senza questo l'agente costruisce alla cieca: è l'unico modo per verificare davvero com'è venuta una scena invece di dedurlo dalle coordinate. Il file resta in /Saved/Screenshots/MCP.

La risoluzione predefinita è volutamente modesta: il PNG viaggia in base64 dentro la risposta, e a 1280x720 costa spesso più contesto di quanto l'immagine ne faccia risparmiare. Alzala quando serve leggere un dettaglio.

Args: filename: nome file; se omesso ne genera uno con il timestamp. width, height: risoluzione della cattura. return_image: se False restituisce solo il percorso, senza allegare il PNG.

Configura la replication di un Blueprint: se e come viene sincronizzato fra server e client in una partita in rete.

Configura il Play In Editor multi-client, per provare il multiplayer in locale.

Args: num_players: numero di finestre client (server incluso in listen_server). net_mode: "standalone" | "listen_server" | "client". one_process: True = più finestre nello stesso processo (più veloce da avviare).

Avvia il Play In Editor con le impostazioni correnti.

Ferma la sessione Play In Editor in corso.

Scrive un'impostazione nei file Config/Default.ini del progetto.

Args: section: es. "/Script/EngineSettings.GameMapsSettings". key: es. "GlobalDefaultGameMode". value: es. "/Game/MyGame/Blueprints/BP_MyGameMode.BP_MyGameMode_C". config: "Game" | "Engine" | "Input".

Nota: alcune impostazioni richiedono il riavvio dell'editor per avere effetto.

Importa file .wav come SoundWave nel Content Browser.

Crea un asset MetaSound Source vuoto (richiede il plugin MetaSound attivo).

Il grafo va poi popolato nell'editor MetaSound o via ue_exec_python.

Crea un Sound Cue, opzionalmente già collegato a un SoundWave importato.

Args: package_path: es. "/Game/MyGame/Audio". name: es. "SC_Explosion". wave_path: path del SoundWave, es. "/Game/MyGame/Audio/explosion".