Introduzione all’aggiunta di entità

Puoi aggiungere un'entità a Minecraft: Bedrock Edition utilizzando un pacchetto di comportamenti e un pacchetto di risorse. Come hai imparato dai tutorial consigliati, il comportamento delle entità può essere modificato con un pacchetto di comportamenti e puoi cambiarne l'aspetto con un pacchetto di risorse. Entrambi i pacchetti sono necessari per aggiungere un'entità funzionante al gioco. Questa guida è suddivisa in due parti: la prima parte illustra la struttura di file e cartelle necessaria per aggiungere un'entità personalizzata a Minecraft. La seconda parte mostra come infondere vita all'entità utilizzando componenti comportamentali e le animazioni.

In questo tutorial imparerai quanto segue:

• Come creare una nuova entità personalizzata utilizzando pacchetti di comportamenti e di risorse.
• Come applicare varie funzionalità all'entità, inclusi i componenti e le animazioni.
• Fare uso delle traduzioni per i nomi delle entità.

Requisiti

Prima di iniziare questo tutorial, ti consigliamo di completare i seguenti passaggi:

• Introduzione ai pacchetti di comportamenti
• Introduzione ai pacchetti di risorse
• Scarica i pacchetti di comportamenti e di risorse del robot minimo e del robot completo

Si consiglia inoltre la conoscenza di quanto segue per comprendere meglio questo articolo.

• Familiarità con il funzionamento del formato JSON.
• Un editor di codice come VSCode

Struttura del file

Nel pacchetto di comportamenti, un file di entità è responsabile della definizione dell'entità sul lato server. Nel pacchetto di risorse, un file di entità client è responsabile di dire al gioco come apparirà l'entità. Il grafico seguente mostra come diversi file possono interagire per creare un'entità personalizzata:

Esempio di entità robot - robot minimo

Per darti un punto di riferimento per questo tutorial, forniamo due versioni della stessa entità: un robot che si genera casualmente nel mondo, ha tre texture casuali, un'animazione della ruota, vari componenti e una meccanica dell'acqua personalizzata. Il link per il download è nella sezione precedente Requisiti.

Per osservare il robot in azione, scegli uno dei set di pacchetti di risorse e comportamenti appena scaricati. (Per ora ti consigliamo di iniziare con il minimo.) Inserisci i pacchetti di risorse e comportamenti nelle loro rispettive sottocartelle com.mojang, avvia un mondo con i trucchi abilitati e usa /summon compass:robot.

Questa è la struttura del pacchetto di comportamenti e del pacchetto di risorse "robot minimo" finito:

Sembra complesso, ma devi solo pensare ai file con "robot" nel nome e dove sono memorizzati.

Dopo esserti fatto un'idea di come si comporta il robot nel gioco, puoi rimuovere i pacchetti di risorse e comportamenti del robot finito e ricrearli da zero con i passi di questo tutorial per avere un'idea di come funzionano tutti i file insieme.

Un buon punto di partenza è quello di utilizzare i pacchetti di risorse e comportamenti che hai creato nei precedenti tutorial. Ti consigliamo di rimuovere l'entità mucca d'attacco, ma questa è una preferenza personale.

Denominazione

Quando crei un'entità, una delle prime cose da considerare è quale ID le darai. I file nei tuoi pacchetti di risorse e comportamenti dovranno essere sincronizzati utilizzando l'ID entità che hai assegnato alla tua entità. Questo ID è costituito da uno spazio dei nomi e da un nome separati da due punti. Questo era l'ID compass:robot che abbiamo usato in precedenza per evocare il robot.

Il tuo spazio dei nomi può essere un'abbreviazione del nome del tuo team o il nome del prodotto. L'ID deve includere solo lettere minuscole, cifre e trattini bassi. Non utilizzare "minecraft" come spazio dei nomi per il contenuto personalizzato. Lo spazio dei nomi "minecraft" è riservato alle risorse di base, quindi dovresti usare "minecraft" solo se stai sovrascrivendo questo tipo di contenuto.

