• Artigo

Edição especial do Windows 10 - 2015

Volume 30 - Número 11

Desenvolvimento de Jogos - Grave Jogos na Plataforma Universal do Windows com o Unity

Por, Jaime Rodriguez | Windows 2015

O Windows 10 possui muitos recursos novos para os desenvolvedores de jogos e para os jogadores. Com a Plataforma Universal do Windows (UWP), os desenvolvedores podem considerar tablets e PCs com Windows 10, dispositivos móveis com Windows 10, (isto é, telefones), Xbox One e HoloLens com uma única base de código. Além disso, as Windows Stores agora são uma única Store e a Microsoft trouxe os Serviços do Xbox Live para o Windows 10, junto com o aplicativo do Xbox para aumentar o envolvimento do jogador em todas as famílias de dispositivo do Windows.

Para os desenvolvedores de jogos, a Unity é um dos mecanismos de desenvolvimento de jogos mais populares. Com suporte para 21 plataformas, possui o melhor suporte de desenvolvimento entre plataformas de qualquer middleware disponível hoje. Seu editor, combinado com o suporte para a linguagem de script C#, faz com que esse mecanismo seja um ambiente de desenvolvimento de jogos extremamente produtivo. Com a Asset Store, a comunidade da Unity e os recursos cada vez melhores da Unity com anúncios, interatividade e análises, nunca foi tão fácil desenvolver um jogo imersivo.

Quando o universo conspira a nosso favor, temos que aproveitar! Este artigo fornecerá todos os detalhes que você precisa para que os seus jogos feitos em Unity rodem perfeitamente no Windows 10. Esta não é uma introdução à Unity ou uma introdução aos aplicativos UWP. Supõe-se que você já esteja familiarizado com ambos estes tópicos e, em vez disso, nos concentraremos em explicar o que mudou com o Windows 10 e as dicas que você precisa saber para criar ótimos Universal Windows Games (UWGs!). Faremos isso através de uma abordagem prática, mostrando as pequenas alterações que fizemos em um jogo de exemplo chamado Chomp (veja a Figura 1) para otimizá-lo para Windows 10.

Chomp
Figura 1 Chomp

O Chomp começou como um jogo para Windows 8.1 escrito em Unity. Como você pode ver na captura de tela na Figura 1, é um jogo muito simples com labirintos semelhante ao Pac-Man. Este exemplo foi criado como um guia para os desenvolvedores demonstrarem como gravar um jogo com a Unity, então, simplicidade é a chave. Mas, com a chegada do Windows 10 e a Unity com suporte para o novo SO, o Chomp teve que ser atualizado. Você pode encontrar o código-fonte para o Chomp em bit.ly/UnityChomp. Baixe-o e vamos continuar nessa empreitada.

Para obter uma versão UWP do nosso jogo, podemos simplesmente exportá-lo usando o perfil do Windows 10 na Unity, mas isso não resulta em um aplicativo otimizado para a forma como o Windows 10 funciona. Não é possível executá-lo em uma janela, no modo de tela cheia, sensível ao toque e assim por diante. Então, vamos dar uma olhada no que fizemos para transformar esse jogo do Windows 8.1 para um jogo do Windows 10.

Introdução (Pré-requisitos)

Os aplicativos UWP (e UWGs) exigem que você desenvolva e teste com o Windows 10 e com o Visual Studio 2015. Qualquer edição do Visual Studio 2015 terá tudo o que você precisa para criar os seus jogos, incluindo o Visual Studio Community 2015, que é gratuito!

Em relação à Unity, você precisa da Unity 5.2.1p2 ou posterior. A Unity 5.2 agora instala o Visual Studio Community 2015 e o Visual Studio 2015 Tools para Unity (VSTU). Então, na prática, para começar você só precisa instalar a Unity e verificar as opções corretas durante o processo de instalação. Veja os detalhes na Figura 2.

Instalar a Unity com as opções corretas fornece tudo o que você precisa para começar
Figura 2 - Instalar a Unity com as opções corretas fornece tudo o que você precisa para começar

Observação: Para desenvolvedores que usam Mac, uma nova alternativa é usar o editor Visual Studio Code com os projetos da Unity. Você pode obter mais detalhes sobre essa opção em bit.ly/UnityVSCode.

Criando para o Windows 10

Criar para o Windows 10 é exatamente o mesmo processo que você já conhece. Existe um novo SDK para aplicativos UWP na plataforma Windows Store (veja a Figura 3), que exportará o jogo como um aplicativo UWP.

