Gerenciador de Pacotes Unity

Unity é uma plataforma que já existe há algum tempo e está em constante evolução. Porém, ao trabalhar nele com vários projetos ao mesmo tempo, você ainda pode encontrar dificuldades no uso de fontes comuns (.cs), bibliotecas (.dll) e outros ativos (imagens, sons, modelos, pré-fabricados). Neste artigo falaremos sobre nossa experiência com uma solução nativa para esse problema para Unity.

Métodos de distribuição de recursos compartilhados

Há mais de uma maneira de utilizar recursos compartilhados para diferentes projetos, mas cada abordagem tem seus prós e contras.

1. Duplicação – duplicamos recursos entre projetos “manualmente”.

Prós:

• Adequado para todos os tipos de recursos.
• Sem problemas de dependência.
• Não há problemas com GUIDs de ativos.

Contras:

• Repositórios gigantes.
• Não há possibilidade de versionamento.
• Dificuldade em rastrear alterações em recursos compartilhados.
• Dificuldade em atualizar recursos compartilhados.

2. Submódulos Git — distribuição de recursos partilhados através de submódulos externos.

Prós:

• Você pode trabalhar com as fontes.
• Você pode distribuir ativos.
• Sem problemas de dependência.

Contras:

• É necessária experiência em Git.
• O Git não é muito amigável com arquivos binários - você terá que conectar o LFS.
• Controle de acesso para repositórios.
• Dificuldade com atualização e downgrade de versões.
• Colisões de GUID são possíveis e não há um comportamento claro por parte do Unity para resolvê-las.

3. NuGet - distribuição de bibliotecas compartilhadas por meio de pacotes NuGet.

Prós:

• Trabalho conveniente com projetos que não dependem do Unity.
• Controle de versão conveniente e resolução de dependências.

Contras:

• O Unity não pode funcionar com pacotes NuGet prontos para uso (no GitHub você pode encontrar o NuGet Package Manager para Unity, que corrige isso, mas há algumas nuances).
• Dificuldades na distribuição de outros tipos de ativos.

4. Unity Package Manager - distribuição de recursos compartilhados através de uma solução nativa para Unity.

Prós:

• Interface nativa para trabalhar com pacotes.
• Proteção contra substituição de arquivos .meta em pacotes devido a conflitos de GUID.
• Possibilidade de versionamento.
• Capacidade de distribuir todos os tipos de recursos para Unity.

Contras:

• Conflitos de GUID ainda podem ocorrer.
• Não há documentação para implementação.

O último método tem mais vantagens do que desvantagens. No entanto, não é muito popular agora devido à falta de documentação e, portanto, iremos abordá-lo em detalhes.

Gerenciador de Pacotes Unity

Unity Package Manager (UPM) é uma ferramenta de gerenciamento de pacotes. Foi adicionado no Unity 2018.1 e usado apenas para pacotes desenvolvidos pela Unity Technologies. Porém, a partir da versão 2018.3, tornou-se possível adicionar pacotes personalizados.

Interface do Gerenciador de Pacotes Unity

Os pacotes não vão para as fontes do projeto (diretório Assets). Eles estão em um diretório separado %projectFolder%/Library/PackageCache e não afetam de forma alguma o projeto, sua única menção no código-fonte está no arquivo packages/manifest.json.

Pacotes no sistema de arquivos do projeto

Fontes de pacotes

O UPM pode usar diversas fontes de pacotes:

1. Sistema de arquivos.

Prós:

• Velocidade de implementação.
• Não requer ferramentas de terceiros.

Contras:

• Dificuldade em versionamento.
• O acesso compartilhado ao sistema de arquivos é necessário para todos que trabalham com o projeto.

2. Repositório Git.

Prós:

• Tudo que você precisa é de um repositório Git.

Contras:

• Você não pode alternar entre versões por meio da janela do UPM.
• Não funciona com todos os repositórios Git.

3. repositório npm.

Prós:

• Suporta totalmente a funcionalidade UPM e é usado para distribuir pacotes oficiais do Unity.

Contras:

• Atualmente ignora todas as versões de strings de pacotes, exceto "-preview".

Abaixo veremos a implementação do UPM + npm. Este pacote é conveniente porque permite trabalhar com qualquer tipo de recurso e gerenciar versões de pacotes, além de oferecer suporte total à interface UPM nativa.

Você pode usá-lo como um repositório npm Verdácio. Há um detalhado a documentação, e apenas alguns comandos são necessários para executá-lo.

Configurando o ambiente

Primeiro você precisa instalar node.js.

Criando um pacote

Para criar um pacote, você precisa colocar o arquivo package.json, que irá descrevê-lo, para o diretório com o conteúdo deste pacote. Você precisa fazer o seguinte:

Vá para o diretório do projeto que queremos criar um pacote.

Execute o comando npm init e insira os valores necessários durante a caixa de diálogo. Para nome, especifique o nome no formato de domínio reverso, por exemplo com.plarium.somepackage.
Para exibir convenientemente o nome do pacote, adicione a propriedade displayName a package.json e preencha-a.