La maggior parte dei file che definiscono l'entità saranno file JSON. Per evitare confusione, si consiglia di utilizzare un'estensione di file estesa quando crei ognuno di questi file. Il gioco ignora i nomi dei file nella maggior parte dei casi, ma mentre si lavora su un componente aggiuntivo, i nomi dei file disordinati possono creare confusione. Le estensioni sono:

Tipo di file	Nome del file
File dell'entità client	entity_name.entity.json
File di modello	entity_name.geo.json
File di animazione	entity_name.animation.json
Controller di animazione	entity_name.animation_controllers.json
Controller di rendering	entity_name.render_controllers.json

entity_name deve essere sostituito dal nome della tua entità, escluso lo spazio dei nomi.

Versioni del formato

Ogni file JSON deve avere un tag format_version. Questo tag è importante per consentire al gioco di leggere correttamente il file. È importante sapere che i file creati in formati precedenti funzioneranno ancora nelle versioni più recenti del gioco, ma solo se la versione del formato è impostata correttamente. Le versioni di formato errate sono una frequente fonte di errori.

Definizione del pacchetto di comportamenti

Il primo passo pratico per aggiungere un robot nel gioco inizia nel pacchetto di comportamenti. Crea un nuovo file nella cartella entities del pacchetto di comportamenti e denominalo robot.json. Copia e incolla questo codice.

{
    "format_version": "1.12.0",
    "minecraft:entity": {
        "description": {
            "identifier": "compass:robot",
            "is_spawnable": true,
            "is_summonable": true
        },
        "components": {}
    }
}

All'interno del tag di descrizione, definiamo gli attributi di base dell'entità. identifier imposta l'ID dell'entità. is_spawnable aggiungerà in seguito uno spawn egg nel gioco che consente al giocatore di generare questa creatura. is_summonable farà funzionare l'entità con il comando /summon.

All'interno di components aggiungeremo componenti per modificare il comportamento dell'entità. Per il momento, aggiungeremo solo il componente minecraft:physics. Conferisce all'entità la gravità e un comportamento di collisione normale.

"components": {
    "minecraft:physics": {}
}

Salva il file robot.json e vai al prossimo passo.

Definizione dell'entità client

Ora, dobbiamo aggiungere l'entità al pacchetto di risorse per dargli un aspetto visivo. Nella cartella entity del pacchetto di risorse, crea un nuovo file JSON denominato robot.entity.json.

{
    "format_version": "1.10.0",
    "minecraft:client_entity": {
        "description": {
            "identifier": "compass:robot",
            "spawn_egg": {
                "base_color": "#505152",
                "overlay_color": "#3b9dff"
            }
        }
    }
}

Questa è la struttura di base del file. Finora è simile al file sul lato del comportamento che abbiamo creato nella sezione precedente. Nota che ora usiamo client_entity invece della semplice entità. Al momento della stesura di questo articolo, 1.10.0 è l'ultima versione del formato di questo file.

Il tag spawn_egg definisce come apparirà lo spawn egg nell'inventario. Usando questo metodo, sembrerà uno spawn egg di base, ma con colori personalizzati.

Elementi visivi

Prima di poter aggiungere l'entità al gioco, è necessario un modello. L'articolo Modellazione e animazione di entità spiega come creare un modello e una texture personalizzati, ma per creare un modello c'è molto da imparare e non abbiamo ancora completato questo tutorial. Pertanto, per ora, puoi far finta di aver già creato un modello copiando e incollando i file dal pacchetto di risorse del robot. Esegui questi stessi passaggi in seguito per aggiungere il modello che hai creato.

• Salva il modello all'interno della cartella models/entity come robot.geo.json.
• Salva la texture in textures/entity come robot.png.

Ora che i file del modello sono in posizione, ci occorre un controller di rendering per collegare il modello, la texture e il materiale utilizzato per l'entità.