Unity voltada para Windows 10
Figura 3 - Unity voltada para Windows 10

Aqui estão alguns dos itens importantes por trás da exportação para o Windows 10 e o desenvolvimento na UWP:

  • Existem novos processadores UNITY_UWP e UNITY_WSA_10_0 que você pode usar para “personalizar” a lógica do seu jogo e a experiência para a UWP.
  • A Unity 5.2 agora inclui uma nova DLL WinRTLegacy simplificada que contém menos tipos que as versões anteriores. Com o Windows 10, a Microsoft reuniu vários tipos de volta no perfil do .NET Core, fazendo com que algumas soluções alternativas incluídas no WinRTLegacy não fossem mais necessárias.
  • A Unity 5.2 está usando o novo modelo de plug-in introduzido na Unity 5. Isso simplifica bastante os plug-ins que fazem parte do seu fluxo de trabalho, como você poderá ver posteriormente neste artigo.
  • A Unity 5.2 inclui suporte experimental para DirectX 12, que é enviado junto com o Windows 10. Para experimentar o suporte experimental, abra o Player Settings na Unity, desmarque a opção Auto Graphics API e inclua manualmente o suporte de Direct3D12.

Novos modelos de projeto

O processo de compilação da Unity agora gera um projeto em Visual Studio 2015 compatível com a UWP. Como você provavelmente já sabe, existem algumas alterações significativas nesse novo sistema de projeto.

Por exemplo, cada aplicativo da UWP agora é enviado com a sua própria cópia do .NET Core junto com o aplicativo, dessa forma você sempre tem a versão do .NET com a qual foram feitos os testes. Para acomodar isso, a Unity gera um arquivo project.json adequado que pegará as “partes” adequadas do .NET através do NuGet.

Além disso, os aplicativos da UWP usam o .NET Native, que gera um código de máquina otimizado, nativo antes do seu aplicativo ser baixado para as máquinas do cliente, resultando em tempos mais rápidos de inicialização e menos consumo de bateria para os seus jogos. O impacto dessas otimizações irão variar conforme a complexidade do seu jogo, mas é certo que elas não afetarão o desempenho. A única limitação com o .NET Native é que ele resulta em tempos de compilação (significativamente) maiores no Visual Studio. Para os aplicativos normais, o Visual Studio compila com o .NET Native somente para a configuração de “Versão” do projeto. Com o arquivo de projeto gerado pela Unity, uma abordagem semelhante é implementada e somente a configuração “Básica” é compilada usando o .NET Native. Se você não estiver familiarizado com os destinos de configuração na Unity, existem três:

  • Depuração é um projeto de depuração completo sem otimizações.
  • Versão é um projeto compilado com otimizações, mas inclui suporte para o criador de perfil.
  • Mestre é a configuração que você deve enviar para a Store, pois a mesma não possui código de depuração, todas as otimizações estão habilitadas e o suporte para a criação de perfil é removido.

Você deve compilar e testar com o .NET Native logo no início do seu ciclo de desenvolvimento. A Unity faz diversos caminhos através de linguagem intermediária (LI) avançada, então se existe um tipo de aplicativo que leva o .NET Native até o seu limite, esse aplicativo é um jogo da Unity. Para garantir que tudo está funcionando conforme planejado, preste atenção nos avisos na janela de saída durante a compilação do .NET Native.

As diferenças supracitadas são significativas em tempo de execução, mas os novos modelos da Unity tornam essas alterações transparentes para você como desenvolvedor, então vamos nos concentrar em como personalizar e fazer os ajustes finais no seu jogo para Windows 10.

Personalizando e fazendo os ajustes finais no seu jogo para Windows 10

Um código-base em muitos fatores forma é um importante recurso na UWP, mas em relação aos jogos, podem ser necessárias algumas otimizações e personalização para fatores forma específicos. Na maior parte das vezes, isso inclui: mecanismos de entrada (tais como, toque, teclado, mouse e gamepad); redimensionamento de janelas; otimização de recursos e ativos e implementação de integração de plataforma nativa, tais como blocos dinâmicos, notificações ou Cortana, com cada fator forma específico. Vamos explorar a aparência dos mesmos para UWGs.

Janelas Os aplicativos Universal Windows agora são hospedados em janelas redimensionáveis em vez de serem executados em tela cheia como ocorria no Windows 8 e 8.1; então, as janelas agora devem ser consideradas para seus jogos e aplicativos. A maioria dessas diferenças são transparentes para você como desenvolvedor da Unity porque as propriedades Screen.height e Screen.width ainda apresentam o relatório do espaço disponível nos tamanhos nativos (pixel).

