Pular para o conteúdo principal

Antes de começar!

FreeMinecraftModels (FMM) está atualmente em desenvolvimento ativo! Isso significa que alguns recursos ainda não estão concluídos e estão sendo ativamente trabalhados.

No entanto, neste momento, o núcleo do plugin está totalmente funcional - conversão de arquivos bbmodel, geração de resource packs, spawn de entidades no jogo e gerenciamento de suas animações, a capacidade de colocar props persistentes, está tudo funcionando em sua maior parte.

Considere apoiar o desenvolvimento em https://www.patreon.com/magmaguy !

O conteúdo do resource pack exportado é licenciado sob a licença CC0 pelo FreeMinecraftModels, sem direitos reservados. Você é livre para usar, distribuir e modificar para qualquer propósito sem restrições ou necessidade de atribuição.

Usando este plugin

O que o FreeMinecraftModels (FMM) pode fazer por administradores de servidores Minecraft?​

Ele pode:

  • Importar modelos .bbmodel ou fmmodel (formato customizado do FFM)
  • Gerar resource packs com modelos que excedem os limites normais de modelos de resource pack do Minecraft (até 112x112x112 unidades ou 7x7x7 blocos no jogo, funcionalmente ilimitado ao usar múltiplos bones)
  • Exibir esses modelos no jogo, enviando pacotes específicos compatíveis com bedrock para clientes bedrock, enquanto também envia display entities para clientes java 1.19.4+
  • Animar esses modelos como foram configurados para serem animados no Blockbench
  • Lidar com animações de estado padrão sem exigir outros plugins (walk, idle, death, attack, spawn)
  • Lidar com hitboxes que rotacionam com a entidade subjacente e têm um eixo x e z diferente
  • Gerenciar três tipos de modelos: static, dynamic e props
    • Props são persistentes e podem ser colocados no mundo de forma que persistam mesmo se o servidor for reiniciado, e é possível distribuir mapas com props para outros servidores
    • Modelos Dynamic são para modelos que precisam de uma entidade viva subjacente para funcionar, idealmente usados por plugins de chefes customizados ou plugins de pets
    • Modelos Static são para modelos não persistentes que não devem se mover, então basicamente decorações ou efeitos temporários

Como você adiciona um modelo existente?​

Para importar um modelo, basta arrastar o .bbmodel para a pasta imports e fazer /fmm reload. Isso gerará um arquivo .fmmodel na pasta models e adicionará o modelo ao resource pack na pasta outputs.

Você precisará usar esse resource pack para visualizar o modelo corretamente! É um resource pack normal, então tudo que você precisa fazer é colocá-lo na sua pasta de resource pack. Servidores Minecraft têm uma maneira de hospedar resource packs. Eu recomendo usar meu plugin, ResourcePackManager, que automaticamente pega os arquivos e os hospeda remotamente para você, até mesclando-os com os arquivos de outros plugins.

Como você visualiza o modelo no jogo?​

É importante notar que, embora o FreeMinecraftModels possa ser usado como um plugin autônomo para visualizar props (basicamente modelos customizados que você pode colocar no mundo), o plugin geralmente funciona melhor quando combinado com um plugin como EliteMobs onde os modelos são ativamente usados para algo concreto, neste caso lutas contra chefes.

Existem três tipos de modelos: static, dynamic e props.

  • Props são persistentes e podem ser colocados no mundo de forma que persistam mesmo se o servidor for reiniciado, e é possível distribuir mapas com props para outros servidores
  • Modelos Dynamic são para modelos que precisam de uma entidade viva subjacente para funcionar, idealmente usados por plugins de chefes customizados ou plugins de pets
  • Modelos Static são para modelos não persistentes que não devem se mover, então basicamente decorações ou efeitos temporários

Visualizando modelos static no jogo​

Para visualizar modelos static no jogo, use o comando /fmm spawn static <id> onde o id é o nome do arquivo do modelo, em letras minúsculas e sem a extensão do arquivo.

Visualizando modelos dynamic no jogo​

Para visualizar modelos dynamic no jogo, use o comando /fmm spawn dynamic <id> onde o id é o nome do arquivo do modelo, em letras minúsculas e sem a extensão do arquivo.

Visualizando props no jogo​

Para visualizar modelos dynamic no jogo, use o comando /fmm spawn prop <id> onde o id é o nome do arquivo do modelo, em letras minúsculas e sem a extensão do arquivo.

