Generazione di Progressi
Una guida per configurare la generazione di progressi con datagen.
PREREQUISITI
Assicurati di aver prima completato il processo di configurazione della datagen.
Configurazione
Anzitutto, dobbiamo creare il nostro fornitore. Crea una classe che estenda FabricAdvancementProvider e compilane i metodi di base:
public class ExampleModAdvancementProvider extends FabricAdvancementProvider {
public ExampleModAdvancementProvider(FabricPackOutput output, CompletableFuture<HolderLookup.Provider> registryLookup) {
super(output, registryLookup);
}
@Override
public void generateAdvancement(HolderLookup.Provider wrapperLookup, Consumer<AdvancementHolder> consumer) {
}
}2
3
4
5
6
7
8
9
Per completare la configurazione, aggiungi questo fornitore alla tua DataGeneratorEntrypoint nel metodo onInitializeDataGenerator.
pack.addProvider(ExampleModAdvancementProvider::new);Struttura dei Progressi
Un progresso è composto di alcune componenti diverse. Assieme ai requisiti, detti "criterio", potrebbe avere:
- Un oggetto
DisplayInfoche dica al gioco come mostrare il progresso ai giocatori, AdvancementRequirements, ovvero liste di liste di criteri, che richiedono che almeno un criterio di ogni sotto-lista sia soddisfatto,AdvancementRewards, che il giocatore riceverà per aver completato il progresso,- Una
Strategy, che informa il progresso su come gestire criteri multipli, e - Un
Advancementgenitore, che organizza la gerarchia che vedi nella schermata "Progressi".
Progressi Semplici
Ecco un semplice progresso per aver ottenuto un blocco di terra:
AdvancementHolder getDirt = Advancement.Builder.advancement()
.display(
Items.DIRT, // The display icon
Component.literal("Your First Dirt Block"), // The title
Component.literal("Now make a house from it"), // The description
Identifier.withDefaultNamespace("gui/advancements/backgrounds/adventure"), // Background image for the tab in the advancements page, if this is a root advancement (has no parent)
AdvancementType.TASK, // TASK, CHALLENGE, or GOAL
true, // Show the toast when completing it
true, // Announce it to chat
false // Hide it in the advancement tab until it's achieved
)
// "got_dirt" is the name referenced by other advancements when they want to have "requirements."
.addCriterion("got_dirt", InventoryChangeTrigger.TriggerInstance.hasItems(Items.DIRT))
// Give the advancement an id
.save(consumer, ExampleMod.id("get_dirt"));2
3
4
5
6
7
8
9
10
11
12
13
14
15
Output JSON
{
"criteria": {
"got_dirt": {
"conditions": {
"items": [
{
"items": "minecraft:dirt"
}
]
},
"trigger": "minecraft:inventory_changed"
}
},
"display": {
"background": "minecraft:gui/advancements/backgrounds/adventure",
"description": "Now make a house from it",
"icon": {
"id": "minecraft:dirt"
},
"title": "Your First Dirt Block"
},
"requirements": [
[
"got_dirt"
]
],
"sends_telemetry_event": true
}2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Genitori
Per creare o estendere un albero di progressi, è possibile impostare un genitore del nostro progressi. Per fare ciò, chiama Advancement.Builder#parent(...) passando il riferimento al progresso genitore.
Advancement.Builder.advancement()
.parent(getDirt)
// ...2
3
Se non è disponibile un riferimento diretto al progresso genitore (per esempio se esso fosse un progresso vanilla), si può passare un Identifier come segnaposto.
Advancement.Builder.advancement()
.parent(createPlaceholder(Identifier.withDefaultNamespace("adventure/root")))
// ...2
3
I tuoi progressi dovrebbero ora essere mostrati come albero nel menu apposito.