O Windows 10 também inclui novas APIs para entrar e sair da tela cheia e as mesmas são expostas através da classe Unity Screen configurando-se a propriedade Screen.fullScreen. Uma boa prática recomendada em relação às janelas é implementar os aceleradores principais padrões para entrar e sair da tela cheia. Os aceleradores variam bastante entre os publicadores, mas um acelerador comum para entrar e sair da tela cheia é F11 ou Alt+Enter. Para o Chomp, queríamos oferecer essa opção para os jogadores de jogar em tela cheia, então alternamos para o modo de tela cheia fazendo o seguinte:

if (Input.GetKeyUp (KeyCode.F11))
{
  Screen.fullScreen = !Screen.fullScreen;
}
if (Input.GetKeyUp (KeyCode.F11))
{
  Screen.fullScreen = !Screen.fullScreen;
}

Ter uma área de trabalho com várias janelas introduz outra alteração necessária para os jogos do Windows 10: Você deve lidar com alterações no foco. Em uma área de trabalho com várias janelas, se a janela do seu jogo não tiver com foco, você deve pausar o jogo e a música, porque o usuário pode estar interagindo com uma janela diferente. A Unity simplifica essa interação com a mesma API exposta em outras plataformas: o método OnApplicationPause. Esse método é chamado em todos os MonoBehaviours ativos quando o foco é alterado. Fazemos isso no Chomp conforme mostrado na Figura 4.

Figura 4 - Pausando seu jogo quando o foco é alterado

public void OnApplicationPause(bool pause)
{
  FocusChanged(!pause);
}
public void FocusChanged(bool isFocused)
{
  if (isFocused)
    musicSource.UnPause();
  else
  {
    musicSource.Pause();
    GameState.Instance.SetState(GameState.GameStatus.Paused);
  }
}

Observe que há assimetria: Quando o jogo perde o foco, o jogo e o áudio são pausados, mas quando ele recebe foco nós cancelamos a pausa somente do áudio. Isso ocorre porque quando o jogo é pausado, mostramos também uma caixa de diálogo de pausa no próprio jogo e quando o foco é retomado, o jogo aguarda o usuário confirmar que quer retomar o jogo. Essa caixa de diálogo serve para configurar o estado do jogo de volta para Execução depois de estar em Pausa.

Com essas duas alterações, tratamos de forma adequada da capacidade de entrar/sair da tela cheia e pausar o jogo quando a nossa janela perde o foco.

Entrada As versões anteriores da Unity possuíam um grande suporte para entrada em jogos do Windows e isso não mudou com o Windows 10. Mouse, toque e gamepad continuam muito bem simplificados pela classe Input e Input Manager na Unity.

O mais importante a se lembrar em relação às entradas é garantir que você está implementando uma quantidade de mecanismos de entrada proporcional aos seus jogos. Para o Chomp, queremos suporte para teclado, gamepad e toque. Lembre-se que as UWGs podem ser executadas em qualquer lugar, então ofereça aos jogadores a melhor experiência de entrada/jogabilidade que você puder. A pergunta mais frequente em relação à entrada é como detectar se você precisa mostrar os controles sensíveis ao toque (como um controle virtual ou um botão direcional) quando você está jogando em um dispositivo sensível ao toque como um telefone.

Uma maneira de determinar se o controle sensível ao toque deve ser mostrado é determinar se o jogo está rodando em um telefone. Se sim, faz sentido que o controle seja exibido e habilitado por padrão. Para determinar se o jogo está rodando em uma plataforma específica (tais como um telefone ou Xbox), você pode verificar se o contrato adequado foi implementado. Essa é a maneira como o Chomp detecta se está sendo rodado no Windows 10 Mobile:

public static bool IsWindowsMobile
{
  get
  {
    #if UNITY_WSA_10_0 && NETFX_CORE
      return Windows.Foundation.Metadata.ApiInformation.
        IsApiContractPresent ("Windows.Phone.PhoneContract", 1);
    #else
      return false;
    #endif
  }
}

Observe que nesse código nós usamos o pré-processador UNITY_WSA_10_0 para determinar se estamos compilando para Windows 10. Sem essa verificação, o código apresentaria erro ao compilar em compilações que não são do Windows 10.