O que o FreeMinecraftModels (FMM) pode fazer por modeladores?​

FMM segue as regras padrão de resource pack para geração de resource pack. Além disso, tenta ser o mais compatível possível com modelos compatíveis com ModelEngine, a fim de tentar padronizar a criação de modelos entre plugins.

Recursos / restrições de geração de modelos​

Se você já criou modelos para ModelEngine, estará familiarizado com muitas das restrições de geração de resource pack do Minecraft:

Cubos:​

Cubos são os mesmos aqui como são no Blockbench, eles são os cubos que compõem o modelo.

  • Cubos podem ter até 112x112x112 "pixels" (unidades do Blockbench) ou 7x7x7 blocos no jogo (restrições normais do Minecraft contornadas usando tamanhos de display, em breve serão ainda mais contornadas para 1.19.4+ graças às display entities)
  • Rotações legais para cubos são 0, 22.5, -22.5, 45 e -45. Nenhuma outra rotação funciona.
  • Cubos rotacionam apenas em um eixo, o que significa que uma rotação de [22.5, 0, 0] está bem, uma rotação de [22.5, 0, 45] não funcionará completamente e rotacionará apenas em um eixo.

Bones:​

Bones são o que o Blockbench chama de "groups". Eles servem para agrupar os cubos juntos, e devem ser usados para agrupar bones juntos para animationsBlueprint.

  • Bones podem ter até 112x112x112 "pixels" (unidades do Blockbench) ou 7x7x7 blocos no jogo. Observe que o tamanho dos bones é definido pelo que eles têm, então se você tiver cubos que estão a mais de 7 blocos de distância, você provavelmente excederá este limite de tamanho. Contornar este limite é tão fácil quanto colocar os blocos em um boneBlueprint diferente não contido no primeiro boneBlueprint!
  • Podem ter qualquer rotação! No entanto, é recomendado evitar usar rotações padrão de 90, -90, 180 e -180, pois estas podem frequentemente levar a comportamento inesperado. Note que isso não se aplica realmente a animações, apenas à posição de repouso padrão dos bones.

Bones são significativamente mais flexíveis que cubos, mas você deve usar o menor número de bones possível! No FMM, devido às limitações do Minecraft, cada bone é uma entidade diferente. Em escala, isso afetará o desempenho rapidamente! Sempre use o menor número de bones possível e esteja atento a quantos desses modelos você está planejando spawnar - quanto mais você planeja ter, menos bones você deve ter!

Virtual Bones​

Virtual Bones é terminologia do model engine para bones que têm metadados específicos, geralmente na forma de um nome específico, que é usado para um propósito específico.

Os seguintes virtual bones foram implementados no FreeMinecraftModels:

  • Hitboxes / eye height: um bone chamado "hitbox" com um cubeBlueprint que define os limites, e tem o mesmo valor x e z (o maior valor será escolhido se não forem iguais) define a hitbox. O nível do olho é definido no pivot point do boneBlueprint da hitbox.
  • Name tag: um bone cujo nome começa com "tag_". Honestamente, eu preferiria ser mais específico aqui e usar " tag_name" para poder usar tags para outras coisas, mas isso será seriamente considerado depois.
  • Head: um bone cujo nome começa com h_ . Este é um virtual bone que é usado para definir a cabeça do modelo, que rotacionará com base na rotação da cabeça da entidade subjacente.

Distribuição de arquivos mais segura, fácil e não editável​

Uma coisa que o FMM tenta resolver é usuários reutilizando modelos que obtiveram para editá-los de maneiras que o criador do modelo não queria que editassem, especificamente para fazer reskin ou de outra forma alterar ligeiramente um modelo e potencialmente tentar revender como uma criação original.

Para esse fim, o FMM usa o formato de arquivo .fmmodel que visa reduzir os arquivos .bbmodel ao ponto em que eles podem ser usados pelo plugin, mas não podem ser editados no Blockbench.

Como modelador, você agora tem a escolha de liberar um arquivo .fmmodel não editável, um arquivo .bbmodel editável ou até mesmo fazer precificação diferencial ou termos de serviço de distribuição para os dois.

Gerar um .fmmodel é tão simples quanto colocar seu .bbmodel na pasta ~/plugins/FreeMinecraftModels/imports e recarregar o plugin com /fmm reload ou reiniciar o servidor. Seu .fmmodel estará então na pasta ~/plugins/FreeMinecraftModels/models.

