Tutorial de Código do Game Hub 0 - Chinês

Fluxo Geral do Segmento (Pode ser usado como prompt para gerar código):

I. Lógica de Movimento do Jogador e Geração de UI

1. O componente GameLogic atua como o gerenciador da lógica central do jogo. Todos os eventos são passados para o GameLogic e distribuídos por ele para os componentes correspondentes, reduzindo o acoplamento do código.
2. Quando o jogador se aproxima de um "invocador" com um BoxCollider, seu componente Transponder transmite o evento de aproximação do jogador para o componente GameLogic. O componente UIFactory instancia um painel de UI para inserir o prompt.
3. O painel de UI montará o componente InputDialog, que monitora a entrada do teclado do jogador. Quando o jogador pressiona Enter, a caixa de entrada é ativada e assume o controle da entrada do teclado. Após o jogador terminar de digitar, pressionar Enter novamente passa os dados de entrada do jogador como um evento para o GameLogic.
4. Quando o jogador se afasta do "invocador", o painel de UI é destruído.

II. Geração de Modelo e Mapeamento de Esqueleto (Fornecido pelo TripoSDK)

1. Após o GameLogic receber o prompt do jogador, ele passa o prompt para o componente TripoClient (requer a entrada da TripoAPIKey).
2. O TripoClient chamará o componente TripoAPI, que passará o prompt para o servidor Tripo. Neste ponto, o TripoAPI completará a montagem da requisição, o envio da requisição e a sondagem da resposta do servidor. Em caso de resposta bem-sucedida, o servidor retornará o TaskID do modelo. Após a geração do modelo, o TripoAPI passará novamente o TaskID do modelo para o servidor Tripo para gerar o esqueleto.
3. Após a conclusão do rigging do esqueleto, o TripoAPI passará a URL do modelo para o componente TripoClient. O TripoClient carregará e analisará o modelo no formato GLB usando o plugin GLTFfast.
4. Em seguida, o componente RuntimeHumanoidAvatarBuilder será anexado ao modelo. Este componente mapeará o esqueleto do modelo no formato GLB para o sistema UnityAvatar, permitindo o retargeting de animação.
5. Finalmente, o TripoClient instanciará o modelo na cena. Neste ponto, os desenvolvedores podem usar os recursos de animação humanoides existentes para animar o modelo.

III. Seção de Transição de Controle

O GameLogic monitorará a entrada do teclado do jogador, trocando a prioridade da câmera entre o modelo e o jogador, bem como o alvo de resposta do ThirdPersonController. Quando o jogador pressiona a tecla F, ele pode operar o modelo. Pressionar F novamente fará com que o jogador saia do modelo. Para o jogo, o modelo pode ser extremamente grande ou pequeno, permitindo que o jogador passe por diferentes obstáculos, e também pode servir como uma alternativa de aparência, implementando sistemas semelhantes de criação de personagens ou skins de baixo custo.

Lógica Geral do Código:
GameObjects Principais

Etapas de Implementação Detalhadas:

• Versão: unity2022.3.55

• O código-fonte e a cena estão localizados em Assets-LowPoly Environment Pack-Demo-Demo1 dos arquivos-fonte.

Configuração do Projeto e Importação de Recursos:

1. Criar Novo Projeto
Abrir o Unity, clicar em New Project (Novo Projeto).
Selecionar o pipeline URP (Universal Render Pipeline), nomear como TripoRuntimeTutorial, e clicar em Create para criar.
2. Importar Pacotes de Recursos
Abrir o navegador, pesquisar Unity Asset Store. Na Unity Asset Store, pesquisar e baixar os seguintes recursos (todos gratuitos), que também podem ser encontrados nos arquivos do projeto fornecidos:
Starter Assets - ThirdPerson Produzido oficialmente pela Unity, fornece controle básico de personagem em terceira pessoa (se for solicitado para reiniciar na primeira importação, siga as instruções e importe novamente após o reinício).
Military FREE - Low Poly 3D Models Pack Fornece recursos de props de cena.
LowPoly Environment Pack Para construir a base do cenário do deserto.
Adicionar aos Meus Recursos e, nas janelas pop-up subsequentes, clicar em Abrir no Unity e baixar.
Após o download, clicar no menu superior do Unity Assets > Import Package > Custom Package, importar os pacotes de recursos acima um por um, e clicar em Import para todos.
3. Converter para Materiais URP
Filtrar todos os arquivos Material, ou selecionar todos os modelos anormais rosa na cena, ir em Editor - Rendering - Materials - Convert to URP Materials, para converter os materiais para materiais URP.
4. Baixar a biblioteca de dependência glTFast (para analisar modelos GLB)
Método um: Baixar via Git (requer ambiente Git na máquina)
Clicar no menu superior Window > Package Manager, na janela pop-up clicar em + > Add package from git URL. Inserir a URL: https://github.com/atteneder/glTFast.git e clicar em Add (Adicionar), aguardar a importação do plugin glTFast.
Método dois: Baixar o plugin Unity no site oficial da Tripo, que inclui o plugin glTFast
Na página inicial do site oficial, em "recursos", encontrar o plugin Unity, baixar e importar para o Unity seguindo o vídeo tutorial incluído no pacote.
5. Abrir a Cena Base
Na lista de arquivos à esquerda do Unity, encontrar o caminho Assets > LowPoly Environment Pack > Demo > Demo1, clicar duas vezes para abrir a cena. Arrastar alguns modelos (como tanques, pedras) da pasta Assets > ithappy para a cena, para configurar um ambiente simples.

Implementação do Controle de Movimento do Jogador: Permitir que o Jogador se Mova na Cena

1. Adicionar Prefabs Relacionados ao Jogador
Na lista de arquivos à esquerda do Unity, encontrar o caminho Assets > StarterAsset > ThirdPersonController > Prefabs. Arrastar os três prefabs seguintes para a cena:
MainCamera (Câmera Principal)
PlayerFollowCamera (Câmera de Seguimento do Jogador)
PlayerArmature (Modelo do Personagem do Jogador)
2. Configurar Parâmetros da Câmera
Selecionar a PlayerFollowCamera na cena, no painel de propriedades à direita (Inspector), encontrar o componente CinemachineVirtualCamera. Definir os campos Follow e Look At para PlayerCameraRoot, que está sob PlayerArmature (pode ser encontrado nos objetos filhos de PlayerArmature).
Acima estão os scripts de controle de terceira pessoa fornecidos oficialmente pela Unity. Neste ponto, clicar no botão Play (Reproduzir) da barra de ferramentas do Unity, usar as teclas WASD para mover o personagem, e o personagem e a câmera deverão seguir o movimento normalmente.

Geração do Painel de Prompt: Exibir o Painel de Entrada Quando o Jogador se Aproxima de um Objeto Específico, e Ocultar ao Sair

1. Criar Área de Disparo
Em Assets-ithappy-Military FREE-perfab, selecionar um modelo (como um tanque), clicar com o botão direito no modelo > Create Empty Child (Criar Filho Vazio), nomear como Trigger.
Selecionar Trigger, no painel de propriedades à direita, clicar em Add Component > Box Collider, para adicionar um colisor.
Marcar a opção Is Trigger (Disparador), clicar em Edit Collider, arrastar os manipuladores do colisor na cena para que seu tamanho seja o dobro do modelo (cobrindo a área ao redor do modelo).
2. Escrever Script de Evento de Disparo
Clicar com o botão direito na lista de arquivos Assets > Create > C# Script à esquerda do Unity, nomear como Transponder, e abrir o script com o Cursor. Queremos que, quando o jogador entra ou sai do colisor, uma mensagem seja passada para o nosso componente GameLogic. No Cursor, selecionar o modelo e inserir nosso prompt de referência:

Por favor, gere um script C# para Unity que implemente eventos de disparo quando o jogador entra/sai de um colisor.

Requisitos: O nome do componente é Transponder. Quando um GameObject com a Tag "Player" entra no colisor, o evento OnPlayerEnter é disparado. Quando o jogador sai, o evento OnPlayerExit é disparado.

Após salvar o script, arrastar o script Transponder para o objeto Trigger.
3. Criar Gerenciador de Lógica do Jogo
Na cena, clicar com o botão direito > Create Empty, nomear como GameLogicManager, para servir como contêiner de componentes lógicos.
Sob GameLogicManager, criar um objeto filho vazio, nomear como GameManager.
Criar um segundo script, nomear como GameManager, para lidar com a lógica principal do jogo.
Referenciamos o componente Transponder e então monitoramos os eventos de entrada e saída do jogador. O prompt de referência é o seguinte:

Por favor, gere um script C# para Unity com o nome do componente GameManager.

Requisitos: Monitorar os eventos OnPlayerEnter e OnPlayerExit do Transponder. Quando OnPlayerEnter for disparado, chamar o script UIFactory para instanciar o prefab da UI de prompt. Quando OnPlayerExit for disparado, destruir este prefab da UI.

Após salvar o script, arrastar o script GameManager para o objeto GameManager e arrastar o componente Transponder para o campo Transponder. Isso completa o monitoramento dos eventos de entrada e saída do jogador.
4. Criar Prefab do Painel de UI
Clicar com o botão direito no painel Hierarchy (lista de objetos da cena) > UI > Panel, para criar um painel de UI.
Sob o painel, criar dois objetos filhos: Text (Texto de Dica) e InputField (Campo de Entrada), ajustar suas posições e tamanhos (pode ser visualizado na janela Game).
Selecionar o painel inteiro, arrastar para a pasta Assets na lista de arquivos à esquerda do Unity, para gerar um prefab (nomeado como InputDialogPrefab).
Nota: Se usar Unity TextMeshPro, será necessário gerar um asset de fonte que suporte chinês, caso contrário, os caracteres chineses serão exibidos como quadrados. Você também pode usar diretamente o asset NotoSansSC SDF que fornecemos, e simplesmente mudar a fonte no componente Text para NotoSansSC SDF.
5. Escrever o Script InputDialog: Inicialização do Painel de UI e Monitoramento da Entrada do Teclado do Jogador
Criar o script InputDialog, no Cursor, inserir o prompt de referência:

Por favor, gere um script C# para Unity com o nome do componente InputDialog.

Requisitos: Criar um sistema de diálogo com caixa de entrada TMP, incluindo TMP_Text para exibir o prompt e TMP_InputField para receber a entrada.

Alternar entre dois modos usando a tecla Enter:

Primeiro Enter: Ativa a caixa de entrada e desabilita o controlador de movimento do jogador (como ThirdPersonController).

Segundo Enter: Envia o conteúdo da entrada e destrói o diálogo.

Manter o foco quando a entrada estiver vazia.

Anexar o componente InputDialog ao prefab do painel de UI, e arrastar Text e InputField para as dependências do painel.
6. Escrever o Script UIFactory: Gerar o Painel de UI
Criar um novo script C#, nomear como UIFactory, com o objetivo de fornecer uma interface para gerar prefabs de UI, servindo como uma camada intermediária para evitar o acoplamento entre os códigos. O prompt de referência é o seguinte:

Criar um script C# chamado UIFactory para implementar a funcionalidade de geração de diálogo de UI no padrão Factory. Os requisitos específicos são: Com um prefab de UI existente, uma função recebe a posição e rotação para gerar a UI, instancia a UI na posição especificada e retorna o componente InputDialog da UI instanciada.

