Pesquisar em Unity

Seja mais do que celular

Aproveite a popularidade do Windows 10 e as novas oportunidades de mercado na Windows Store.

Guias de portabilidade

Introdução

A criação de jogos com Unity é cada vez mais popular, nomeadamente porque permite o acesso a múltiplas plataformas e tipos de dispositivos a partir de um único código. O mesmo acontece com a criação de jogos para Windows 10 com o Windows Platform Universal (UWP). Este white paper explica como usar o que você já sabe sobre Unity para criar jogos para UWP. Os tópicos incluem:

  • compilar seu jogo para UWP
  • compreender as melhores práticas do ambiente Windows
  • implementar recursos específicos da plataforma
  • compreender os principais plug-ins
  • publicar na Windows Store

Para ilustrar os detalhes importantes necessários para portar um jogo Unity no UWP, usamos um jogo existente para ajudar a analisar os vários aspectos e considerações envolvidos na exportação para UWP e à subsequente implementação na Windows Store.

Nota: Este guia assume que você já está familiarizado com os conceitos básicos do Unity3D. Você pode aprender mais sobre como usar Unity3D a qualquer momento, consultando os Tutoriais Unity

Requisitos para escrever um jogo UWP com Unity

Para desenvolver, compilar e apresentar um jogo Unity à Windows Store, você vai precisar de:

  • Unity 5.3.5. Tanto a versão gratuita Unity como Unity Pro funcionam. Os add-ons para publicação na Windows Store são gratuitos para os usuários básicos e Unity Pro.
  • Visual Studio Você pode usar qualquer SKU Visual Studio, mesmo o gratuito Visual Studio Express. Para a Universal Windows Platform, você precisará Visual Studio 2015 Update 1.
  • Windows 10 Se você não possui uma licença do Windows 10, você pode obter uma versão teste de 90 dias. Se você estiver usando Mac OS X ou se instalar no hardware Apple, verifique as várias opções de instalação com Boot Camp, VMWare ou Parallels.
  • Conta Microsoft Você vai precisar de uma conta gratuita da Microsoft para obter uma licença de desenvolvedor.
  • Windows Store - conta de desenvolvedor. É necessária para implantar seu jogo na Windows Store. Durante este processo, você será registrado e verificado como um indivíduo ou empresa que pode enviar aplicativos e jogos para a loja. Este registro é partilhado com Windows Phone (um registro pode enviar aplicativos para ambas as lojas). Pode haver uma pequena taxa de inscrição para os indivíduos, mas as contas gratuitas Dev Center estão frequentemente disponíveis através de programas patrocinados pela Microsoft (por exemplo, para estudantes ou startups).
  • Dispositivos de teste Windows 10. O simulador pode simular multitoque e diferentes resoluções de tela, mas recomendamos testar em um dispositivo móvel ARM real com capacidade de toque se você estiver desenvolvendo uma experiência móvel / toque.

Este documento foi criado com o Unity 5.3.5, Visual Studio 2015 Update 2 e Windows 10 Versão 1511. Recomendamos usar Unity 5.3.2 e Visual Studio Update 1 ou versões superiores. As versões mais antigas podem ter uma interface de programação de aplicativos diferente e pode haver problemas de compatibilidade.

Windows Store

Windows Store tem agora um único lugar para apresentar e transferir seus aplicativos UWP. Você ainda pode usar dispositivos com sistemas operacionais mais antigos, mas neste documento nos concentramos em transferir seu jogo como um aplicativo UWP para a Windows Store.

NuGet

NuGet é o gerenciador de pacotes para a plataforma de desenvolvimento Microsoft, incluindo .NET. NuGet permite aos desenvolvedores encontrar bibliotecas de terceiros e adicioná-las a projetos como dependências. Você pode usar o NuGet para fornecer todas as bibliotecas do Windows que você precisa para usar nativamente. NuGet também pode ser usado para gerenciar DLLs que são chamados pelos seus scripts em Unity.

NuGet também é necessário para portar jogos Unity para UWP. Quando você exporta um projeto de Unity para um aplicativo Visual Studio UWP, Unity depende de NuGet para instalar todas as bibliotecas necessárias para o .NET Core.

Configurar Unity para implantar Windows Store

Nesta seção, você vai aprender o que é necessário para fazer de um jogo Unity existente numa aplicação pronta para implantação na Windows Store como jogo Universal Windows Platform (UWP). Os seguintes tópicos são abordados:

  • Habilitar o modo de desenvolvedor no Windows 10
  • Digitar os detalhes do jogo em Unity
  • Exportar para UWP no Windows 10
  • Criar solução no Visual Studio 2015 Update 2 com o Window 10 SDK
  • Associar o seu jogo com Windows Store
  • Adicionar imagens/conteúdos necessários (por exemplo, logotipo, ícone,splash) se ainda não tiver sido feito em Unity
  • Execute o Kit de Certificação de Aplicativos Windows (WACK)
  • Publicar na Windows Store

Habilitar o modo de desenvolvedor no Windows 10

A licença de desenvolvedor não é mais necessária para cada dispositivo que você deseja usar para desenvolver, instalar ou testar seu aplicativo. Em vez disso, agora você pode ativar um dispositivo apenas uma vez para estas tarefas na configuração do dispositivo.

Habilitar seus dispositivos Windows 10

Para o Windows 10, usando um desktop, tablet ou telefone, é necessário habilitar o dispositivo para o desenvolvimento em Configurações do Sistema.

Para fazer isso, vá até Configurações do Sistema e escolha “Update & security.” Em seguida selecione “For developers.” Aqui você pode selecionar e habilitar “Developer mode.”

Você pode encontrar mais detalhes sobre como fazer isso aqui.

Digitar os detalhes do jogo em Unity

Um dos primeiros passos na preparação de seu jogo para Unity é certificar-se que você tem as configurações de compilação corretas configuradas para ele.

Para compilar jogos Unity para aplicativos Universal Windows Platform (UWP), você precisa do seguinte:

Para definir as configurações em Unity, primeiro clique “File,” então em “Build Settings.”

Em seguida, clique em Player Settings… .

na janela Player Settings você pode então introduzir os seus dados de jogo.