Apri il file robot.entity.json nella cartella entity del tuo pacchetto di risorse.

Per la maggior parte delle entità (come il nostro robot), possiamo utilizzare il controller di rendering predefinito fornito dal gioco. Illustreremo maggiormente in dettaglio i controller di rendering nella parte più avanzata di questo tutorial. Per ora, è sufficiente che tu ne conosca la posizione e il contenuto:

{
    "format_version": "1.10.0",
    "minecraft:client_entity": {
        "description": {
            "identifier": "compass:robot",
            "materials": {
                "default": "entity"
            },
            "textures": {
                "default": "textures/entity/robot"
            },
            "geometry": {
                "default": "geometry.robot"
            },
            "render_controllers": [
                "controller.render.default"
            ],
            "spawn_egg": {
                "base_color": "#505152",
                "overlay_color": "#3b9dff"
            }
        }
    }
}

Il modello ha come riferimento il nome della geometria. Se crei un modello in Blockbench , ricorda di impostare il nome della geometria sul nome dell'entità nelle impostazioni del progetto. In questo caso, "robot".

A differenza delle geometrie, le texture sono collegate dal loro percorso nel pacchetto di risorse, meno l'estensione del file, come mostrato nell'esempio.

Nella maggior parte dei casi, non è richiesto un materiale personalizzato. Invece, puoi usare un materiale predefinito. In questo esempio, usiamo entity. Se la texture contiene parti trasparenti, puoi usare entity_alphatest, o se la texture è traslucida (come il vetro colorato), puoi usare entity_alphablend.

Stringhe di traduzione

In questo momento, né l'entità stessa né lo spawn egg hanno un nome proprio nel gioco. Per definire un nome, abbiamo bisogno di un file di linguaggio. Crea una nuova cartella chiamata texts all'interno del tuo pacchetto di risorse e crea un nuovo file chiamato en_US.lang. Per le entità personalizzate, dobbiamo solo modificare questo file di linguaggio, perché tutte le altre lingue verranno impostate per impostazione predefinita sull'inglese americano. All'interno di questo file, aggiungi queste due righe:

entity.compass:robot.name=Robot
item.spawn_egg.entity.compass:robot.name=Spawn Robot

La prima riga definisce il nome dell'entità. Questo sarà visibile nei messaggi di morte e nell'output di alcuni comandi. La chiave e il valore sono sempre separati dal segno uguale. La prima riga può essere suddivisa in:

entity.<identifier>.name=<Name>

La seconda riga definisce il nome oggetto dello spawn egg:

item.spawn_egg.entity.<identifier>.name=<Name>

Test

Ricorda di eseguire test presto e spesso. Incontrare un problema in anticipo aiuta a rendere più semplice la sua identificazione, in modo che sia anche più facile da risolvere. Testare spesso rivelerà i problemi subito dopo aver apportato modifiche, il che aiuta a restringere la causa di tali modifiche recenti.

Dovresti essere in grado di generare la tua entità nel gioco usando lo spawn egg o il comando di evocazione. Se vuoi solo un'entità statica, sei a posto. Ma se vuoi personalizzare ancora di più l'entità, continua a leggere.

Esempio di entità robot - robot completo

Ora sarebbe un buon momento per provare i pacchetti di risorse e comportamenti del robot completo. Confronta la raccolta di cartelle e file. Dopodiché, rimetti a posto i tuoi pacchetti di robot minimi così possiamo continuare ad aggiungere funzionalità.

Componenti

I componenti dicono all'entità come agire nel gioco. Aggiungiamo alcuni componenti e spieghiamo in dettaglio cosa fanno.