Como o npm é orientado a js, o arquivo contém as propriedades principais e de scripts que não precisamos, que o Unity não usa. É melhor removê-los para não confundir a descrição do pacote. O arquivo deve ser parecido com isto:

1. Vá para o diretório do projeto que queremos criar um pacote.
2. Execute o comando npm init e insira os valores necessários durante a caixa de diálogo. Para nome, especifique o nome no formato de domínio reverso, por exemplo com.plarium.somepackage.
3. Para exibir convenientemente o nome do pacote, adicione a propriedade displayName a package.json e preencha-a.
4. Como o npm é orientado a js, o arquivo contém as propriedades principais e de scripts que não precisamos, que o Unity não usa. É melhor removê-los para não confundir a descrição do pacote. O arquivo deve ser parecido com isto:

   {
    "name": "com.plarium.somepackage",
    "displayName": "Some Package",
    "version": "1.0.0",
    "description": "Some Package Description",
    "keywords": [
      "Unity",
      "UPM"
    ],
    "author": "AUTHOR",
    "license": "UNLICENSED"
   }

5. Abra o Unity e gere um arquivo .meta para package.json (o Unity não vê ativos sem arquivos .meta, os pacotes para Unity são abertos somente leitura).

Enviando um pacote

Para enviar o pacote você precisa executar o comando: npm publish --registry *адрес до хранилища пакетов*.

Instalando e atualizando pacotes via Unity Package Manager

Para adicionar um pacote a um projeto Unity, você precisa:

1. Adicionar ao arquivo manifest.json informações sobre a origem dos pacotes. Para fazer isso você precisa adicionar a propriedade scopedRegistries e indicar os escopos e o endereço de origem onde os escopos específicos serão pesquisados.

   
   "scopedRegistries": [
      {
        "name": "Main",
        "url": "адрес до хранилища пакетов",
        "scopes": [
          "com.plarium"
        ]
      }
    ]
   

2. Vá para o Unity e abra a janela do Gerenciador de Pacotes (trabalhar com pacotes personalizados não é diferente de trabalhar com pacotes integrados).
3. Selecione todos os pacotes.
4. Encontre o pacote que você precisa e adicione-o.

Trabalhando com fontes e depuração

Para que as fontes sejam conectadas ao projeto, é necessário criar Definição de montagem para o pacote.

O uso de pacotes não limita suas opções de depuração. Porém, ao trabalhar com pacotes no Unity, você não pode ir para o IDE clicando em um erro no console se o erro ocorreu no pacote. Isso se deve ao fato do Unity não ver os scripts como arquivos separados, pois ao utilizar a Definição de Assembly eles são coletados em uma biblioteca e incluídos no projeto. Ao trabalhar com fontes de um projeto, clicar no IDE está disponível.

Script em um projeto com um pacote conectado:

Script do pacote com um ponto de interrupção funcional:

Correções urgentes em pacotes

Os pacotes Unity adicionados a um projeto são somente leitura, mas podem ser editados no cache de pacotes. Para fazer isso você precisa:

1. Vá para o pacote no cache de pacotes.

   

2. Faça as alterações necessárias.
3. Atualizar versão no arquivo package.json.
4. Enviar pacote npm publish --registry *адрес до хранилища пакетов*.
5. Atualize a versão do pacote para a versão corrigida por meio da interface do UPM.

Conflitos de importação de pacotes

Os seguintes conflitos de GUID podem ocorrer ao importar pacotes:

1. Pacote - pacote. Se, ao importar um pacote, for descoberto que pacotes já adicionados contêm ativos com o mesmo GUID, os ativos com GUIDs correspondentes do pacote importado não serão adicionados ao projeto.
2. Um pacote é um projeto. Se, ao importar um pacote, for descoberto que o projeto contém ativos com GUIDs correspondentes, os ativos do pacote não serão adicionados ao projeto. Porém, os ativos que dependem deles passarão a utilizar ativos do projeto.

Transferindo ativos de um projeto para um pacote

Se você transferir um ativo de um projeto para um pacote enquanto o Unity estiver aberto, sua funcionalidade será preservada e os links em ativos dependentes começarão a usar o ativo do pacote.

É importante: Ao copiar um ativo de um projeto para um pacote, ocorrerá o conflito “Pacote - Projeto” descrito na seção acima.

Possíveis soluções para conflitos

1. Reatribuir GUIDs usando nossos próprios algoritmos ao importar todos os ativos para eliminar colisões.
2. Adicionar todos os ativos a um projeto e depois dividi-los em pacotes.
3. Criação de um banco de dados contendo os GUIDs de todos os ativos e realização de validação no envio de pacotes.

Conclusão

UPM é uma nova solução para distribuição de recursos compartilhados no Unity, que pode ser uma alternativa válida aos métodos existentes. As recomendações descritas no artigo foram baseadas em casos reais. Esperamos que você os considere úteis.

Fonte: habr.com