Se você quiser, pode ainda adicionar um logotipo e imagens de tiles na Player Settings janela que será exibida na Windows Store. E tal como acontece com muitas coisas na criação de aplicativos Unity para a Windows Store, existem várias maneiras de fazer isso. Você pode igualmente adiar a adição de imagens via Unity IDE e fazê-lo mais tarde através de Visual Studio.

Suas configurações de compilação estão agora devidamente configuradas no Unity3D. Você pode exportar para UWP.

Exportar para Universal Windows Platform

Esta seção irá rever o suporte Unity existente para aplicativos Universal Windows Platform (UWP) e como exportar de Unity para UWP.

Unity3D teve suporte para aplicativos UWP desde Unity 5.2. Atualmente, você pode exportar para UWP, selecionando o SDK Universal 10 a partir da plataforma Windows Store na janela "Build Settings", como ilustrado abaixo:

Unity 5.3.5 exportará os arquivos de soluções de Visual Studio 2015, que podem então ser compiladas e executadas nos dispositivos Windows 10.

Três arquiteturas são suportadas: ARM, x86 e x64. Além disso, você pode usar .NET Core 5.0 em seus projetos de jogos.

Clique no botão Build na janela Build Settings para abrir uma janela Build Windows Store que permite selecionar uma pasta para compilar o seu jogo.

Após ter selecionado a pasta, Unity vai começar a compilar o seu jogo para a plataforma selecionada. Isso pode demorar alguns minutos se você tiver um jogo grande:

Uma janela do Windows Explorer agora deve exibir a pasta contendo todos os arquivos gerados por Unity.

Para mais detalhes sobre este processo, consulte a documentação Unity3D de Windows.

Solução de compliação no Visual Studio 2015 Update 2 com o SDK Windows 10

para vender ou distribuir o seu aplicativo Universal Windows Platform (UWP), você precisa criar um pacote appxupload Este pacote simplifica a venda de seu aplicativo no Windows Store ou distribuição a outros usuários. Quando você cria o appxupload outro pacote appx será gerado para testes e para sideloading. Você pode distribuir seu aplicativo diretamente transferindo o pacote appx para um dispositivo.

Para o Windows 10, você gera um único pacote (.appxupload) que pode ser carregado para Windows Store. Seu aplicativo pode então ser instalado e executado em qualquer dispositivo Windows 10.

Nota: Para criar um pacote de aplicativo para um aplicativo do Windows 8.1, siga estas instruções.

Agora você está pronto para compilar o seu jogo no Visual Studio.

Primeiro, selecione a plataforma x86 ou x64.

No menu, clique em Build -> Build Solution.

Permita que NuGet Package Manager restaure os pacotes.

Clique Run e assegure-se de ter selecionado Local Machine

Verifique o funcionamento clicando em “Build succeded”.

Uma vez feito isso, você pode vender seu aplicativo na Windows Store. Se você tem um aplicativo LOB (line-of-business) que você não pretende vender, porque é somente para uso interno, você pode transferir este aplicativo para instalá-lo em qualquer dispositivo Windows 10.

Para mais informações, consultar Packaging Universal Windows apps for Windows 10

Associe seu aplicativo com Windows Store

No Projetomenu, selecione Store -> Associate App with the Store....

Ao fazer isso, a maior parte dos campos na pestana Packaging do designer de manifestos será automaticamente atualizado. Os seguintes valores são transferidos para o arquivo do manifesto do aplicativo para o projeto atual em sua máquina local:

  • Package Display Name
  • Package Name
  • Publisher ID
  • Publisher Display Name
  • Versão

Se você substituir o arquivo padrão package.appxmanifest criando um arquivo personalizado .xml para o manifesto, não poderá associar sua aplicação com a Store. Se você tenta associar um arquivo de manifesto personalizado com a loja, verá uma mensagem de erro. Não se recomenda a criação de um package personalizado.

Para mais informações, consultar Aplicativos Packaging Universal Windows para Windows 10.

Como preparar-se para enviar seu aplicativo à Store

Uma vez que você tenha criado a sua aplicação, reservando um nome, você pode começar a trabalhar para a sua publicação. O primeiro passo é criar uma envio.

Você normalmente inicia a sua apresentação quando o seu aplicativo está completo e pronto para publicar. No entanto, você pode começar a inserir informações, mesmo antes de ter escrito uma única linha de código. A apresentação será salva no seu painel para que você possa trabalhar nele quando estiver pronto.

Após a publicação de seu aplicativo, você pode publicar uma versão atualizada criando outra apresentação em seu painel. Criar uma nova apresentação permite fazer e publicar as alterações necessárias quer você esteja carregando novos pacotes ou apenas alterando detalhes, como preço ou categoria.

Para criar uma nova apresentação de um aplicativo, clique em Update junto à apresentação mais recente mostrada na página de resumo do aplicativo.

Checklist da apresentação do aplicativo

Unity fornece-lhe os recursos mínimos necessários para a apresentação de um aplicativo, mas é recomendável que você forneça suas próprias imagens e recursos. O seguinte é uma captura de tela de secção de Visual Assets do arquivo Package.appxmanifest :

Você pode rever todos os recursos fornecidos pelo processo de compilação.

Para mais informações, consultar Apresentações de aplicativos no MSDN.

Execute o Kit de Certificação de Aplicativos Windows (WACK)

Para dar a seu aplicativo a melhor oportunidade de ser publicado na Windows Store, ou obter Certificação Windows validá-lo e testá-lo localmente antes de apresentá-lo para certificação. Este tópico mostra como instalar e executar o Kit de Certificação de Aplicativos Windows. WACK irá executar uma série de testes ao seu aplicativo para avaliar o desempenho e conformidade da API. Para mais detalhes sobre os testes específicos realizados por este kit, consulte os seguintes tópicos:

Pré-requisitos

Se você estiver desenvolvendo um aplicativo Universal Windows Platform (UWP), você deve...

Para instalar o KIt de Certificação de Aplicativo Windows, versão 10, que está incluído no kit de desenvolvimento Windows Software (SDK) para Windows 10, comece por criar um pacote de aplicativo para executar o teste. No menu Project, selecione Store -> Create App Packages…:

Ao concluir a criação do pacote, aparece a seguinte janela onde você pode lançar o Kit de certificação de Aplicativos Windows (WACK):

Ao lançar WACK, aparece o seguinte diálogo:

Clique Next para prosseguir com a validação. Não se assuste ao ver várias janelas pop-up. A ferramenta simplesmente executa o seu jogo e realiza testes, que podem demorar alguns minutos.

Uma vez concluídos os testes, aparece a seguinte janela. Se os testes falharam, você poderá analisá-los e efetuar correções para repetir o processo e passar os testes.

Clique no link “Click here to view the results” para abrir um navegador com os resultados do teste.

Aqui você pode consultar os resultados de todos os testes, identificar os problemas e corrigi-los. Após ter corrigido os problemas e re-executado os testes, você deve obter os seguintes resultados:

Para mais informações, consultar Uso do Kit de certificação do Aplicativo Windows no MSDN.

Publicar na Windows Store

Agora que o seu jogo está compilado e carregado, você precisa entrar em sua conta de desenvolvedor para apresentá-lo à loja. Siga os seguintes passos a fim de iniciar o processo de apresentação.

  1. Abra um navegador e vá para https://dev.windows.com.
  2. Entre na sua conta e clique no link Painel.
  3. Selecione o nome do pacote do aplicativo que você criou no Visual Studio.
  4. Clique em "Start your submission."
  5. Nesta próxima etapa, você precisa preencher informações sobre o seu jogo para poder apresentá-lo. Clique num destes links para abrir uma nova página que irá orientá-lo no processo de apresentação.

A Página de pacotes é onde você carrega todos os arquivos do pacote (.xap, .appx, .appxupload, e/ou .appxbundle) Para o aplicativo que você está apresentando. Você pode carregar pacotes para qualquer sistema operacional de seus aplicativos nesta etapa.

Quando um cliente faz o download do seu aplicativo, a Windows Store verifica todos os pacotes disponíveis para seu aplicativo e fornece automaticamente ao cliente o pacote mais adequado ao dispositivo.

Para obter detalhes sobre o que inclui um pacote e como ele deve ser estruturado, consulte Requisitos do pacote de aplicativos. Você também pode querer saber mais sobre...

Fazer upload de pacotes para a sua apresentação

Para fazer upload de pacotes, arraste-os para o campo de upload ou clique para navegar pelos seus arquivos. A Página de pacotes página vai deixar você fazer upload arquivos .xap, .appx, .appxupload, e/ou .appxbundle

Nota: Para o Windows 10, você deve carregar sempre o arquivo.appxupload aqui, não o .appx ou .appxbundle. Para mais informações sobre pacotes de aplicativos Universal Windows Platform (UWP) para a loja, ver Aplicativos Packaging Universal Windows para Windows 10.

Se forem detectados problemas com os seus pacotes ao validá-los, você deve removê-los, corrigir os problemas e carregá-los novamente. Para mais informações, consulte Resolver erros de upload de pacotes.

Implementação de referência

Nesta seção, nós faremos referência a um simples jogo de basquetebol em 3D escrito por Jb Evain no cenário Build em menos de 20 minutos. Se você gostaria de criar o jogo a partir do zero, você pode seguir a palestra de Jb. O único recurso externo que você vai precisar para criar o jogo é este arquivo Hoop.3ds

Se você preferir apenas fazer o download do pacote do projeto acabado, Basketball-At-Build.zip, está completo e jogável. Você poderá continuar com o resto desta seção uma vez extraído o arquivo compactado.

Esta é uma cena do jogo terminado:

Basquetebol

Nas próximas etapas, vamos usar um jogo para ilustrar as etapas descritas acima e prepará-lo para a apresentação na Windows Store.

Se você está compilando o jogo a partir do zero, você terá de seguir estas etapas. Se você tiver baixado o projeto concluído, você pode ignorar as etapas de 1 a 8.

  1. Abra Unity e crie um novo Projeto Você pode chamá-lo de "basquetebol" ou "jogo incrível", se quiser.
  2. Crie uma cena do jogo.
  3. Arraste Hoop.3ds da sua área de download para o painel Assets.
  4. Selecione Assets -> Import Packages -> Characters.
  5. Uma vez feito o download do recurso, clique em Import Isto levará todos os recursos ao seu projeto.
  6. Crie uma esfera e aplique materiais para que tenha cor e ressaltos.
  7. Coloque os componentes na cena.
  8. Escreva o script Shooter para poder lançar bolas no cesto de basquetebol.
  9. na pestana Projeto expanda a árvore Assets e clique na pasta Scenes.
  10. Faça duplo clique na cena Jogo para carregá-la Antes de avançarmos, executemos o jogo e vejamos como funciona.
  11. Agora que sabemos que o jogo funciona, podemos testar suas habilidades!

Criar nosso projeto Visual Studio com Unity

Agora que você importou e testou o jogo em Unity, vamos à criação de uma solução Visual Studio.

No menu, clique em File | Build Settings… para abrir a janela Build Settings e certifique-se de que você tem uma cena selecionada na visualização Scenes In Build Verifique se as seguintes configurações estão presentes ...

  • Plataforma está configurado para Windows Store (Se não estiver, clique em Windows Store -> Switch Platform).
  • SDK está configurado para Universal 10.
  • UWP Build Type está configurado para XAML.
  • Unity C# Projects e Development Build estão ambas selecionadas.

Em seguida, clique no botão Player Settings… e verifique se as informações estão corretas. Este jogo é para o modo Landscape Verifique que Default Orientation foi o modo Landscape selecionada:

Finalmente, clique no botão Build na janela Build Settings Você será solicitado para selecionar uma pasta onde compilar o projeto. Aqui será criado seu projeto e solução Visual Studio.

Usar Visual Studio para criar um pacote de aplicativo e WACK

Criamos a sua solução Visual Studio, e agora podemos prosseguir com a configuração.

Dê um duplo clique na solução criada para você.

Visual Studio 2015 irá abrir três projetos. Não se preocupe se você vê erros. Visual Studio carrega recursos de forma assíncrona. Espere que todos os recursos sejam carregados e compile o projeto em modo Debug selecionando Build | Build Solution no menu.