Nella cartella behavior pack/entities/ apri robot.json e sostituisci la singola voce di "minecraft:physics": {} con tutto questo...

   "components": {
        "minecraft:physics": {},
        "minecraft:nameable": {},
        "minecraft:movement": {
            "value": 0.25
        },
        "minecraft:movement.basic": {},
        "minecraft:jump.static": {},
        "minecraft:navigation.walk": {
            "avoid_water": true
        },
        "minecraft:behavior.tempt": {
            "priority": 1,
            "speed_multiplier": 1.4,
            "items": ["diamond"],
            "within_radius": 7.0
        },
        "minecraft:behavior.random_stroll":
        {
            "priority": 3,
            "speed_multiplier": 0.8
        },
        "minecraft:experience_reward": {
            "on_death": 8
        }
   }

Nome del componente	Descrizione
minecraft:nameable	Consente al giocatore di nominare l'entità con una tag di nome.
minecraft:movement	Indica all'entità quanto velocemente spostarsi. La maggior parte degli animali in Minecraft ha una velocità di 0,25.
minecraft:movement.basic	Conferisce all'entità la capacità di muoversi sul terreno.
minecraft:jump.static	Consente all'entità di saltare per salire sui blocchi.
minecraft:navigation.walk	Consente all'entità di esplorare il mondo. Evitare l'acqua è una delle opzioni incluse con questo componente.
minecraft:behavior.tempt	Fa in modo che l'entità segua i giocatori che tengono in mano dei diamanti. Stiamo dando a questo comportamento una priorità più alta, quindi darà priorità a questa azione (numero più basso = priorità più alta).
minecraft:behavior.random_stroll	Farà in modo che l'entità cammini casualmente per il luogo. Stiamo impostando la priorità su un numero più alto in modo che l'entità lo faccia solo quando non ha nient'altro da fare. Il moltiplicatore di velocità diminuirà la velocità durante l'utilizzo di questo comportamento di camminata.
minecraft:experience_reward	Consente all'entità di rilasciare esperienza quando viene uccisa da un giocatore.

Animazioni

In questa sezione, aggiungeremo semplicemente una semplice animazione della ruota al robot. Se vuoi saperne di più sulle animazioni, su come utilizzare i controller di animazione e su come creare animazioni in Blockbench, leggi questa guida.

Le animazioni sono memorizzate nei file di animazione. Quindi la prima cosa che dobbiamo fare è creare una cartella chiamata animations nel pacchetto di risorse e creare un file chiamato robot.animation.json al suo interno. In quel file, creeremo una nuova animazione chiamata animation.robot.drive. Vogliamo anche impostare loop su true in modo che l'animazione continui a essere riprodotta. Il file dovrebbe avere un aspetto simile a questo:

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.drive": {
            "loop": true
        }
    }
}

Le animazioni ci consentono di animare la posizione, la rotazione e la grandezza di ciascun osso. (Se non sai ancora cosa significa "osso" in questo contesto, non ci sono problemi. Lo scoprirai quando imparerai a usare Blockbench. Per ora, sappi che indica un chunk del modello, come una gamba o una ruota). Le animazioni possono essere eseguite con fotogrammi chiave o espressioni Molang o una combinazione di entrambi. In questo esempio useremo solo le espressioni Molang.

Molang è un linguaggio dedicato solo ai pacchetti di risorse e di comportamenti. Ci permette di ottenere vari numeri dall'entità usando una query e di calcolare un risultato da questi numeri usando espressioni matematiche. Ad esempio, la query query.modified_distance_moved restituirà la distanza percorsa dall'entità. Possiamo usarlo per calcolare la rotazione della ruota del robot sull'asse X, il che si tradurrà in un'animazione che farà sembrare che il robot stia guidando. Devi giocare con i numeri, ma per questo modello 60 ha funzionato abbastanza bene.

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.drive": {
            "loop": true,
            "bones": {
                "wheel": {
                    "rotation":["query.modified_distance_moved*60", 0, 0]
                }
            }
        }
    }
}