O que o FreeMinecraftModels (FMM) pode fazer por desenvolvedores que desejam integrá-lo em seus plugins?​

FMM tem um repositório maven! Maven:


<repository>
    <id>magmaguy-repo-releases</id>
    <name>MagmaGuy's Repository</name>
    <url>https://repo.magmaguy.com/releases</url>
</repository>

<dependency>
<groupId>com.magmaguy</groupId>
<artifactId>FreeMinecraftModels</artifactId>
<version>LATEST.VERSION.HERE</version>
</dependency>

Gradle:

maven {
    name = "magmaguyRepoReleases"
    url = uri("https://repo.magmaguy.com/releases")
}

compileOnly group : 'com.magmaguy', name: 'FreeMinecraftModels', version: 'LATEST.VERSION.HERE'

Note que FreeMinecraftModels é destinado a ser usado como uma API, e exigirá a instalação do plugin no servidor. Não faça shade dele em seu plugin!

Uso da API​

FMM visa ser o mais fácil possível de usar como uma API.

No momento, se você deseja usar FreeMinecraftModels como uma API para ter acesso ao uso de modelos customizados, há apenas quatro classes que você precisa conhecer:

  • ModeledEntity - a classe base para todas as entidades
  • StaticEntity - para quando você quer usar um modelo static não permanente
  • DynamicEntity - para quando você quer disfarçar outra entidade viva com um modelo
  • PropEntity - para quando você quer colocar um modelo no mundo que persiste mesmo se o servidor for reiniciado

Aqui está um trecho para lidar com um modelo static:

import org.bukkit.Bukkit;

public class FreeMinecraftModelsModel {
    private StaticEntity staticEntity = null;

    //Create the model
    public FreeMinecraftModelsModel(String id, Location location) {
        //This spawns the entity!
        staticEntity = StaticEntity.create(id, location);
        //This checks if the entity spawned correctly
        if (staticEntity == null) Bukkit.getLogger().warning(("FMM failed to find a model named " + id + " !"));
    }

    public void remove() {
        //This removes the entity
        staticEntity.remove();
    }
}

Tenha em mente que modelos static são destinados a permanecer no lugar e atuar como um elemento decorativo em um local fixo ( animações não contam como 'movimento' aqui). Embora seja possível movê-los, considere se você pode preferir usar um modelo dynamic se esse for seu propósito.

E aqui está como o EliteMobs, meu plugin de chefes customizados, usa entidades dynamic:

package com.magmaguy.elitemobs.thirdparty.custommodels.freeminecraftmodels;

import com.magmaguy.elitemobs.thirdparty.custommodels.CustomModelInterface;
import api.com.magmaguy.freeminecraftmodels.ModeledEntityManager;
import customentity.com.magmaguy.freeminecraftmodels.DynamicEntity;
import lombok.Getter;
import org.bukkit.entity.LivingEntity;

public class CustomModelFMM implements CustomModelInterface {
    @Getter
    private DynamicEntity dynamicEntity;

    public CustomModelFMM(LivingEntity livingEntity, String modelName, String nametagName) {
        dynamicEntity = DynamicEntity.create(modelName, livingEntity);
        if (dynamicEntity == null) return;
        dynamicEntity.setName(nametagName);
    }

    public static void reloadModels() {
        ModeledEntityManager.reload();
    }

    public static boolean modelExists(String modelName) {
        return ModeledEntityManager.modelExists(modelName);
    }

    @Override
    public void shoot() {
        if (dynamicEntity.hasAnimation("attack_ranged")) dynamicEntity.playAnimation("attack_ranged", false);
        else dynamicEntity.playAnimation("attack", false);
    }

    @Override
    public void melee() {
        if (dynamicEntity.hasAnimation("attack_melee")) dynamicEntity.playAnimation("attack_melee", false);
        else dynamicEntity.playAnimation("attack", false);
    }

    @Override
    public void playAnimationByName(String animationName) {
        dynamicEntity.playAnimation(animationName, false);
    }

    @Override
    public void setName(String nametagName, boolean visible) {
        dynamicEntity.setName(nametagName);
        dynamicEntity.setNameVisible(visible);
    }