Em seguida, você vai querer...

  1. Verificar se a compilação funciona.
  2. Alterar o modo de modo a Master. Isto é importante pois você precisará apresentar seus aplicativos UWP em Windows Store usando o o modo Master. (o modo remove as verificações de segurança e desativa o profiler a fim de proporcionar o melhor desempenho.)
  3. Selecionar Store | Create App Packages... no menu Projeto .

Se você estiver fazendo isso pela primeira vez ou tiver passado vários dias desde a última vez, será solicitado que você autentique com suas credenciais de desenvolvedor da Windows Store. Você precisará inserir um código de segurança para confirmar suas credenciais.

Se a sua compilação foi bem sucedida, continue clicando no botão Launch Windows App Certification Kit Este processo de teste pode demorar algum tempo para validar que o jogo está pronto para ser apresentado em Windows Store.

Se tudo se processa corretamente, você deve ver a seguinte tela:

Desenhar o seu jogo Unity para UWP

Unity fornece um conjunto de ferramentas completas que permite direcionar a várias plataformas. Isso inclui suporte para as aplicações Universal Windows Platform (UWP). As ferramentas Unity cobrem as seguintes áreas, entre muitas outras:

  • Várias resoluções e redimensionamento de tela
  • Proporção de tela

Várias resoluções e redimensionamento de tela

Pronto a usar, o seu jogo Unity pode gerar várias resoluções e redimensionamento de tela. Um aspecto deste suporte que pode não ser intuitivo, mas é essencial para o seu jogo é o seu menu e heads-up display (HUD).

Unity oferece um novo sistema de interface de usuário, Unity UI. Este novo sistema IU elimina a necessidade de plugins de terceiros e simplifica as interfaces dentro de seu jogo. É importante configurar o seu menu e o HUD corretamente e testar em diferentes resoluções. Você se lembra de Windows Forms ou WPF, que permitia ancorar seus elementos de interface do usuário para que se redimensionassem automaticamente em função da tela? Unity oferece a mesma possibilidade. Além de ancorar as posições, você pode definir se os seus elementos de interface do usuário se redimensionam ou mantêm o tamanho quando a tela é redimensionada.

Proporção de tela

Além de múltiplas resoluções e redimensionamento, Unity suporta várias proporções de tela. É fundamental testar as várias proporções de tela que deseja integrar no seu jogo. Unity permite testar facilmente quaisquer proporções de tela.

Pense em testar em emuladores, além dos dispositivos de destino aos quais você tem acesso, a fim de garantir que você tem tudo pronto.

Ferramentas Visual Studio 2015 para Unity

Visual Studio é fornecido com ferramentas para ajudar a preparar o seu jogo Unity para publicação na Windows Store. Algumas delas são:

  • Unity Project Explorer
  • Escritura de scripts e debugging em Visual Studio
  • Graphics Debugger

Visual Studio Tools for Unity

A partir de Unity 5.2, você não precisa mais importar o Visual Studio Tools for Unity separadamente. No Visual Studio 2015, simplesmente entre em Tools | Extensions and Updates para instalar Visual Studio 2015 Tools for Unity.

A seção seguinte irá orientá-lo através das etapas necessárias para obter a última versão do VSTU ou se estiver usando uma versão anterior a Unity 5.2. Se você estiver usando Visual Studio 2015, com Unity 5.2 ou mais recente, as etapas seguintes não são necessárias e podem seguramente ser ignoradas.

Visual Studio Tools for Unity permite a você escrever e depurar seus jogos Unity dentro de Microsoft Visual Studio. Além da possibilidade de adicionar breakpoints e avaliar variáveis e expressões complexas, você também pode navegar pelo seu projeto como se estivesse em Unity com o Unity Project Explorer. Enfim, você vai visualizar exatamente os mesmos resultados no console dentro do Visual Studio que você iria obter em Unity.

O que se segue é uma captura de tela da instalação do Visual Studio 2015 Tools for Unity. Aceite as condições, selecionando a caixa

Uma vez concluída a instalação, abre-se uma janela:

Agora que já concluimos a instalação, é preciso abrir Unity e adicionar essa ferramenta para o nosso projeto.

A seguinte janela Unity aparece. Deixe tudo selecionado e clique no Import botão:

Você verá que uma nova pasta foi criada na sua hierarquia de seu projeto:

Verifique que suas configurações de compilação estão corretamente adaptadas à utilização de Visual Studio, como indicado abaixo. Certifique-se de ter selecionado “Unity C# Projects” e “Development Build”:

Agora você está pronto para escrever scripts e depurar usando o Visual Studio. Lembre-se: o processo de instalação é necessário apenas para versões Unity anteriores a 5.2.

Escritura de scripts e debugging em Visual Studio

Dando duplo clique num script Unity, abre-se Visual Studio. Por exemplo, se selecionarmos o script Shooter.cs e abrimos no Visual Studio, veríamos o seguinte

Agora, se queremos depurar o GetButtonDown que inicia jogando bolas, poderíamos adicionar um breakpoint na linha 12 e, em seguida, clicar no botão Attach to Unity botão:

Agora, novamente em Unity, basta clicar no botão Play E o jogo começa. Como sabemos que Atualizar vai ser iniciado, veremos a pausa do jogo na linha 12 no Visual Studio, se clicar no botão esquerdo do mouse:

Seu fluxo de trabalho com a depuração é o mesmo que com qualquer projeto Visual Studio.

Graphics Debugger

Visual Studio 2015 é fornecido com um depurador de gráficos muito potente que permitirá a você otimizar o seu jogo.

Para começar, vamos ter certeza de que você tem Graphics Tools adicionado ao sistema. No Windows, vá para Settings, selecione System, selecione Apps & Features, selecione Manage optional features. Se estiver instalado, você deve ver Graphic Tools:

Se você não tem isso, selecione Add a feature e, na lista, clique Graphic Tools. Consulte a documentação MSDN em Graphics diagnostic tools se você tem problemas para instalá-lo.