Criteri multipli
Per predisporre condizioni più avanzate per un progresso, è possibile chiamare Advancement.Builder#addCriteria(...) più volte, con criteri ulteriori.
Advancement.Builder.advancement()
.addCriterion("ate_apple", ConsumeItemTrigger.TriggerInstance.usedItem(itemLookup, Items.APPLE))
.addCriterion("ate_cooked_beef", ConsumeItemTrigger.TriggerInstance.usedItem(itemLookup, Items.COOKED_BEEF))
// ...2
3
4
Affinché questo progresso sia completato, sarà ora necessario che tutti i criteri vengano soddisfatti. Questo è il comportamento predefinito, ma è anche possibile modificarlo scegliendo un'altra strategia.
Advancement.Builder.advancement()
.addCriterion("brew_mundane", CriteriaTriggers.BREWED_POTION.createCriterion(
new BrewedPotionTrigger.TriggerInstance(Optional.empty(), Optional.of(Potions.MUNDANE))
))
.addCriterion("brew_thick", CriteriaTriggers.BREWED_POTION.createCriterion(
new BrewedPotionTrigger.TriggerInstance(Optional.empty(), Optional.of(Potions.THICK))
))
.requirements(AdvancementRequirements.Strategy.OR)
// ...2
3
4
5
6
7
8
9
Premi
È possibile attribuire premi a determinati progressi, ed essi saranno conferiti al giocatore che li completa. Per fare ciò, chiamiamo Advancement.Builder#rewards(...) elencando i premi desiderati.
Advancement.Builder.advancement()
.rewards(AdvancementRewards.Builder.experience(10))
// ...2
3
Sono disponibili altri tipi di premi, eccone alcuni:
Advancement.Builder.advancement()
.rewards(
new AdvancementRewards.Builder()
// Give entries from a loot table
.addLootTable(ModLootTables.ADVANCEMENT_COLLECT_NETHER_STAR)
// Make recipes available in the recipe book
.addRecipe(RecipeBuilder.getDefaultRecipeId(new ItemStackTemplate(Items.BEACON)))
// Run a .mcfunction - https://minecraft.wiki/w/Function_(Java_Edition)
.runs(ExampleMod.id("got_nether_star"))
// Give experience points
.addExperience(200)
)
// ...2
3
4
5
6
7
8
9
10
11
12
13
Criteri Personalizzati
WARNING
Anche se la datagen può avvenire lato client, i Criterion e i Predicate sono nell'insieme di codice main (entrambi i lati), poiché il server ne ha bisogno per innescarli e valutarli.
Definizioni
Un criterio (in inglese criterion, plurale criteria) è qualcosa che un giocatore può fare (o che succede a un giocatore) e che può essere considerata per quanto riguarda un progresso. Nel gioco ci sono già vari criteri, che si possono trovare nel package net.minecraft.advancements.criterion. In genere dovrai aggiungere un nuovo criterio solo se devi implementare una meccanica personalizzata nel gioco.
Le condizioni sono valutate dai criteri. Un criterio viene preso in considerazione solo se tutte le condizioni rilevanti sono soddisfatte. Le condizioni di solito si esprimono come predicati.
Un predicato è qualcosa che accetta un valore e restituisce un boolean. Per esempio, un Predicate<Item> potrebbe restituire true se l'oggetto è un diamante, mentre un Predicate<LivingEntity> potrebbe restituire true se l'entità non è ostile ai villici.
Creare Criteri Personalizzati
Anzitutto ci serve una meccanica da implementare. Informiamo il giocatore riguardo a quale utensile ha usato ogni volta che rompe un blocco.
public class ExampleModDatagenAdvancement implements ModInitializer {
@Override
public void onInitialize() {
HashMap<Item, Integer> tools = new HashMap<>();
PlayerBlockBreakEvents.AFTER.register(((level, player, blockPos, blockState, blockEntity) -> {
if (player instanceof ServerPlayer serverPlayer) { // Only triggers on the server side
Item item = player.getMainHandItem().getItem();
Integer usedCount = tools.getOrDefault(item, 0);
usedCount++;
tools.put(item, usedCount);
serverPlayer.sendSystemMessage(Component.nullToEmpty("You've used \"" + item + "\" as a tool " + usedCount + " times!"));
}
}));
}
}2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Nota che questo è del codice molto brutto. La HashMap non viene memorizzata persistentemente, quindi sarà resettata ad ogni riavvio del gioco. È solo per mostrare i Criterion. Avvia il gioco e provalo!
Ora, creiamo il nostro criterio personalizzato, UseToolCriterion. Avrà bisogno di una sua classe Conditions, quindi creeremo entrambe insieme:
public class UseToolCriterion extends SimpleCriterionTrigger<UseToolCriterion.Conditions> {
@Override
public Codec<Conditions> codec() {
return Conditions.CODEC;
}
public record Conditions(Optional<ContextAwarePredicate> playerPredicate) implements SimpleCriterionTrigger.SimpleInstance {
public static Codec<UseToolCriterion.Conditions> CODEC = ContextAwarePredicate.CODEC.optionalFieldOf("player")
.xmap(Conditions::new, Conditions::player).codec();
@Override
public Optional<ContextAwarePredicate> player() {
return this.playerPredicate;
}
}
}2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Wow, questo è un sacco! Analizziamolo poco per volta.
UseToolCriterionè unSimpleCriterionTrigger, al quale si possono applicare delleConditions.Conditionsha un attributoplayerPredicate. Tutte leConditionsdovrebbero avere un predicato del giocatore (tecnicamente unLootContextPredicate).Conditionsha anche unCODEC. QuestoCodecè semplicemente il codec per il suo unico attributo,playerPredicate, con istruzioni aggiuntive per convertirlo tra di essi (xmap).
INFO
Per saperne di più sui codec, controlla la pagina Codec.
Ci serve un modo per controllare se le condizioni sono soddisfatte. Aggiungiamo un metodo ausiliare a Conditions:
public boolean requirementsMet() {
return true; // AbstractCriterion#trigger helpfully checks the playerPredicate for us.
}2
3
Ora che abbiamo un criterio e le sue condizioni, ci serve un modo per innescarlo. Aggiungi un metodo d'innesco a UseToolCriterion:
public void trigger(ServerPlayer player) {
trigger(player, Conditions::requirementsMet);
}2
3
Ci siamo quasi! Ora, ci serve un'istanza del nostro criterio con cui lavorare. Mettiamola in una nuova classe, chiamata ModCriteria, mediante a un metodo ausiliario che facilita la registrazione.
public class ModCriteria {
public static final UseToolCriterion USE_TOOL = register("use_tool", new UseToolCriterion());
private static <T extends CriterionTrigger<?>> T register(final String name, final T criterion) {
return Registry.register(BuiltInRegistries.TRIGGER_TYPES, ExampleMod.id(name), criterion);
}
}2
3
4
5
6
7
Per assicurarci che i nostri criteri siano inizializzati al tempo giusto, aggiungi un metodo vuoto init:
public static void init() {
}2
E chiamalo nell'initializer della tua mod:
ModCriteria.init();Infine, dobbiamo innescare il nostro criterio. Aggiungi questo a dove inviamo un messaggio al giocatore nella classe main della mod.
ModCriteria.USE_TOOL.trigger(serverPlayer);Il tuo criterio nuovo e luccicante è ora pronto per l'uso! Aggiungiamolo al nostro fornitore:
AdvancementHolder breakBlockWithTool = Advancement.Builder.advancement()
.parent(getDirt)
.display(
Items.DIAMOND_SHOVEL,
Component.literal("Not a Shovel"),
Component.literal("That's not a shovel (probably)"),
null,
AdvancementType.GOAL,
true,
true,
false
)
.addCriterion("break_block_with_tool", ModCriteria.USE_TOOL.createCriterion(new UseToolCriterion.Conditions(Optional.empty())))
.save(consumer, ExampleMod.id("break_block_with_tool"));2
3
4
5
6
7
8
9
10
11
12
13
14
Esegui l'operazione di datagen di nuovo, e avrai con te un nuovo progresso con cui giocare!
Condizioni con Parametri
Tutto questo è bello e tutto, ma, e se volessimo solo concedere il progresso dopo aver fatto qualcosa 5 volte? E perché non concederne un altro dopo 10 volte? Per questo dovremo dare alla nostra condizione un parametro. Puoi attenerti a UseToolCriterion, o andare avanti qui con un nuovo ParameterizedUseToolCriterion. Nella pratica dovresti solo avere quello parametrizzato, ma li terremo entrambi per questo tutorial.
Lavoriamo dal basso verso l'alto. Dovremo verificare se i requisiti sono soddisfatti, quindi modifichiamo il nostro metodo Conditions#requirementsMet:
public boolean requirementsMet(int totalTimes) {
return totalTimes > this.requiredTimes; // AbstractCriterion#trigger helpfully checks the playerPredicate for us.
}2
3
requiredTimes non esiste, quindi rendilo un parametro di Conditions:
public record Conditions(Optional<ContextAwarePredicate> playerPredicate, int requiredTimes) implements SimpleCriterionTrigger.SimpleInstance {
@Override
public Optional<ContextAwarePredicate> player() {
return this.playerPredicate;
}
public boolean requirementsMet(int totalTimes) {
return totalTimes > this.requiredTimes; // AbstractCriterion#trigger helpfully checks the playerPredicate for us.
}
}2
3
4
5
6
7
8
9
10
Ora il nostro codec dà errore. Scriviamo un nuovo codec per le nuove modifiche:
public static Codec<ParameterizedUseToolCriterion.Conditions> CODEC = RecordCodecBuilder.create(instance -> instance.group(
ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(Conditions::player),
Codec.INT.fieldOf("requiredTimes").forGetter(Conditions::requiredTimes)
).apply(instance, Conditions::new));2
3
4
Andando avanti, dobbiamo ora aggiustare il nostro metodo trigger:
public void trigger(ServerPlayer player, int totalTimes) {
this.trigger(player, conditions -> conditions.requirementsMet(totalTimes));
}2
3
Se hai creato un nuov criterio, dobbiamo aggiungerlo a ModCriteria
public static final ParameterizedUseToolCriterion PARAMETERIZED_USE_TOOL = register("parameterized_use_tool", new ParameterizedUseToolCriterion());E chiamarlo nella nostra classe principale, proprio dove c'è quello vecchio:
ModCriteria.PARAMETERIZED_USE_TOOL.trigger(serverPlayer, usedCount);Aggiungi il progresso al tuo fornitore:
AdvancementHolder breakBlockWithToolFiveTimes = Advancement.Builder.advancement()
.parent(breakBlockWithTool)
.display(
Items.GOLDEN_SHOVEL,
Component.literal("Not a Shovel Still"),
Component.literal("That's still not a shovel (probably)"),
null,
AdvancementType.GOAL,
true,
true,
false
)
.addCriterion("break_block_with_tool_five_times", ModCriteria.PARAMETERIZED_USE_TOOL.createCriterion(new ParameterizedUseToolCriterion.Conditions(Optional.empty(), 5)))
.save(consumer, ExampleMod.id("break_block_with_tool_five_times"));2
3
4
5
6
7
8
9
10
11
12
13
14
Esegui nuovamente la datagen, e hai finalmente finito!
Risorse condizionali
Per applicare una condizione per risorse a un progresso generato, racchiudi il consumer in withConditions e fornisci le condizioni desiderate. Questo permetterà di generare il progresso al quale sono applicate le condizioni:
Advancement.Builder.advancement()
.display(
ModBlocks.DUPLICATOR_BLOCK,
Component.literal("Experimental Duplication"),
Component.literal("Place a duplicator block with the Redstone Experiments flag enabled."),
null,
AdvancementType.CHALLENGE,
false, false, false)
.addCriterion("place_block", ItemUsedOnLocationTrigger.TriggerInstance.placedBlock(ModBlocks.DUPLICATOR_BLOCK))
.save(withConditions(consumer,
ResourceConditions.featuresEnabled(FeatureFlags.REDSTONE_EXPERIMENTS)), ExampleMod.id("experimental_duplication"));2
3
4
5
6
7
8
9
10
11