Ora che l'animazione è stata creata, dobbiamo collegarla nel file dell'entità client. (Ricorda, il pacchetto di risorse è il client, quindi apri <resource pack>/entity/robot.entity.json per questa prossima parte.) Il tag animations collega tutte le animazioni e i controller di animazione utilizzati dall'entità. Ogni animazione ottiene un nome breve che può essere utilizzato per riprodurre l'animazione in un controller di animazione o direttamente nel file, in questo caso drive.

Le sezioni scripts e animate possono essere utilizzate per riprodurre direttamente le animazioni:

        "animations": {
            "drive": "animation.robot.drive"
        },
        "scripts": {
            "animate": ["drive"]
        }

Con questi due tag aggiunti nel tag di descrizione del file dell'entità client, l'animazione di guida sarà sempre attiva e farà avanzare la rotazione della ruota mentre l'entità è in movimento.

Controller di rendering

I controller di rendering ci consentono di modificare la geometria, le texture e i materiali dell'entità utilizzando Molang. L'esempio seguente mostra come utilizzare la geometria, il materiale e la texture che sono stati collegati nel file di entità client come default:

{
    "format_version": "1.8.0",
    "render_controllers": {
        "controller.render.robot": {
            "geometry": "Geometry.default",
            "materials": [ { "*": "Material.default" }],
            "textures": [ "Texture.default" ]
        }
    }
}

Se vogliamo usare solo una geometria, un materiale e una texture predefiniti, possiamo semplicemente lasciarlo puntare al controller di rendering predefinito, come abbiamo fatto prima. Ma questo è il momento giusto per imparare come aggiungere texture casuali, quindi analizziamo come funzionano i controller di rendering.

Spiegazione del controllore di rendering

Noterai che il tag di base è denominato render_controllers. Ciò significa che in un file possiamo specificare più controller di rendering.

Il nostro controller di rendering è denominato utilizzando il seguente schema: controller.render.<entity_name>. Per un controller di rendering multiuso, possiamo anche usare un'altra parola chiave invece del nome dell'entità.

All'interno del tag del controller di rendering, sono specificate le diverse risorse, ma noterai che ognuna utilizza un formato JSON diverso.

Geometria

Un controller di rendering può mostrare solo una geometria alla volta. Ecco perché è collegato direttamente come una stringa. Questa stringa può essere un'espressione Molang e dovrebbe sempre restituire una geometria. In questo caso si chiama Geometry.default, il che significa che restituirà la geometria collegata come default da qualsiasi entità che utilizza il controller di rendering.

È possibile eseguire il rendering di più geometrie su un'entità utilizzando più controller di rendering. Tuttavia, questo può essere complicato e può portare a comportamenti imprevisti. Pertanto, è consigliato solo a creatori esperti.

Materiali

A differenza della geometria, i materiali sono scritti come un array di oggetti. Lo scopo è che possiamo assegnare a ciascun osso un materiale separato. Ogni oggetto nell'array può avere una coppia chiave-valore. La chiave seleziona una serie di ossa. Un asterisco viene utilizzato come carattere jolly. Ciò significa che a tutte le ossa, indipendentemente dal nome, verrà assegnato il materiale predefinito. Nota che i materiali sono assegnati in ordine, il che significa che i materiali più in basso nell'elenco possono sovrascrivere i materiali precedenti.

        "materials": [
            { "*": "Material.default" },
            { "*_arm": "Material.transparent" }
        ],

In questo esempio, applichiamo prima il materiale predefinito a tutte le ossa. Quindi, sovrascriviamo il materiale con il materiale trasparente su tutte le ossa che terminano in _arm. In questo modo, tutte le ossa del braccio sosterrebbero la trasparenza.

Texture

Le texture sono specificate in un array. Nella maggior parte dei casi, qui verrà collegata solo una texture, perché le entità non supportano texture separate. C'è un'eccezione però: i materiali possono supportare più texture sovrapposte l'una sull'altra, come il materiale entity_multitexture. Ad esempio, questo viene utilizzato dai lama per sovrapporre l'arredamento.

Array