Você terá que usar a compilação Visual Studio a partir de Unity e abrir o jogo com Visual Studio, a fim de utilizar as Graphics Tools. Em Visual Studio, você pode usar essa ferramenta do menu, clicando em Debug | Graphics | Start Graphics Debugging, como mostrado abaixo:

Ao iniciar o jogo, abre-se a seguinte UI:

Clique no ícone Capture Frame para capturar o quadro atual do jogo. Você pode capturar diferentes partes do seu jogo.

Dando duplo clique em um quadro você acede à análise detalhada do mesmo. Você pode se mover para a frente e para trás nos draw calls no painel Graphics Event List além de selecionar pixels individuais e ver o painel Graphics Pixel History :

Note que o arquivo de diagnóstico de gráficos pode se tornar muito grande. Para mais informações, você pode consultar Visual Studio Graphics Diagnostics.

Windows Store Asset Generation

Para apresentar seu aplicativo na Windows Store, você deve fornecer imagens no tamanho correto. Uma extensão de Visual Studio foi concebida apenas para esta finalidade: UWP Tile Generator. Você pode selecionar uma imagem e criar todos os tamanhos que você precisa em um arquivo zip.

Diferenças entre aplicativos Unity e UWP.

Unity utiliza um framework chamado Scripting backend para suportar scripting. Atualmente suporta três backends: Mono, .NET e IL2CPP. Se seu aplicativo é para Windows Store, apenas a NET e IL2CPP estão disponíveis. Você pode selecionar Scripting Backend clicando no botão Player Settings na janela Build Settings em Unity.

Em Unity IDE, os scripts usando .NET fazem referência à versão 3.5 de .NET. No entanto, quando o jogo é exportado para Visual Studio, todo o seu código C# é compilado com .NET Core, que é um subconjunto da versão 4.5. .NET ( Nota: No entanto , se você usar IL2CPP como o backend de scripting, seu aplicativo de Windows Store vai continuar a usar o .NET 3.5) Para ilustrar isto, tente escrever a seguinte linha de código em um script Unity:

        
          System.Collections.SortedList lst = new SortedList();
        
      

Quando vocêF12 na SortedList no Visual Studio para ver a definição de tipo, você vai perceber que esta classe está na biblioteca mscorlib.

Se você inserir o mesmo código em seu projeto exportado e F12 no SortedList tipo, você verá que esta versão da classe está contida em um pacote NuGet que faz parte do .NET Core.

No passado, a falta de tipos ou de métodos em .NET 3.5 em .NET Core podia levar a problemas e implicava a utilização de bibliotecas auxiliares como WinRTLegacy para preencher as lacunas e fornecer não apenas os tipos, mas também métodos de extensão.

Dica: Tenha cuidado com as guias para os tipos em falta entre Unity e .NET Core. Muitos deles estão desatualizados e carecem de precisão.

É importante entender esta diferença essencial entre Unity e UWP, mesmo se os problemas relativos a métodos e tipos faltam ao portar do .NET 3.5 para .NET Core continuam a diminuir à medida que .NET Core cresce. Por exemplo, System.Threading.Tasks, que foram introduzidos após .NET 3.5 e integram .NET Core. Você pode igualmente encontrar problemas contrários para implementar recursos de .NET Core ausentes no .NET 3.5.

Importante notar que, se você usar IL2CPP como backend para scripting, a superfície API entre o editor de Unity e seu aplicativo Windows Store vai se tornar idêntica.

Características específicas da plataforma

Unity e Windows Universal plataforma (UWP) sendo plataformas diferentes, a portabilidade entre ambas implica vantagens, bem como dificuldades.

Otimização do desempenho

Os aplicativos UWP usam .NET Native, que gera um código de máquina nativo e otimizado. Isto leva a tempos de inicialização mais rápidos e a um consumo menor de bateria para seus jogos. O impacto destas otimizações varia de acordo com a complexidade do jogo, mas os jogos Unity que usam o scripting backend .NET são particularmente otimizados. Em um projeto de jogo gerado, apenas uma configuração de compilação "Master” compilará .NET Native.

Diretivas

Se você quiser invocar um Toast UWP ou de um Tile de seu jogo, como você faria? Estes recursos não estão incluídos no .NET 3.5, o backend para Scripting que permite desenvolver na Unity. Neste caso, o seu código iria funcionar bem, uma vez exportado para o Visual Studio mas nunca iria trabalhar em Unity IDE.

A fim de contornar problemas como este, Unity fornece uma biblioteca UnityEngine.WSA, que contém subclasses como Aplicação, Cursor, Launcher, Tile e Toast. Você pode programar para estes tipos em seus scripts C# Unity para interoperar entre Unity e UWP.

A segunda técnica para a gestão de recursos que estão faltando no .NET 3.5 é usar a diretiva NETFX_CORE nos seus scripts. Esta diretiva é usada para ignorar blocos de código que você sabe que não será compilado no .NET 3.5, mas que você precisa em seu jogo quando ele é compilado com .NET Core. O exemplo a seguir, que pode ser encontrada no repositório Unity bitbucket, mostra como o código que não funciona no IDE Unity pode ser ignorado usando diretivas.

        
          #if NETFX_CORE
          async
          #endif
          void UpdateTile(byte[] png150x150)
          {
          #if NETFX_CORE
              // In order to change tile image, we should change the uri too
              // in this example we store images in applications local storage
              // we must also take care of cleaning it up
              StorageFolder localFolder = ApplicationData.Current.LocalFolder;
              StorageFolder tilesFolder = null;
              try
              {
                  tilesFolder = await localFolder.GetFolderAsync("tiles");
              }
              catch (Exception)
              { }
              if (tilesFolder != null)
                  await tilesFolder.DeleteAsync();
              tilesFolder = await localFolder.CreateFolderAsync("tiles");
              string tileFile = "tile" + counter++ + ".png";
              StorageFile file = await tilesFolder.CreateFileAsync(tileFile, CreationCollisionOption.ReplaceExisting);
              await FileIO.WriteBytesAsync(file, png150x150);

              string txt = textToTile ? text : "";
              Tile.main.Update("ms-appdata:///local/tiles/" + tileFile, "", "", txt);
          #endif
          }
        
      