7. Associar Dependências de Componentes
Verificar novamente se as dependências dos componentes estão corretamente associadas. Confirmar que a Tag do PlayerArmature no painel Inspector está definida como Player.
Selecionar o objeto GameManager, no painel de propriedades à direita, arrastar e atribuir o campo Transponder para o componente Transponder no objeto Trigger na cena.
Arrastar e atribuir o campo UIFactory para o componente UIFactory no objeto GameLogicManager.
Após iniciar o jogo, aproximar-se do objeto com o Trigger configurado para ver o painel de UI. Ao se afastar, o painel de UI será automaticamente destruído. Observação: Nossos arquivos-fonte fixam a posição de geração do painel, por favor, modifique este valor de acordo com as propriedades Transform do Trigger selecionado. Ou defina o RenderMode do componente Canvas do prefab da UI para ScreenSpace-Overlay, para que a UI seja tratada como dados de espaço de tela, e não entre no espaço do mundo.

Submeter o Prompt para a Tripo API

Até este ponto, ainda não podemos submeter o prompt para o servidor Tripo. No entanto, o código que os desenvolvedores precisam escrever está basicamente concluído. As solicitações de rede subsequentes, geração de modelo, rigging de esqueleto, mapeamento e adaptação, e retargeting de animação, já foram implementados em scripts e serão integrados ao plugin Tripo For Unity no futuro.
É essencial criar um UIEvent na cena primeiro, caso contrário, a UI não responderá!

1. Importar Scripts do Plugin Tripo
Na lista de arquivos à esquerda do Unity, encontrar os scripts TripoClient.cs, TripoAPI.cs e RuntimeHumanoidAvatarBuilder.cs nos arquivos-fonte baixados, e arrastá-los para a pasta Assets/Scripts.
Os códigos acima, TripoClient e TripoAPI, lidam com o envio e recebimento de requisições de rede, e RuntimeHumanoidAvatarBuilder mapeia o esqueleto do modelo para o sistema de esqueletos do Unity. TripoClient e TripoAPI são versões simplificadas do plugin Tripo For Unity, e completam a funcionalidade de rigging de esqueleto. Esta versão também será atualizada em breve, e então terá um processo ainda mais conveniente.
2. Criar Objeto Cliente Tripo
Sob GameLogicManager, criar um objeto filho vazio, nomear como TripoClient.
Arrastar os scripts TripoClient.cs e TripoAPI.cs para este objeto.
No painel de propriedades à direita, encontrar o campo API Key do componente TripoClient e inserir sua chave de API Tripo (é necessário registrar uma conta no site oficial da Tripo com antecedência; os usuários têm 600 pontos gratuitos por mês).
3. Associar Lógica de Passagem de Prompt
Devido à adição de eventos de entrada do jogador, precisamos adicionar lógica de escuta para o GameManager. Neste ponto, o código do GameManager já deve estar monitorando os eventos OnPlayerEnter e OnPlayerExit.
O exemplo de código fornecido já define funções de callback quando o GameManager faz uma chamada de instanciação para o UIFactory. Existem outras soluções, claro, mas neste exemplo, o prompt de exemplo para completar esta parte da lógica é o seguinte. Note que, se houver dependências entre componentes, é melhor fornecer o código gerado anteriormente como contexto para a IA:
No script GameManager, adicionar lógica: quando OnPlayerEnter é disparado, chamar o UIFactory para instanciar o prefab InputDialog anterior. Quando OnPlayerExit é disparado, destruir o prefab gerado. Após o jogador confirmar a entrada, passar o prompt do jogador para o script TripoClient existente, usando o exemplo de chamada tripoClient.TextToModel(prompt, pos);. Modificar os scripts relacionados.
Abrir o script GameManager.cs, encontrar o método OnPromptConfirmed (função que lida com a confirmação da entrada), e completar o código interno. Nota: Garantir que o campo tripoClient já esteja atribuído ao objeto TripoClient no componente GameManager.
4. Criar Contêiner de Modelo
Na cena, criar um objeto