    @Override
    public void setNameVisible(boolean visible) {
        dynamicEntity.setNameVisible(visible);
    }

    @Override
    public void switchPhase() {
        dynamicEntity.stopCurrentAnimations();
    }
}

Modelos Dynamic são construídos em cima de uma entidade viva, que pode ser fornecida ao usar o método create como no exemplo acima, ou ao executar o método spawn em uma entidade Dynamic.

Contribuindo para o projeto FreeMinecraftModels (FMM) como desenvolvedor

FMM é distribuído sob a licença GPLV3 e contribuições de código são bem-vindas. Aqui estão as diretrizes básicas de contribuição:

  • Siga as convenções de nomenclatura existentes, mantenha o nível existente de verbosidade e adicione documentação suficiente para que sua contribuição seja fácil de entender
  • Mantenha as contribuições relevantes ao escopo do plugin. Se você não souber se será relevante, sinta-se livre para perguntar com antecedência.
  • Esteja atento ao impacto de desempenho do seu código. Algumas contribuições podem ser recusadas se forem muito não otimizadas ou causarem um impacto de desempenho muito grande.

Estrutura geral do plugin​

Para economizar seu tempo, aqui está uma rápida divisão do fluxo lógico do FMM:

  1. Lê a pasta imports
  2. Move arquivos da pasta imports para a pasta models. Se o arquivo for um .bbmodel, ele é convertido para .fmmodel na pasta models.
  3. Lê os arquivos na pasta models.
  4. Interpreta todas as estruturas de modelos, criando Skeletons que contêm grupos de Bones, e esses bones contêm grupos de Bones filhos e Cubes. Cubes e Bones geram os dados JSON do resource pack aos quais cada um está relacionado. Isso significa que Cubes geram o JSON específico para cubos e Bones geram o outline e arquivos individuais de boneBlueprint. Note que um boneBlueprint resulta em um arquivo de resource pack. Modelos são adicionados a uma lista conforme são gerados.
  5. Ainda no Skeleton, interpreta todas as Animations no modelo, se houver
  6. Todos os dados foram agora inicializados, o resource pack foi gerado na pasta outputs e o plugin está pronto para ser usado.

Truques usados neste plugin:​

Os truques usados aqui são bastante bem estabelecidos e padronizados, mas serão listados mesmo assim porque podem ser contraintuitivos.

Por favor, note que esses truques são completamente invisíveis para usuários e criadores de modelos; restrições e soluções alternativas são listadas apenas para ajudá-lo a entender como o FMM contorna várias limitações do Minecraft.

  • Todos os modelos são ampliados 4x e então o tamanho e o pivot point são reajustados no código para estender o tamanho máximo teórico do modelo
  • Como modelos de resource pack só podem ter modelos indo de -16 a +32 em tamanho, os modelos são deslocados em segundo plano. Isso é completamente invisível para os jogadores.
  • Armadura de cavalo de couro é usada para criar modelos com uma tonalidade que pode ser influenciada através de código (ou seja, para indicações de dano). A armadura de cavalo deve ser definida como branca para exibir as cores corretas!
  • Blockbench usa um sistema específico de IDs para as texturas, mas na verdade lê as texturas sequencialmente da configuração. IDs são atribuídos aqui com base em sua posição na lista de texturas, seguindo como o Blockbench faz.
  • Cada bone é uma entidade diferente devido às limitações do Minecraft
  • Armadura de cavalo de couro está no slot da cabeça do armor stand
  • Tanto armor stands quanto display entities são usados para os itens static padrão; clientes bedrock recebem os armor stands, e clientes 1.19.4+ recebem as display entities (clientes mais antigos receberão armor stands)

Contribuindo para o projeto FreeMinecraftModels (FMM) em geral

FMM é na verdade financiado coletivamente pelas pessoas adoráveis em https://www.patreon.com/magmaguy ! Todas as contribuições ajudam mais do que você imagina ;)

Recursos atualmente planejados:

  • Geração de RSP para cliente Bedrock
  • Gerenciamento de RSP com integração geyser
  • tag_projectile como meta bones dos quais projéteis podem ser disparados (pode ter mais de um por modelo)

Limitações estranhas atuais que seria bom corrigir:

  • A TransformationMatrix é uma bagunça, mas nenhuma solução melhor foi desenvolvida ainda. Elas precisam de algum trabalho de alguém que seja bom em matrizes.