Ocasionalmente você pode querer ser mais específico e usar uma diretiva Unity_WSA_10_0 em vez de depender de NETFX_CORE. Esta última é uma diretiva para qualquer aplicativo Windows Store, Unity_WSA_10_0 é usado especificamente para dispositivos Windows 10.

Escrever Plugins

Os plugins também pode ser afetados pelas diferenças entre .NET 3.5 e .NET Core. Por vezes o código é compatível e você não tem dificuldades. No entanto, quando não é , Unity permite configurar seu aplicativo de forma a usar duas versões diferentes do mesmo plug-in, uma para a IDE Unity (baseada nas APIs .NET 3.5) e outra para o jogo inteiro (.NET core).

Para implementar vários plugins, você deve seguir certas regras. Os seus plugins devem compartilhar o mesmo nome e têm o mesmo número de versão. Os dois plugins devem também ser colocados em pastas separadas. Por exemplo, o plug-in compatível com o seu Editor deve ir em.. \Assets\Plugins\MyPlugin.dll,, enquanto que o plugin especifico de UWP vai em..\Assets\Plugins\WSA\MyPlugin.winmd.

Além disso, é necessário configurar a versão de seus plug-ins, que você escreveu para o Editor como um espaço reservado para o seu plug-in .NET Core , indicando a Unity qual biblioteca é o espaço reservado e qual é a versão live que será implantado na Windows Store.

Selecione Assets\Plugins\MyPlugin.dll em seu Unity Project Explorer e marque Editor como plataforma.

Depois, vá a Assets\Plugins\WSA\MyPlugin.winmd e selecione Windows Store Apps como a plataforma correta para esse plugin.

Para ilustrar melhor esse processo, criamos um conjunto de plug-ins.

Abra o Visual Studio 2015 e crie um novo projeto chamado "MyPlugin". Use o modelo de projeto para um Visual C# | Windows | Universal | Windows Runtime Component. (Você também poderia usar um modelo de projeto Class Library em seu lugar, mas o Windows Runtime Component tem algumas características interessantes, como poder ser usado a partir de qualquer projeção de linguagem de runtime de Windows, o que proporciona benefícios adicionais.)

Clique com o botão direito do mouse na sua solução e selecione Add -> New Project. Esta versão stub da biblioteca será unicamente usada no editor Unity. Como compilará usando .NET 3.5, deve ser criada com o modelo do projeto Visual C# | Windows | Classic Desktop | Class Library Chame esse projeto “MyPluginStub,” Você não pode usar o mesmo nome para dois projetos na mesma solução.

Porque as duas bibliotecas têm de ter o mesmo nome, você precisa configurar o arquivo de saída para MyPluginStub para ser chamado MyPlugin, tal como o seu outro projeto. Para isso, clique com o botão direito no projeto MyPluginStub no Solution Explorer e selecione Properties. Na pestana Application, altere tanto o campo Assembly Name como Default para "MyPlugin", a fim de coincidir com o outro projeto. Entretanto, você deve igualmente alterar o campo Target framework para ".NET Framework 3.5."

Exclua os arquivos Class1.cs que Visual Studio criou para cada um de seus projetos. Em seguida, crie uma nova classe no projeto MyPlugin Windows Runtime Component chamado "Foo.cs." Em vez de criar uma classe semelhante para o projeto Windows Desktop, vamos compartilhar Foo.cs, adicionando-o como um arquivo vinculado.

Agora você pode editar o mesmo arquivo físico, Foo.cs, a partir do projeto MyPlugin, bem como o projeto MyPluginStub. Examine o arquivo no editor de código de ambos os projetos. Você vai notar que quando você o visualiza a partir de MyPluginStub, Visual Studio coloca rabiscos vermelhos para identificar System.Threading.Tasks Isso ocorre porque o tipo existe no .NET Core, mas não existe no .NET Framework 3.5.

Poderíamos simplesmente apagar essa linha para corrigir o erro uma vez que não está previsto usá-la. Em vez disso, no entanto, vamos testar uma diretiva para mostrar como funciona. Substituir o elemento Tasks pelas três linhas de código seguintes.

        
          #if NETFX_CORE
            using System.Threading.Tasks;
          #endif
        
      

Depois de adicionar isso, você deve compilar os projetos de novo. Ainda precisamos de uma solução para a classe Foo. Naturalmente, será chamada Bar. Bar deve enviar uma mensagem diferente se é chamada a partir do editor Unity ou a partir do interior do Windows Runtime Composant. Adicione a seguinte implementação deste método de barras à sua classe Foo. (Adicionar igualmente a palavra-chave "sealed" a sua declaração de classe, pois os componentes Runtime exigem isso.)

        
          public sealed class Foo
            {
              public string Bar()
              {
                #if NETFX_CORE
                  return "Windows Store version of the plugin.";
                #endif
                  return "Unity Editor version of the plugin.";
              }
            }
        
      

Compile as duas bibliotecas.

Em seguida, configure seu projeto Unity para usar essas bibliotecas. Abra seu projeto no Unity e crie uma nova pasta em "Assets" chamada "Plugins". Além de plugins, crie outro diretório chamado WSA (abreviatura de Windows Store Application). Localize o arquivo MyPlugins.dll do seu projeto MyPluginsStub e arraste-o para ...\Assets\Plugins. Em seguida, arraste o arquivo MyPlugins.winmd compilado para ...\Assets\Plugins\WSA.

Clique em Plugins\MyPlugin no painel Assets. As configurações de importação MyPlugin irão aparecer no painel Inspector. Desmarque a opção "Any Platform" e selecione Editor. Isto irá indicar ao IDE qual a versão da biblioteca deve ser executada quando você estiver no Editor Unity.

Em seguida, desça um nível e selecione Plugins\WSA\MyPlugin. O inspector já deve ter selecionado WSAPlayer como plataforma. Isto indica a Unity que esta é a versão da biblioteca que você deseja publicar na Windows Store. Vá até ao campo Placeholder e selecione sua biblioteca de stub na raiz da pasta de plug-ins. Isto permite explicar a relação entre as duas bibliotecas. Plugins \ MyPlugin.dll é o espaço reservado para a sua biblioteca real, Plugins \ WSA \ MyPlugin.winmd.