Ter o controle sempre visível é uma abordagem, mas talvez seja melhor mostrar o controle somente quando o usuário está realmente usando o toque em um dispositivo. O Windows 10 inclui uma nova API que determinará se o usuário está rodando o Windows 10 no modo Tablet (toque) ou no modo de área de trabalho tradicional (mouse/teclado): Windows.UI.ViewManagement.UIViewSettings.User­InteractionMode. Essa API deve ser executada na thread da interface do usuário do Windows, então é preciso realizar marshaling da chamada de dentro da Unity para a thread da interface do usuário. Incluímos o código mostrado na Figura 5 para o Chomp determinar se o usuário está interagindo com o aplicativo usando toque.

Figura 5 - Código para determinar se o usuário está usando toque

public static bool IsWindows10UserInteractionModeTouch
{
  get
  {
    bool isInTouchMode = false;
#if UNITY_WSA_10_0 && NETFX_CORE
    UnityEngine.WSA.Application.InvokeOnUIThread(() =>
    {
      isInTouchMode =
        UIViewSettings.GetForCurrentView().UserInteractionMode ==
        UserInteractionMode.Touch;
    }, true);        
#endif
    return isInTouchMode;
  }
}

Agora com esses dois métodos implementados, podemos atualizar o Chomp para dar um palpite sobre quando mostrar o controle. Se o jogo estiver rodando em um dispositivo móvel ou se o modo de interatividade do usuário for toque, UseJoystick retornará true e exibiremos o controle:

public static bool UseJoystick
{
  get
  {
    return (IsWindowsMobile || IsWindows10UserInteractionModeTouch) ; 
  }
}

Após tratar das janelas e da entrada podemos seguir adiante e aproveitar as novas APIs nativas do Windows para incluir ainda mais funcionalidades no nosso jogo.

Integração nativa com o Windows 10: A integração nativa da plataforma Light-Up com o SO de um jogo em Unity é tratada da mesma maneira que era feita anteriormente: Se você estiver compilando usando a opção de compilação do .NET Core na Unity (usando o pré-processador NETFX_CORE), pode embutir código nativo, conforme mostrado nos exemplos anteriores.

Se o código que deseja adicionar for maior do que você deseja embutir ou se o comportamento precisar ser simplificado (entre as plataformas), também é possível usar os plug-ins. Para o Windows 10, a equipe da Microsoft Developer Experience Games Evangelism (da qual fazemos parte) está disponibilizando gratuitamente vários plug-ins que facilitam a integração com o Windows 10. Você pode encontrar esses plug-ins em bit.ly/Win10UnityPlugins. Até a presente data, os seguintes plug-ins foram compartilhados:

  • Store: Um plug-in da Store para compras com suporte para simulador de aplicativos, consumíveis, bens duráveis e recibos. Tudo que você precisa para fazer uma transação na Windows Store está aqui.
  • AzureMobile: Um plug-in do Microsoft Azure com operações de Criação, Leitura, Atualização e Exclusão (CRUD) para o Armazenamento do Azure.
  • Principal: Um plug-in “principal” que oferece integração nativa com os principais recursos do SO tais como blocos dinâmicos, notificações locais, notificações por push e Cortana.
  • Anúncios: Um plug-in que inclui o novo Microsoft Ads SDK para Windows 10, agora com suporte para vídeos intersticiais.

Anteriormente, o Chomp não possuía compras dentro dos aplicativos, então decidimos adicioná-las ao jogo usando o plug-in da Store. Agora, o Chomp possui suporte para a compra de consumíveis (boosters) e bens duráveis (mazes).

A maneira mais fácil de usar esses plug-ins é baixar o pacote da Unity do GitHub e importá-los para o Chomp em Ativos | Importar pacote | Pacotes personalizados no Editor da Unity. Após o pacote ser importado, você terá os binários apropriados localizados na pasta Plug-ins da Unity. Depois de instalados, os binários podem ser encontrados no diretório Plugins\WSA; a Unity exige conjuntos de espaço reservado (compatíveis com o Microsoft .NET Framewok 3.5) para uso no editor, para que os mesmos sejam incluídos e copiados para a própria pasta de Plug-ins.

Após importar o pacote, podemos referenciar as APIs da Store de dentro do Chomp. Primeiro chamamos Store.LoadListingInformation, fornecendo um método de retorno de chamada que é executado após a conclusão, para obter uma lista de todos os itens disponíveis para compra. Se a chamada tiver sido feita com sucesso, fazemos a iteração sobre os itens de ProductListing retornados e usamos os mesmos para popular os preços na nossa interface do usuário, conforme mostrado na Figura 6.

Figura 6 - Lista de itens disponíveis para compra dentro do aplicativo

