Extensão de Enum
Aprenda a como adicionar entradas aos Enums com Mixin e Modificadores de Classes.
Extensão de Enum é um recurso do Mixin que pode confiavelmente adicionar novas entradas a um Enum.
Ao ter Enums do Minecraft como alvo, você pode usar Mixins com modificadores de classes para exibir novas entradas de Enum no código-fonte descompilado. Se isso for configurado para ser transitivo, mods que dependem do seu também verão as entradas adicionadas.
WARNING
Extensão de Enum requer pelo menos Loader 0.19.0 para suporte de Mixin e pelo menos Loom 1.16 para suporte de modificador de classe.
Além disso, os cabeçalhos dos arquivos de modificadores de classe devem especificar v2 como a versão para usar extensões de Enum.
Criando o Mixin
Antes de criar a classe mixin, certifique-se que o Loader 0.19.0 ou superior é uma dependência explicita no seu arquivo fabric.mod.json:
...
"depends": {
...
"fabricloader": ">=0.19.0"
...
}
...Ainda se você estiver usando a versão correta como uma dependência do Gradle, você deve explicitamente depender da versão 0.19.0 ou superior para habilitar esse recurso de Mixin.
Para criar uma extensão de Enum, crie um enum no seu pacote de mixin, anote-o com @Mixin e adicione suas constantes a ele como se eles fossem parte da classe de Enum-alvo. Por exemplo, vamos adicionar uma nova entrada à RecipeBookType:
@Mixin(RecipeBookType.class)
enum RecipeBookTypeMixin {
EXAMPLE_MOD_RECIPE_BOOK_TYPE
}2
3
4
IMPORTANTE
Você sempre deve prefixar as contantes de Enum que você adiciona com o ID do seu mod para garantir unicidade. Para esses documentos, nós usaremos EXAMPLE_MOD_.
Passando Argumentos de Construtor
Se o Enum alvo não possui um construtor padrão, você deve fazer um shadow do construtor da classe-alvo e passar os argumentos necessários para a sua declaração de entrada adicionada.
Por exemplo, vamos adicionar uma nova entrada RecipeCategory. Crie um construtor que combina com o construtor desejado na classe-alvo e anote-o com @Shadow.
@Mixin(RecipeCategory.class)
enum RecipeCategoryMixin {
EXAMPLE_MOD_RECIPE_CATEGORY("exampleModRecipeFolderName");
@Shadow
RecipeCategoryMixin(String recipeFolderName) {
}
}2
3
4
5
6
7
8
Implementando Métodos Abstratos
Para implementar um método-alvo abstrato de Enum, faça um shadow do método abstrato, e então sobrescreva-o e implemente-o na sua entrada adicionada. Por exemplo, vamos adicionar uma nova entrada ConversionType::
@Mixin(ConversionType.class)
enum ConversionTypeMixin {
EXAMPLE_MOD_CONVERSION_TYPE(false) {
@Override
void convert(Mob from, Mob to, ConversionParams params) {
// ...
}
};
@Shadow
abstract void convert(Mob from, Mob to, ConversionParams params);
@Shadow
ConversionTypeMixin(final boolean discardAfterConversion) {
}
}2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Acessando o Ordinal do Enum Atual
Você pode precisar pegar o ordinal da sua entrada Enum adicionada para passá-la a um construtor. Para fazer isso, o Mixin fornece o método MixinIntrinsics.currentEnumOrdinal(), que retorna o índice correto enquanto considera as contribuições dos outros mods.
Como um exemplo, vamos criar um mixin para o IllagerSpell da versão vanilla e adicionar um feitiço, cuja ordinal é passada como o primeiro argumento do construtor:
@Mixin(targets = "net.minecraft.world.entity.monster.illager.SpellcasterIllager$IllagerSpell")
enum IllagerSpellMixin {
EXAMPLE_MOD_ILLAGER_SPELL(MixinIntrinsics.currentEnumOrdinal(), 0.8, 0.8, 0.2);
@Shadow
IllagerSpellMixin(final int id, final double red, final double green, final double blue) {
}
}2
3
4
5
6
7
8
Agora você pode ter certeza que currentEnumOrdinal() retornará o índice correto, mesmo se outro mod também estendesse esse mesmo Enum.
Criando a Entrada do Modificador de Classe
Se você está tendo como alvo um Enum do Minecraft, você pode usar uma entrada de modificador de classe para visivelmente modificar o Enum alvo no código-fonte descompilado.
Para optar usar esse recurso, lembre-se de usar Loom 1.16 ou superior e de definir a versão do cabeçalho do arquivo para v2.
A sintaxe para uma entrada de extensão de Enum é:
extend-enum <targetClassName> <ENUM_CONSTANT_NAME>Para modificação de classe, as classes usam os seus nomes internos.
Por exemplo, o modificador de classe para a contante RecipeBookType que nós adicionamos na seção de mixin seria:
extend-enum net/minecraft/world/inventory/RecipeBookType EXAMPLE_MOD_RECIPE_BOOK_TYPEAplicando Mudanças
Para visualizar as entradas de Enum adicionadas no código-fonte descompilado, você deve recarregar o seu projeto do Gradle e regenerar fontes. Tenha certeza de reabrir qualquer classe-alvo do código-fonte descompilado para ver as modificações.
TIP
Se as modificações não aparecem, você pode tentar validar o arquivo e verificar se algum erro aparece.
INFO
Você não verá argumentos de construtor passados, implementação de métodos ou outros elementos no código-fonte descompilado. Isso porque esses são tratados pelo mixin e são apenas aplicados durante o runtime.
Você agora pode usar a contante de Enum no seu código:
void exampleRecipeBookTypeMethod(RecipeBookType recipeBookType) {
if (recipeBookType == RecipeBookType.EXAMPLE_MOD_RECIPE_BOOK_TYPE) {
// ...
}
}2
3
4
5
Se você está apenas a adicionando com um mixin e ela não está no código-fonte descompilado, você pode verificar comparando os nomes:
void exampleRecipeBookTypeMethodNoCT(RecipeBookType recipeBookType) {
if (recipeBookType.name().equals("EXAMPLE_MOD_RECIPE_BOOK_TYPE")) {
// ...
}
}2
3
4
5
Se você precisa usar a constante em múltiplas áreas, obtenha ela ao chamar valueOf e armazenando o resultado em um campo:
public static final RecipeBookType ADDED_RECIPE_BOOK_TYPE = RecipeBookType.valueOf("EXAMPLE_MOD_RECIPE_BOOK_TYPE");Armadilhas Comuns
Extensões de Enum não podem garantir que as entradas que você adiciona não quebrarão nada.
É a sua responsabilidade revisar os usos do Enum-alvo e tentar prevenir problemas quando possível. Se você está incapaz de resolver algum, e ocorrem travamentos, pode ser melhor não usar nenhuma extensão de Enum.
Essa seção fala sobre padrões para ficar de olho e evitar ao estender Enums, mas isso não é exaustivo.
Trocar Expressões
Instruções switch são frequentemente usados para lidar com constantes de Enum. Por conta disso, um travamento pode acontecer se uma expressão switch não lida com entradas adicionadas por outros mods. Por exemplo, suponha que nós temos a seguinte expressão switch:
void exampleProblematicSwitch(RecipeBookType recipeBookType) {
String s = switch (recipeBookType) {
case SMOKER -> "smoker";
case CRAFTING -> "crafting";
case FURNACE -> "furnace";
case BLAST_FURNACE -> "blast_furnace";
case EXAMPLE_MOD_RECIPE_BOOK_TYPE -> "example_mod_recipe_book_type";
};
// ...
}2
3
4
5
6
7
8
9
10
Note como não há uma clausula default. Mesmo que nós tenhamos lidado com todos os valores no Enum Vanilla e com os nossos próprios, isso lançaria uma exceção caso outro mod adicionasse uma entrada diferente.
Como você pode prevenir isso? Não há uma maneira universal de evitar travamentos - a sua abordagem deve ser adaptada dependendo do caso. Porém, de modo geral:
- Se a expressão
switchestá em um método vanilla, você pode usar um mixin para editá-la - Se a expressão
switchvem de um mod, você deve tentar entrar em contato com os desenvolvedores, para desenvolver juntos uma abordagem compatível. Caso contrário, você pode ter que criar um mixin para o outro mod.
Enums Serializados
Certas entradas de Enum são serializadas automaticamente. Um exemplo é o Enum Variants na classe Axolotl.
Estendendo essas Enums serializaria a sua entrada customizada no namespace do Minecraft, e em algumas versões isso pode acontecer baseado no ID númerico. Isso não é bom porque pode afetar os indices de todas as outras entradas.
É melhor evitar estender Enums se as suas entidades são serializadas desse jeito. Em vez disso, você pode querer procurar por uma API, caso disponível.