É hora de testar as duas bibliotecas para nos certificarmos que estão configurados corretamente na Unity. Crie um Script C# novo na Unity chamado de "TestFooBar." Crie uma instância privada da classe Foo e escreva o valor de retorno Bar em Logger.

        
          using UnityEngine;
          using System.Collections;
          using MyPlugin;

          public class TestFooBar : MonoBehaviour {

            private Foo testFoo = new Foo();
             // Use this for initialization
               void Start () {
                  Debug.Log(testFoo.Bar());
                }

            // Update is called once per frame
              void Update () {

              }
            }
        
      

Finalmente, arraste este script para um dos seus objetos do jogo, como Player, para anexá-lo. Isso garante que o método de inicio do script será invocado. Execute o jogo na Unity e, se tudo correr conforme o previsto, a mensagem correta deve aparecer no painel do console.

Finalmente, vá para a Build Settings e clique no botão Build para exportar seu projeto para Visual Studio.

Execute o seu jogo no Visual Studio. Agora você deve ver a seguinte mensagem na janela do Visual Studio Output:

Este exemplo de plugin é a base para quase todas as interações entre a Universal Windows Plataform (UWP) e Unity. Se você consegue que as mensagens apareçam corretas em seus consoles, então você aprendeu tudo o que precisa para encapsular o código UWP e acessá-lo de seu jogo Unity.

Publicidade

Você pode executar Microsoft Ads como plugin Unity baixando e instalando Unity Plugins para Windows Store e Azure Services. O plugin também contém APIs para compras no aplicativo, verificações de licenças e validação de recibos.

A maneira mais fácil de usar os plugins Unity para Windows Store é baixar o pacote Unity de GitHub e importá-lo em seu aplicativo via Assets | Import Package | Custom Packages no Editor Unity. Uma vez o pacote é importado, você terá os binários adequados localizados nas pastas Unity Plugins e Unity Plugins\WSA.

Alternativamente, você pode usar a extensão mais recente SDK de Microsoft Store Engagement and Monetization de seu aplicativo UWP exportada para exibir banners e anúncios intersticiais de vídeo. O SDK de Microsoft Store Engagement and Monetization integra os recursos de publicidade do SDK de Microsoft Universal Ad Client com outros recursos relacionados com serviços Store em um só instalador unificado.

Analytics

Colete análises sobre seus jogadores através da plataforma Unity ou através da Windows Universal Platform (UWP). Você pode igualmente optar por usar ambas as plataformas em conjunto para recolher dados complementares. Se você quiser usar Unity, terá de vincular seu projeto a um ID Unity Services e depois habilitar Analytics para seu projeto. Mais informação pode ser encontrada no Manual de Unity.

Uma vez tenha implantado o seu jogo, os dados serão automaticamente recolhidos para você no seu Painel do Windows Dev Center. O painel irá mantê-lo atualizado com os relatórios sobre:

  • Aquisições
  • Saúde
  • Classificações
  • Resenhas
  • Feedback
  • Uso
  • Aquisição IAP
  • Mediação de anúncios
  • Desempenho de publicidade
  • App install ads
  • Canais e conversões

Se estiver habilitado, você poderá mesmo consultar a telemetria de uso para o seu jogo.

Finalmente, você também pode usar APIs REST para visualizar estes analytics de uma forma mais útil para você sem a necessidade de passar pelo Windows Dev Center.

Compras no aplicativo /In-App Purchases (IAP)

Os jogos Unity exportados para Windows Universal Platform (UWP) contam com duas plataformas, Unity e UWP. Você tem duas opções para permitir compras no aplicativo. Você pode usar Unity IAP ou Unity Plugins para Windows Store e Azure Services.

Para usar Unity IAP, você terá de configurar um ID Unity Services Project na janela Services na Unity. Isto guiará você através de uma série de diálogos para habilitar seus IAP’s para Windows Store. Mais detalhes estão disponíveis no site da Unity. Não esqueça que Unity IAP não funciona com o backend de scripting. IL2CPP.

Com os Plugins Unity para Windows Store, você usa a API Store para recuperar suas listas de dentro de um arquivo de script Unity. Primeiro você deve criar Produtos In-App (no aplicativo) para seu aplicativo através da Windows Store Dev Center. Em seguida, você pode atualizar seu aplicativo e permitir compras de seus IAPs. O requisito principal, feito através do plugin, necessita que você invoque o LoadListingInformation método para recuperar seus In-App Products (produtos no aplicativo), como mostrado no código de exemplo abaixo.

        
          Store.LoadListingInformation((response) =>
          {
            if (response.Status == CallbackStatus.Failure)
              {
                prettyPrintErrors("LoadListingInformation", response);
                return;
              }

            prettyPrintSuccess("LoadListingInformation", response);
            text.text = "\nFinished Loading Listing Information" + text.text + "\n";
            Debug.Log(response.Result.Description.ToString());
            foreach (var productListingKey in response.Result.ProductListings.Keys)
              {
                Debug.Log("Key: " + productListingKey + " value: " + response.Result.ProductListings[productListingKey].Name);
              }
          });
        
      

O exemplo completo de implementação que mostra como usar a API Store está disponível no GitHub.

Melhores práticas

À medida que complete os aspectos básicos de seu jogo, você quererá aperfeiçoar seu aplicativo para a família de dispositivos Windows 10. Nesta seção, vamos abordar várias práticas recomendadas para facilitar a sua implantação na Windows Store.

Tela inicial e progresso da carga

Ao iniciar o jogo, é importante mostrar um indicador de progresso para que o usuário saiba que o jogo não está congelado ou parado.

Neste artigo, vamos supor que você está usando um projeto de XAML. Se não é o caso, a maioria dos conceitos aqui apresentados aplicam-se a um projeto DirectX, mas as implementações variam.

Há duas fases importantes no carregamento de um jogo na Windows Store via Unity

  1. Tela inicial do aplicativo
  2. Experiência de tela inicial estendida

A imagem da tela inicial será mostrada pelo sistema operacional e você pode configurá-la atualizando seu manifesto de aplicativos, tal como indicado:

Windows irá mostrar a tela inicial do aplicativo apenas durante o tempo que leva o sistema operacional a carregar a página (escrito em XAML markup) que irá hospedar suas cenas Unity.

Normalmente, a cena Unity demora mais tempo para carregar. Para criar uma experiência de tela inicial estendida, use XAML para mostrar a mesma imagem inicial novamente com um indicador de progresso na parte superior para que o usuário saiba que se estão carregando cenas Unity. Em MainPage.xaml, você irá adicionar uma barra de progresso ao lado da imagem da tela inicial.

        
          <SwapChainPanel x:Name="DXSwapChainPanel">
            <Grid x:Name="ExtendedSplashGrid" Background="#222C37">
              <Image x:Name="ExtendedSplashImage" Source="Assets/SplashScreen.png" 
                VerticalAlignment="Center" HorizontalAlignment="Center"/>
              <ProgressBar x:Name="SplashProgress" Foreground="#FFFFFFFF" 
                Background="#FF333333" Maximum="10000" Width="320" Height="25"/>
            </Grid>
          </SwapChainPanel>
        
      

Em MainPage.xaml.cs , o código por detrás do arquivo para XAML UI, use o construtor para iniciar um temporizador que ativará a barra de progresso dando feedback visual para o usuário.

Fator de forma do dispositivo

Um código base para muitos fatores de forma é uma característica fundamental da Universal do Windows Platform (UWP), mas os jogos podem ainda exigir algumas adaptações e otimizações para fatores de forma específicos. Frequentemente, estes incluem mecanismos de entrada (por exemplo, tátil, teclado, mouse, gamepad), redimensionamento de janelas, otimização de recursos e assets, e implementação de integração da plataforma nativa com cada fator de forma específica.

Suporte de orientação

Tendo em conta que nos dispositivos novos predomina a proporção de tela panorâmica, o editor Unity irá exportar projetos com orientação paisagem por defeito. Se o seu jogo suporta a orientação retrato, será necessário alterar o manifesto do aplicativo no Visual Studio. Você não pode fazer isso no editor de Unity.

Para alterar o manifesto, dê duplo clique no Package.appxmanifest arquivo, situado na raiz do seu projeto Windows Store Visual Studio. No editor de manifesto, verifique as orientações que deseja usar.

As APl de orientação (Input.deviceOrientation e Screen.orientation) funcionam bem na Unity. Você pode usá-las para consultar a orientação do dispositivo e até mesmo definir a orientação para cenas específicas.

Suporte para janelas

Os aplicativos Universal Windows Platform (UWP) são hospedados em janelas redimensionáveis em vez de ser executados em tela completa como no Windows 8 e 8,1, para que as janelas sejam tidas em consideração para os seus jogos e aplicações

A maioria destas diferenças são transparentes para você como desenvolvedor Unity porque as propriedades Screen.height e Screen.width ainda relatam o espaço disponível em tamanhos nativos (pixel).

Quando o usuário muda o tamanho da janela, a prática recomendada é pausar o jogo para que o usuário possa decidir o que fazer a seguir. Como as janelas também podem perder o foco no modo Desktop, onde várias janelas podem estar abertas em simultâneo, você deve gerenciar as mudanças do foco e fazer pausa quando a janela de seu jogo perde o foco.

Pausando e retomando seu jogo

No Windows, a engine de jogo Unity normalmente encarrega-se de pausar e retomar automaticamente quando o jogo perde o foco. Em cenários onde você pode querer pausar o jogo fora da suspensão automática do aplicativo, como durante a navegação entre páginas XAML, você pode invocar o UnityPause método.

Se você precisa fazer algo mais quando a aplicação está prestes a fazer uma pausa, OnApplicationPause Em seu lugar faça um callback em seus scripts.

Entrada para gamepad e mouse

A família de dispositivos Windows é compatível com uma grande variedade de entradas, de teclado e mouse até tátil e gamepads. Felizmente, todos esses modos de entrada não são apenas totalmente compatíveis com Unity, também são bem captados por meio do Gerenciador de entrada da Unity.

No comportamento do atirador do nosso jogo de basquetebol, devemos aguardar a liberação do eixo de entrada "Fire1" antes de lançar uma bola no jogo.

        
          void Update()
            {
              if (Input.GetButtonDown("Fire1"))
              {
                var instance = (Rigidbody)Instantiate(this.prefab, transform.position 
                        + (transform.forward * 1.05f), transform.rotation);
                instance.velocity = (transform.forward + transform.up / 2) * this.speed;
              }
            }
        
      

"Fire1" está atribuído por defeito, a o botão esquerdo do mouse, e ao botão Gamepad / joystick, como mostrado abaixo no Gerenciador de entrada. Para visualizar o Input Manager em Unity IDE, selecione Edit -> Project Settings -> Input.

Em um controlador de Xbox One, o" botão 0 do joystick ", definido para "Fire1", é o botão A. Há também entradas já definidas para o componente FPSController para movimentos e saltos. Os movimentos do mouse, as teclas à esquerda, à direita, para cima e para baixo do teclado, bem como as teclas a, d, s, e W, e o botão esquerdo do joystick no controlador da Xbox One movem o jogador por defeito. O botão direito do mouse, barra de espaço, e o botão Xbox B todos fazem o jogador saltar.

Você pode personalizar ainda mais suas entradas para obter experiências personalizadas por remapeamento de entradas para eixos ou mesmo adicionando mais eixos para seu jogo. Mais informação sobre os eixos virtuais no Manual Unity.

Conclusão

Este documento mostra como configurar e exportar o seu jogo de Unity para um projeto Universal Windows Platform (UWP) no Visual Studio. Aborda igualmente como apresentar o seu jogo UWP na Windows Store. Explicamos algumas das diferenças sutis entre as plataformas Unity e Universal Windows bem como os recursos e o código específico das plataformas que você deve conhecer como desenvolvedor de jogos. Finalmente, este documento aborda as melhores práticas para preparar o seu jogo para publicação.

Referências

Voltar ao topo
Eu entendi

Usamos cookies para garantir a melhor experiência no nosso site. Clique aqui para obter mais informações.