void Start()
{   
  Store.LoadListingInformation(OnListingInformationCompleted);
  ...
}
void OnListingInformationCompleted(
  CallbackResponse<ListingInformation> response)
{
  if (response.Status == CallbackStatus.Success)
  {
    ListingInformation result = response.Result;
    PopulatePrices(result.ProductListings);
  }
}

Após o usuário ter escolhido o item desejado para compra, só é preciso de mais algumas poucas linhas de código para executar a transação. A Figura 7 mostra o código que adicionamos durante a compra de um bem durável (novos labirintos para o jogo).

Figura 7 - Fazendo uma compra dentro do aplicativo

public void OnDurablePurchase(GameObject buttonClicked)
{
  string productId = GetProductId(buttonClicked.name);
  if (!string.IsNullOrEmpty (productId))
  {
    Store.RequestProductPurchase(productId, (response) =>
    {               
      if (response.Status == CallbackStatus.Success)
      {
        // response.Status just tells us if callback was successful.
        // The CallbackResponse tells us the actual Status
        // as returned from store.
        // Check both.
        if (response.Result.Status == ProductPurchaseStatus.Succeeded)
        {
          EnableLevels(productId);
          return;
        }                 
      }
    });
  }
}

Como você pode ver, é bastante simples o uso desses novos plug-ins para implementar funcionalidades nativas.

Enviando para a Store

Enviar para a Windows Store está mais fácil do que nunca. Agora você pode enviar um único pacote que inclui todos os binários ou você pode enviar um pacote para cada plataforma/arquitetura, se desejado.

Se deseja dividir os seus pacotes ou oferecer suporte ao seu jogo somente em plataformas específicas, você pode editar manualmente o arquivo package.appxmanifest e ajustar o elemento TargetDeviceFamily:

<Dependencies>
  <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.10240.0" 
    MaxVersionTested="10.0.10240.0" />
</Dependencies>

As três famílias de dispositivo possíveis são:

  • Windows.Universal: Permite que os seus binários sejam implantados em qualquer lugar que atenda aos seus requisitos de hardware.
  • Windows.Mobile: Deve ser usada para binários que serão usados nas SKUs do Windows 10 Mobile, nomeadamente Windows Phone, apesar de que no futuro serão outros dispositivos pequenos (quinze centímetros ou menores) que não são telefones e que rodam essa SKU, então não pense que são somente telefones.
  • Windows.Desktop: Deve ser usada para jogos que podem ser jogados somente no computador e em tablets.

Se você pretende que seja somente para dispositivos móveis ou para computadores, mas não para console e outras famílias mais recentes do Windows, pode ter duas famílias de dispositivo no seu manifesto, então (troque “x” por “y” conforme necessário):

<Dependencies>
  <TargetDeviceFamily Name="Windows.Mobile" MinVersion="10.0.x.0"
    MaxVersionTested="10.0.y.0"/>
  <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.x.0"
    MaxVersionTested="10.0.y.0"/>
</Dependencies>

Observe que você pode ter MinVersion e MaxVersions diferentes para cada família de dispositivo. Isso será útil no futuro já que o Windows 10 Mobile será enviado com um número de versão posterior ao computador do Windows 10. Entretanto, por agora, recomendamos que você mantenha as versões padrão (10.0.10240.0).

Conforme mencionado anteriormente quando discutimos o .NET Native, ao enviar os seus pacotes, certifique-se de que você enviou a configuração Mestre. Além disso, recomendamos que você inclua os arquivos de símbolo do banco de dados do programa completo (PDB) para análise de falhas. A nova Store não possui a opção de baixar cabs para analisá-los localmente. Em vez disso, você deve enviar seus PDBs para a Windows Store e a Store faz o trabalho para você, oferecendo rastreamento de pilha para as falhas (veja a Figura 8).

Incluindo arquivos de símbolo de banco de dados do programa
Figura 8 - Incluindo arquivos de símbolo de banco de dados do programa

Finalmente, ao enviar para a Windows Store através do portal do desenvolvedor, certifique-se de escolher a configuração de hardware correta. A Store agora permite que você especifique os requisitos de hardware tais como toque ou teclado, para que o seu jogo seja instalado somente nos dispositivos corretos (veja a Figura 9).

Preferências de hardware disponíveis no portal do desenvolvedor
Figura 9 - Preferências de hardware disponíveis no portal do desenvolvedor

E tem muito mais!