Quando si lavora con più risorse di un solo tipo, può essere utile utilizzare un array. Un array è un elenco di collegamenti di risorse che sono definiti nel controller di rendering e da cui puoi selezionare una risorsa utilizzando Molang.

Possiamo definire un array per il robot in questo modo:

        "controller.render.robot": {
            "arrays": {
                "textures": {
                    "Array.variant":[
                        "Texture.default",
                        "Texture.variant_b",
                        "Texture.variant_c"
                    ]
                }
            },

Nella sezione array possiamo definire gli array per ciascuna delle tre categorie: textures, materials e geometries. All'interno della categoria, puoi definire gli array usando Array.<array name> come nome. Ogni riga all'interno dell'array collega una texture definita nel file di entità client.

Puoi accedere all'array usando Molang. Gli array sono in base 0, quindi è possibile accedere alla prima texture di questo array tramite Array.variant[0].

In questo esempio, stiamo usando la query sulla variante per scegliere una texture dall'array. La variante di una creatura può essere modificata tramite il componente minecraft:variant nel file di comportamento.

"textures": [ "Array.variant[ query.variant ]" ]

Ora dobbiamo collegare le texture aggiuntive nel file dell'entità client. La normale texture blu del robot è già collegata come default e ora creeremo due copie del file di texture del robot, modificheremo il colore e le collegheremo come variant_b e variant_c.

            "textures": {
                "default": "textures/entity/robot",
                "variant_b": "textures/entity/robot_b",
                "variant_c": "textures/entity/robot_c"
            },

Ora le texture sono collegate. L'ultimo passaggio consiste nel rendere casuale la variante nel file di comportamento. Per questo useremo i gruppi di componenti. Sono un modo per aggiungere e rimuovere un set di componenti dall'entità in qualsiasi momento. Useremo anche un evento che rende casuale il gruppo di componenti da aggiungere.

        "description": {
            ...
        },
        "components": {
            ...
        },
        "component_groups": {
            "compass:color_0": {
                "minecraft:variant": {"value": 0}
            },
            "compass:color_1": {
                "minecraft:variant": {"value": 1}
            },
            "compass:color_2": {
                "minecraft:variant": {"value": 2}
            }
        },
        "events": {
            "minecraft:entity_spawned": {
                "randomize": [
                    {
                        "add": {
                            "component_groups": ["compass:color_0"]
                        }
                    }, {
                        "add": {
                            "component_groups": ["compass:color_1"]
                        }
                    }, {
                        "add": {
                            "component_groups": ["compass:color_2"]
                        }
                    }
                ]
            }
        }

Ora, quando la generiamo per la prima volta, l'entità sceglierà casualmente un gruppo di componenti e quindi una variante. Questa è una tecnica molto comune per rendere casuale l'aspetto di un'entità.

Generazione

Le regole di generazione definiscono il modo in cui le entità si generano casualmente nel mondo. Creeremo un file di regole di generazione per il nostro robot. Per prima cosa, crea una cartella chiamata spawn_rules nel tuo pacchetto di comportamenti. All'interno della cartella, crea un nuovo file di testo chiamato robot.json. Il contenuto del file dovrebbe essere simile a questo:

{
    "format_version": "1.8.0",
    "minecraft:spawn_rules": {
        "description": {
            "identifier": "compass:robot",
            "population_control": "animal"
        },
        "conditions": []
    }
}

All'interno di minecraft:spawn_rules dobbiamo considerare due cose: controllo della popolazione e condizioni.

description definisce le proprietà di base del file. identifier deve corrispondere a quello della nostra entità. population_control definisce il modo con cui il gioco riconosce quante creature generare ed è un po' più complesso.

Controllo della popolazione

Ci sono diversi pool di entità. Quando il pool definito qui è considerato pieno, il gioco non genererà più le creature di questo pool. Ci sono tre diverse opzioni:

• "animal" : creature passive come le mucche e i maiali
• "water_animal": creature acquatiche come i pesci tropicali e i delfini
• "monster": creature ostili come gli scheletri e gli zombi

Per il robot, usiamo il pool degli animali.

Condizioni

conditions è un array di possibili condizioni che permetterebbero la generazione di una creatura nel mondo. Ognuna delle condizioni cerca separatamente di generare creature nel mondo. Ciascuna è costituita da un gruppo di componenti che definiscono quando generare la creatura e quando non farlo.

Per una regola di generazione di base, una condizione è sufficiente. Per il robot utilizzeremo questa configurazione:

{
    "format_version": "1.8.0",
    "minecraft:spawn_rules": {
        "description": {
            "identifier": "compass:robot",
            "population_control": "animal"
        },
        "conditions": [
            {
                "minecraft:spawns_on_surface": {},
                "minecraft:brightness_filter": {
                    "min": 12,
                    "max": 15,
                    "adjust_for_weather": false
                },
                "minecraft:weight": {
                    "default": 40
                },
                "minecraft:biome_filter": {
                    "test": "has_biome_tag",
                    "value": "animal"
                }
            }
        ]
    }
}

Nome del componente	Descrizione
minecraft:spawns_on_surface	La creatura si genera sulla superficie
minecraft:brightness_filter	Genera l'entità solo a una certa luminosità. Accetta tre opzioni, min, max e adjust_for_weather. I livelli di luce vanno da 0 a 15. Se adjust_for_weather è impostato su true , si terrà conto della diminuzione della luce dovuta a pioggia e temporali.
minecraft:weight	Il peso dell'entità nella generazione. Più alto è il numero, più spesso verrà generata la creatura.
minecraft:biome_filter	Filtra il bioma in cui la creatura può essere generata. I filtri del bioma funzionano in modo simile ai filtri nel comportamento, il che significa che sono ammessi operatori quali all_of e any_of. I biomi hanno tag diversi che indicano il tipo, la variante, la dimensione del bioma e le caratteristiche, come i mostri e gli animali.

I robot ora verranno generati in qualsiasi luogo della superficie dove possono generarsi animali e dove c'è luce sufficiente. Con un peso di 40, verranno generati anche abbastanza frequentemente.

Animazioni del comportamento

Le animazioni del comportamento funzionano in modo simile alle normali animazioni, ma vengono eseguite nel pacchetto di comportamenti. Mentre le normali animazioni animano il movimento del modello, nonché i suoni e le particelle, le animazioni del comportamento possono eseguire comandi regolari, attivare eventi di entità o eseguire espressioni Molang. Le animazioni del comportamento sono spesso chiamate anche Eventi di entità, anche se quel nome può creare un po' di confusione.

Dato che ai robot non piace l'acqua, aggiungeremo una meccanica per danneggiare i robot nell'acqua o sotto la pioggia. Innanzitutto, creeremo un controller di animazione per testare quando l'entità è in acqua utilizzando una query Molang. Crea una nuova cartella nel pacchetto di comportamenti denominato animation_controllers e crea il file robot.animation_controllers.json al suo interno:

{
    "format_version": "1.10.0",
    "animation_controllers": {
        "controller.animation.robot.in_water": {
            "states": {
                "default": {
                    "transitions": [
                        {"in_water": "query.is_in_water_or_rain"}
                    ]
                },
                "in_water": {
                    "transitions": [
                       {"default": "query.is_in_water_or_rain == 0"}
                    ]
                }
            }
        }
    }
}

Il controller di animazione è molto simile ai normali corrispettivi lato client. Ha due stati che vengono attivati a seconda che il robot sia in acqua o meno.

Ora aggiungiamo un'animazione per dare un effetto veleno al robot. Crea la cartella animations all'interno del pacchetto di comportamenti e crea un file denominato robot.animation.json:

{
    "format_version": "1.8.0",
    "animations": {
        "animation.robot.poison": {
            "loop": true,
            "animation_length": 1,
            "timeline": {
                "0.0": [
                    "/effect @s poison 2 0 true"
                ]
            }
        }
    }
}

Invece di usare il tag osso qui per animare le ossa, usiamo il tag cronologia. Nei pacchetti di risorse, le cronologie possono essere utilizzate solo per eseguire il codice Molang. Nelle animazioni del comportamento, puoi usarlo per eseguire codice Molang, comandi o attivare eventi di entità. Nota che tutti questi valori sono forniti in forma di stringa. Il gioco scoprirà il tipo di stringa basandosi sul suo contenuto. Se la stringa inizia con una barra, verrà eseguita come comando. Se corrisponde a questo schema: @s namespace:event, verrà eseguita come evento di entità. Se assomiglia a Molang, verrà eseguita come Molang.

Per questo motivo, è importante che nelle animazioni del comportamento i comandi inizino con la barra. Inoltre, tieni presente che stiamo applicando il veleno per due secondi, perché un secondo non basterebbe ad applicare effettivamente il danno. Il true alla fine del comando renderà ambientale l'effetto di stato, il che significa che non ci saranno particelle.

Come con le animazioni nei pacchetti di risorse, dobbiamo collegare tutte le nostre animazioni e i controller di animazione nel tag di descrizione della nostra entità, che sarà simile a questo:

        "description": {
            "identifier": "compass:robot",
            "is_spawnable": true,
            "is_summonable": true,
            "animations": {
                "poison": "animation.robot.poison",
                "in_water": "controller.animation.robot.in_water"
            },
            "scripts": {
                "animate": [
                    "in_water"
                ]
            }
        },

La sezione delle animazioni elenca tutte le animazioni e i controller di animazione utilizzati dall'entità e assegna loro un nome breve. Nella sezione script/animazioni, elenchiamo le animazioni che dovrebbero sempre essere eseguite. Vogliamo che il controller rilevi lo stato in esecuzione sempre, ma non l'effetto veleno.

Ora dobbiamo tornare al controller di animazione e aggiungere l'effetto veleno. Aggiungeremo anche una piccola meccanica di rigenerazione insieme a un effetto sonoro, in modo che il robot non muoia così facilmente.

            "states": {
                "default": {
                    "transitions": [
                        {"in_water": "query.is_in_water_or_rain"}
                    ]
                },
                "in_water": {
                    "animations": [
                        "poison"
                    ],
                    "on_exit": [
                        "/effect @s regeneration 2 4 true",
                        "/playsound random.fizz @a[r=16]"
                    ],
                    "transitions": [
                        {"default": "query.is_in_water_or_rain == 0"}
                    ]
                }
            }

Nell'array animations, elenchiamo tutte le animazioni che dovrebbero essere in esecuzione in questo stato, che è solo poison nel nostro caso.

Nel tag on_exit, aggiungiamo due comandi che verranno eseguiti quando il robot esce dall'acqua. Il primo comando conferirà al robot un effetto di rigenerazione di livello quattro per due secondi. Il secondo comando riprodurrà un effetto sonoro frizzante.

Nota che avremmo potuto anche eseguire il comando nell'array on_entry dello stato predefinito, ma questo avrebbe anche riprodotti gli effetti quando si generava il robot o si ricaricava il mondo, perché il gioco passa sempre prima allo stato default.

Per riassumere il rapporto tra controller e animazioni: un controller di animazione viene utilizzato per controllare quando viene riprodotta un'animazione, mentre un'animazione stessa è ciò che si verifica a seguito della transizione all'animazione determinata dal controller. Animazioni e controller di animazione vengono forniti al file del comportamento dell'entità.

E adesso?

In questa guida abbiamo aggiunto al gioco un'entità personalizzata completa. Se hai usato i file dei modelli esistenti anziché crearne di tuoi, questo potrebbe essere il momento giusto per imparare a conoscere Blockbench. In alternativa, puoi ottenere maggiori informazioni sul comportamento delle entità per il server.

Modellazione e animazione delle entità Introduzione al comportamento delle entità