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.

Regola quanto costa in banda un attore replicato: dormancy, frequenza di aggiornamento, priorità e relevancy. ue_set_replication decide se replicare, questo decide con che intensità.

Solo i parametri passati vengono toccati, gli altri restano come sono.

Args: blueprint_path: Blueprint Actor da configurare. dormancy: "awake" | "initial" | "dormant_all" | "dormant_partial" | "never". "initial" è la scelta giusta per attori di scena che non cambiano mai dopo lo spawn: smettono di consumare banda finché non li si risveglia. net_update_frequency: aggiornamenti al secondo quando è rilevante (default UE 100). min_net_update_frequency: minimo a cui l'engine può scendere (default UE 2). net_priority: peso relativo nella coda di replication (default UE 1.0). net_cull_distance: distanza in cm oltre la quale il client smette di riceverlo (default UE 15000). Scritta come quadrato, che è come Unreal la memorizza. only_relevant_to_owner: replica solo al client che lo possiede. net_use_owner_relevancy: eredita la relevancy dall'owner. net_load_on_client: se False l'attore non viene creato sui client al caricamento del livello.

Stato di rete completo di un Blueprint: replication, dormancy, frequenze, priorità, relevancy e quali componenti replicano.

Attiva la replication di un singolo componente di un Blueprint.

Un attore replicato non replica automaticamente i suoi componenti: le proprietà di un componente arrivano ai client solo se il componente è marcato come replicato.

Args: blueprint_path: Blueprint che contiene il componente. component_name: nome come si vede nell'editor (il suffisso _GEN_VARIABLE dei template è gestito da solo). replicates: True per attivare.

Scrive una proprietà sul template di un componente di un Blueprint, non su un'istanza piazzata nel livello.

È la via per le proprietà EditDefaultsOnly, che Unreal rifiuta di scrivere su un attore spawnato ("cannot be edited on instances") — per esempio SensesConfig di un AIPerceptionComponent. Per gli attori già nel livello usa invece ue_set_actor_property.

Args: blueprint_path: Blueprint che contiene il componente. component_name: nome come si vede nell'editor. property_name: nome della proprietà (snake_case o PascalCase secondo quanto accetta la classe). value: valore JSON; dict con x/y/z, pitch/yaw/roll o r/g/b vengono convertiti nei tipi Unreal corrispondenti, e i path /Game/... vengono caricati come asset.

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".

Elenca le classi (native e Blueprint) derivate da una classe base, base inclusa.

Copre il caso "che sottoclassi di Character esistono nel progetto?" o "elencami le luci disponibili": la Blueprint del progetto compare col suo nome generato (es. "BP_PlayerCharacter_C").

Args: parent: nome esposto ai binding Python (es. "Character", "Actor") o percorso completo (es. "/Script/Engine.Light", "/Game/.../BP_Nemico.BP_Nemico_C"). name_contains: filtro case-insensitive sul nome, opzionale. limit: massimo numero di risultati.

Elenca gli struct derivati da uno struct base, base incluso.

Args: parent: nome esposto ai binding Python (es. "Vector") o percorso completo (es. "/Script/CoreUObject.Vector"). name_contains: filtro case-insensitive sul nome, opzionale. limit: massimo numero di risultati.

Elenca nome, valore numerico e display name di un enum nativo del motore.

Il nome va passato senza il prefisso "E" delle UENUM C++: "CollisionChannel", non "ECollisionChannel". Non copre gli enum definiti come Blueprint asset (UserDefinedEnum in /Game/...): quelli non hanno un binding Python generato, vanno letti con ue_exec_python e unreal.load_asset(path).

Args: enum_name: es. "CollisionChannel", "ObjectTypeQuery".

Crea un asset Widget Blueprint (UMG) vuoto.

L'albero nasce senza radice, e WidgetTree.RootWidget non è scrivibile da Python: per costruire un layout con i tool ue_umg_* parti invece da ue_duplicate_asset di un Widget Blueprint che una radice ce l'ha già, e svuotalo con ue_umg_remove_widget. Questo tool va bene quando la radice la metti a mano nel Widget Designer, o quando il Widget Blueprint serve solo come asset da riempire dopo.