Este artigo fornece um resumo das novidades para os desenvolvedores da Unity mostrando como portamos o nosso jogo simples para o Windows 10 e adicionamos alguns novos recursos. Devido ao nosso espaço limitado, nos focamos nos conceitos básicos e no que deve ser feito especificamente para um jogo em vez de mostrar todos os novos recursos na plataforma do Windows 10. Se você deseja ter um jogo excelente e imersivo, lembre-se de aproveitar os recursos adicionais tais como o novo centro de notificação (para estimular a participação) na área de trabalho, Cortana, os novos modelos de blocos dinâmicos e as novas APIs dos Serviços do Xbox Live. Com o Windows 10, a Microsoft está gradualmente abrindo o acesso aos Serviços do Xbox Live. Você não precisa gravar um jogo para console; você só precisa ter um excelente jogo rodando no Windows 10 e querer aproveitar os serviços como placar de líderes, conquistas, jogabilidade entre dispositivos e assim por diante. Para obter acesso, inscreva-se no programa ID@Xbox em xbox.com/id.

Visual Studio 2015 Tools for Unity

Começando com a versão 5.2, a Unity inclui o Visual Studio 2015 Tools for Unity (VSTU), fazendo com que o Visual Studio seja o novo editor de códigos padrão para os projetos da Unity no Windows. Essa alteração resultará em um melhor IntelliSense, coloração de sintaxe no editor e um ótimo depurador de C#. Para configurar o seu editor de script padrão, selecione a opção do menu Editar | Preferências no Editor da Unity. As suas escolhas podem incluir o MonoDevelop (incorporado), Visual Studio 2015, Visual Studio 2013 ou a opção de pesquisar mais opções.

O VSTU também inclui alguns atalhos para facilitar a escrita do código para Unity. Por exemplo, se você clicar com o botão direito em uma classe MonoBehaviour, o menu de contexto terá uma nova entrada de Implement MonoBehaviours, que permite que você inclua uma assinatura do método MonoBehaviour na sua classe.

No mesmo menu de contexto, existe também uma entrada de Quick MonoBehaviours, que realiza uma função semelhante, mas com uma caixa de diálogo menos intrusiva onde você pode digitar o nome do método que você está procurando e a assinatura é incluída novamente. Ambos esses métodos são acessíveis a partir dos aceleradores de tecla de atalho para um uso ainda mais rápido (Ctrl+Shift+M e Ctrl+Shift+Q).

Além das melhorias no editor, um dos melhores recursos ao usar o VSTU é a integração do depurador simplificado com o Editor da Unity. Quando um projeto da Unity é aberto no Visual Studio, será exibido automaticamente um botão de “Anexar à Unity” para depuração na barra de ferramentas padrão de Depuração. A Figura A mostra onde está localizado o botão. Esse botão encontrará automaticamente o processo do Editor da Unity e irá anexar-se ao mesmo. A partir daí você pode facilmente definir pontos de interrupção, analisar valores de variáveis e fazer tudo que você espera fazer com o Visual Studio. O VSTU possui até suporte experimental para interromper exceções. Para obter ainda mais detalhes sobre os recursos do VSTU 2.0, verifique o post do blog, “Visual Studio Tools for Unity 2.0,” em bit.ly/VSTUInfo.

Observação: Se você não estiver visando o Windows 10 e estiver usando o Visual Studio 2013, existe um pacote que pode ser baixado que inclui todos os pontos positivos descritos aqui para os usuários do Visual Studio 2013 Community Edition. Você pode baixar essa extensão em bit.ly/VSTU2013.

Jaime Rodriguezlidera a equipe da Microsoft Developer Experience Games Evangelism. Você pode encontrá-lo no Twitter: @jaimerodriguez e através do seu blog em jaimerodriguez.com.

Brian Peeké um desenvolvedor de jogos evangelista sênior na Microsoft. Ele é um jogador hardcore e desenvolve jogos para Windows, consoles e qualquer outra coisa que possa ser programada desde que se lembra. Você pode vê-lo pelo país apresentando-se em conferências de desenvolvedores ou você pode segui-lo no Twitter: @BrianPeek e através do seu blog em brianpeek.com.

Agradecemos aos seguintes especialistas técnicos da Microsoft pela revisão deste artigo: Sanjeev Dwivedi e Adam Tuliper
Sanjeev Dwivedi é um desenvolvedor de jogos evangelista sênior na Microsoft. Entre em contato com ele em sanjeev.dwivedi.net.

Adam Tuliper é um evangelista técnico sênior na Microsoft. Você pode encontrá-lo no Twitter em @AdamTuliper.