Args: package_path: es. "/Game/UI". name: es. "WBP_MainMenu". parent_class: nome esposto ai binding Python (es. "UserWidget") o percorso completo di una classe C++ del progetto, per la via BindWidget. editor_utility: True per un Editor Utility Widget (tool per l'editor, non per il gioco) invece di un Widget Blueprint normale.

La gerarchia dei widget di un Widget Blueprint: nomi, classi, figli e tipo di slot.

root: null vuol dire albero vuoto — lì non si può aggiungere niente finché non c'è una radice.

Crea un widget e lo mette sotto un pannello dell'albero.

Args: widget_blueprint_path: es. "/Game/UI/WBP_MainMenu". widget_class: "TextBlock", "Button", "Image", "VerticalBox", "HorizontalBox", "CanvasPanel", "Overlay", "Border", "ProgressBar"… parent: nome del pannello che lo conterrà; se omesso, la radice. Dev'essere un PanelWidget: un TextBlock non può contenere nulla. name: nome del widget, quello che si vedrà in Hierarchy e che serve per BindWidget da C++. Se omesso lo sceglie Unreal. slot: layout dentro il pannello, applicato subito — le stesse chiavi di ue_umg_set_slot.

Imposta proprietà su un widget: testo, colore, visibilità, immagine.

Le proprietà di testo sono FText nel motore: passa una stringa normale, la conversione è automatica. I dict con x/y/z, pitch/yaw/roll o r/g/b diventano i tipi Unreal corrispondenti, e i path "/Game/..." vengono caricati come asset.

Restituisce applied e failed separati: una proprietà sbagliata non fa fallire le altre.

Imposta il layout di un widget dentro il suo pannello.

Le chiavi valide dipendono dal pannello che lo contiene, e ue_umg_tree_info riporta slot_class per saperlo:

• CanvasPanelSlot: position [x, y], size [x, y], z_order, alignment, auto_size.

• VerticalBoxSlot / HorizontalBoxSlot: padding (numero singolo, o [left, top, right, bottom], o {"left":…}), horizontal_alignment, vertical_alignment.

Le liste di 2 numeri diventano Vector2D, quelle di 4 un Margin.

Toglie un widget dall'albero, con tutto quello che contiene.

La radice non si può togliere (RootWidget non è scrivibile): per svuotare un albero, rimuovi i figli della radice.

Elenca i grafi di un Blueprint (EventGraph, UserConstructionScript, funzioni...).

Args: blueprint_path: es. "/Game/MyGame/BP_Player".

Elenca gli eventi visibili su un Blueprint: custom, ereditati overridabili, di interfaccia.

is_implemented dice se esiste già un nodo per quell'evento nel grafo.

Args: blueprint_path: es. "/Game/MyGame/BP_Player".

Aggiunge (o ritrova) il nodo di un evento ereditato overridabile nell'event graph.

Restituisce il path del nodo e i suoi pin — l'unico modo per riferirsi a quel nodo in seguito con ue_bp_connect_pins, dato che il grafo non elenca i propri nodi via Python.

Args: blueprint_path: es. "/Game/MyGame/BP_Player". event_name: nome dell'evento ereditato, es. "ReceiveBeginPlay", "ReceiveTick", "ReceiveEndPlay". Vedi ue_bp_list_events per i nomi disponibili su questo Blueprint. x: posizione orizzontale del nodo nel grafo (solo visuale). y: posizione verticale del nodo nel grafo (solo visuale).

Crea un grafo funzione vuoto (nodi Entry/Return di default).

I nodi interni non sono raggiungibili da qui: il corpo va scritto a mano nel Blueprint Editor, o lasciato vuoto come slot da riempire in seguito.

Args: blueprint_path: es. "/Game/MyGame/BP_Player". func_name: es. "ApriPorta".

Nodi, pin, connessioni ed errori di compilazione di un grafo Blueprint.

È il punto di partenza: dà i nomi oggetto dei nodi da usare in tutti gli altri tool, e errors/warnings dicono se il grafo compila.

Args: blueprint_path: es. "/Game/MyGame/BP_Player". graph_name: nome oggetto del grafo ("EventGraph", "UserConstructionScript", o il nome di una funzione), non il titolo tradotto. ue_bp_list_graphs li elenca.

Aggiunge un nodo di chiamata a funzione e restituisce i suoi pin.

Args: blueprint_path: Blueprint da modificare. function_path: "/Script/.:", per esempio "/Script/Engine.KismetSystemLibrary:PrintString" o "/Script/Engine.GameplayStatics:GetPlayerPawn". graph_name: grafo di destinazione. position: {"x": .., "y": ..} o [x, y], solo estetica.

Aggiunge un nodo Branch (if/then/else): pin Condition in ingresso, then e else in uscita.

Aggiunge un Custom Event. Solo nei grafi evento: una funzione non può contenerne.

Aggiunge un nodo Get o Set per una variabile membro.

La variabile dev'essere già stata creata con ue_add_variable.

Args: blueprint_path: Blueprint da modificare. variable_name: nome della variabile. mode: "get" o "set". graph_name: grafo di destinazione. position: {"x": .., "y": ..} o [x, y]. class_path: per leggere una variabile di un'altra classe; vuoto = questo Blueprint.

Aggiunge un nodo qualunque dalla palette, per "Categoria|Nome".

Ultima spiaggia per i nodi che non hanno un tool dedicato. I nomi sono localizzati come l'editor: su un editor italiano il Branch è "Utilità|ControlloDiFlusso|Ramo", non "Utilities|FlowControl|Branch". Cerca la stringa esatta con ue_bp_list_palette prima di chiamare questo, o usa i tool tipizzati che non hanno il problema.

Cerca fra i nodi aggiungibili a un grafo, filtrando per sottostringa.

La palette completa ha migliaia di voci e segue la lingua dell'editor: filtrare è l'unico modo pratico di trovare il nome esatto da passare a ue_bp_add_node_by_name.

Args: blueprint_path: Blueprint di riferimento. graph_name: grafo di cui si vuole la palette. contains: sottostringa da cercare, senza distinzione di maiuscole. limit: quante corrispondenze restituire.

Collega un pin di uscita di un nodo a un pin di ingresso di un altro.

Args: blueprint_path: Blueprint da modificare. from_node: nome oggetto del nodo di partenza, o event:<NomeMembro> (es. "event:ReceiveBeginPlay") per un nodo evento. from_pin: pin di uscita, es. "then" per il filo di esecuzione. to_node: nome oggetto del nodo di arrivo. to_pin: pin di ingresso, es. "execute". graph_name: grafo su cui lavorare.

Se i tipi non sono compatibili il tool lo dice, riportando i due tipi invece di fallire in silenzio.

Stacca tutti i collegamenti di un pin, e riporta quanti erano.

Scrive il valore letterale di un pin di ingresso non collegato.

Unreal non valida il valore: verificato dal vivo che scrivere "non_un_bool" su un pin booleano viene accettato e memorizzato così com'è. Per questo il tool rilegge sempre il pin dopo la scrittura e restituisce il valore vero — controllalo, invece di fidarti del successo.

Cancella un nodo dal grafo, con tutti i suoi collegamenti.