Artikel
11/17/2015

Sonderausgabe 2015 zu Windows 10

Band 30, Nummer 11

Entwicklung von Spielen – Programmieren von Spielen für die universelle Windows-Plattform mit Unity

Von Jaime Rodriguez | Windows 2015

Windows 10 hat Entwicklern von Spielen und auch Spielern viele neue Features zu bieten. Mithilfe der neuen universellen Windows-Plattform (UWP) können Entwickler für Windows 10-Tablets und PCs, Mobilgeräte mit Windows 10 (Smartphones), Xbox One und HoloLens mit einer einzigen Codebasis Spiele entwickeln. Darüber hinaus wurden die Windows Stores in einem zentralen Store zusammengeführt, hat Microsoft die Xbox Live Services zu Windows 10 gebracht sowie die Xbox-App eingeführt, um Gamer in allen Windows-Gerätefamilien stärker einzubeziehen.

Für Spieleentwickler ist Unity eine der beliebtesten Engines. Mit 21 unterstützten Plattformen bietet sie die beste plattformübergreifende Unterstützung sämtlicher derzeit verfügbarer Middleware. Dank ihres Editors in Kombination mit der Unterstützung für C#-Skripts wird eine überaus produktive Umgebung für die Entwicklung von Spielen zur Verfügung gestellt. Durch den Asset Store, die Unity-Community und die zahlreicher werdenden Funktionen von Unity in Form von Werbeanzeigen, Interaktion und Analyse war es noch nie einfacher, ein immersives Spiel zu entwickeln.

Wenn die Konstellation der Sterne günstig ist, müssen wir darüber schreiben! Dieser Artikel bietet Ihnen alle Einzelheiten, die Sie brauchen, damit Ihre Unity-Spiele unter Windows 10 überzeugend laufen. Dies ist keine Einführung in Unity oder UWP-Apps. Wir gehen davon aus, dass Sie mit diesen beiden Themen bereits vertraut sind, und konzentrieren uns stattdessen auf die Änderungen, die Windows 10 mit sich bringt, und Insidertipps zum Entwickeln toller universeller Windows-Games (UWGs). Wir steigen dazu gleich in die Praxis ein, und stellen Ihnen einige Änderungen vor, die wir an einem Spiel mit dem Namen Chomp (siehe Abbildung 1) vorgenommen haben, um es für Windows 10 zu optimieren.

Chomp
Abbildung 1: Chomp

Chomp ist zunächst einmal ein mit Unity geschriebenes Windows 8.1-Spiel. Wie das Bildschirmfoto in Abbildung 1 zeigt, ist es ein ziemlich einfaches mit Pac-Man vergleichbares Labyrinthspiel. Dieses Beispiel wurde als Leitfaden für Entwickler erstellt, um das Schreiben eines Spiels mit Unity zu veranschaulichen, weshalb Einfachheit das Hauptkriterium war. Doch da Windows 10 nun verfügbar ist und Unity das neue Betriebssystem unterstützt, musste Chomp aktualisiert werden. Sie finden den Quellcode für Chomp unter bit.ly/UnityChomp. Laden Sie ihn herunter, und begeben Sie sich mit uns auf die Reise.

Um eine UWP-Version unseres Spiels zu erhalten, könnten wir einfach das Spiel mit dem Windows 10-Profil in Unity exportieren, doch sorgt dies nicht für eine Anwendung, die für die Funktionsweise von Windows 10 optimiert ist. Sie lässt u. a. nicht das Laufen in einem Fenster, den Vollbildmodus und keine Toucheingaben zu. Werfen wir nun einen Blick darauf, was wir getan haben, um dieses Spiel von Windows 8.1 zu Windows 10 zu portieren.

Erste Schritte (Voraussetzungen)

UWP-Apps (und UWGs) erfordern, dass Entwicklung und Tests mit Windows 10 und Visual Studio 2015 erfolgen. Sämtliche Visual Studio 2015-Editionen bieten alles, was Sie brauchen, um Spiele zu entwickeln, sogar das kostenlose Visual Studio Community 2015!

Was Unity angeht, benötigen Sie mindestens Unity 5.2.1p2. Mit Unity 5.2 werden nun Visual Studio Community 2015 und Visual Studio 2015 Tools für Unity (VSTU) installiert, sodass Sie in der Praxis für den Einstieg nur Unity installieren und während des Installationsvorgangs die entsprechenden Optionen auswählen müssen. Abbildung 2 zeigt Einzelheiten.

Abbildung 2: Durch Installation von Unity mit den entsprechenden Optionen erhalten Sie alles, was Sie für den Einstieg brauchen

Hinweis: Für auf einem Mac arbeitende Entwickler ist eine neue Alternative das Verwenden des Visual Studio Code-Editors mit Unity-Projekten. Weitere Details zu dieser Option finden Sie unter bit.ly/UnityVSCode.

Erstellen von Builds für Windows 10

Das Erstellen von Builds für Windows 10 erfolgt genauso wie bisher. Es gibt ein neues SDK für UWP-Apps auf der Windows Store-Plattform (siehe Abbildung 3), das das Spiel als UWP-App exportiert.

Abbildung 3: Entwickeln für Windows 10 in Unity

Hier nun einige der wichtigen Vorgänge, die während des Exports für Windows 10 und der UWP-Entwicklung "unter der Haube" ablaufen:

Es gibt die neuen Präprozessoren UNITY_UWP und UNITY_WSA_10_0, mit denen Sie die Logik und das Erlebnis Ihres Spiels für die UWP anpassen können.
Unity 5.2 bietet nun die neue verbesserte "WinRTLegacy"-DLL, die weniger Typen als in früheren Versionen aufweist. Mit Windows 10 hat Microsoft im .NET Core-Profil wieder einige Typen erneut integriert, wodurch einige der Problemumgehungen für WinRTLegacy nicht mehr nötig sind.
Unity 5.2 verwendet das in Unity 5 eingeführte neue Plug-In-Modell. Dadurch werden Plug-Ins in Ihrem Workflow wesentlich vereinfacht, was weiter unten in diesem Artikel gezeigt wird.
Unity 5.2 bietet experimentelle Unterstützung für DirectX 12, das zum Funktionsumfang von Windows 10 gehört. Um diese experimentelle Unterstützung auszuprobieren, öffnen Sie in Unity "Player Settings". Deaktivieren Sie die Option "Auto Graphics API", und fügen Sie Unterstützung für Direct3D12 manuell hinzu.

Neue Projektvorlagen

Beim Unity-Buildprozess wird nun ein Visual Studio 2015-Projekt erzeugt, das mit der UWP kompatibel ist. Wie Sie wahrscheinlich schon wissen, weist dieses neue Projektsystem einige erhebliche Änderungen auf.

Beispielsweise enthält jede UWP-App nun eine eigene Kopie von .NET Core, sodass Sie stets über die .NET-Version verfügen, mit der Sie getestet haben. Um dies zu realisieren, generiert Unity eine entsprechende Datei "project.json", die die ordnungsgemäßen .NET-Komponenten über NuGet bezieht.

Ferner nutzen UWP-Apps .NET Native, das einen optimierten, systemeigenen Maschinencode generiert, bevor Ihre App auf die Computer der Kunden heruntergeladen wird, und für Ihre Spiele schnellere Startzeiten und einen niedrigeren Akkuverbrauch ermöglicht. Die Auswirkungen dieser Optimierungen variieren basierend auf der Komplexität Ihres Spiels, beeinträchtigen aber keinesfalls dessen Leistung. Der einzige Nachteil von .NET Native sind die (wesentlich) längeren Kompilierzeiten in Visual Studio. Bei herkömmlichen Apps kompiliert Visual Studio nur die "Release"-Konfiguration des Projekts mit .NET Native. Mit der von Unity generierten Projektdatei wird ein ähnlicher Ansatz befolgt, bei dem nur die "Master"-Konfiguration mit .NET Native kompiliert wird. Wenn Ihnen die Konfigurationsziele in Unity noch nicht bekannt sein sollten, es gibt drei:

"Debug" ist ein vollständiges Debugprojekt ohne Optimierungen.
"Release" ist ein mit Optimierungen kompiliertes Projekt, das aber die Profilerstellung einschließt.
"Master" ist die Konfiguration, die Sie im Store veröffentlichen, die über keinen Debugcode mehr verfügt, bei der alle Optimierungen aktiviert sind und die Profilerstellung wegfällt.

Sie sollten unbedingt schon frühzeitig in Ihrem Entwicklungszyklus eine Kompilierung und Tests ausführen. Unity arbeitet umfassend mit erweiterter IL-Einbindung (Intermediate Language), und wenn es einen Typ von App gibt, der .NET Native am stärksten beansprucht, dann ist das ein Unity-Spiel. Um sicherzustellen, dass die Dinge wie gewünscht laufen, achten Sie während der .NET Native-Kompilierung im Ausgabefenster auf Warnhinweise.

Die zuvor erwähnten Unterschiede zur Laufzeit sind erheblich, doch die neuen Unity-Vorlagen machen diese Änderungen Ihnen als Entwickler transparent. Deshalb wollen wir uns darauf konzentrieren, Ihr Spiel für Windows 10 anzupassen und zu optimieren.

Anpassen und Optimieren Ihres Spiels für Windows 10

Eine Codebasis für viele Formfaktoren ist ein Hauptmerkmal der UWP, doch was Spiele angeht, sind ggf. für bestimmte Formfaktoren noch weitere Anpassungen und Optimierungen erforderlich. Dazu zählen in der Regel: Eingabemechanismen (z. B. Touch, Tastatur, Maus und Gamepad), Größenänderung von Fenstern, Optimierung von Ressourcen und Objekten sowie Implementierung der systemeigenen Plattformintegration, z. B. Live-Kacheln, Benachrichtigungen oder Cortana, beim jeweiligen Formfaktor. Nun wollen wir uns ansehen, was dies für universelle Windows-Games bedeutet.

Fenstertechnik Universelle Windows-Apps werden in Fenstern mit änderbarer Größe gehostet, anstatt wie unter Windows 8 und 8.1 im Vollbild ausgeführt zu werden. Deshalb ist die Fenstertechnik nun eine Überlegung für Ihre Spiele und Anwendungen. Die meisten dieser Unterschiede sind für Sie als Unity-Entwickler nachvollziehbar, da die Eigenschaften "Screen.height" und "Screen.width" den verfügbaren Platz weiter in systemeigenen Größen (in Pixeln) melden.

Windows 10 bietet außerdem neue APIs zum Aktivieren und Deaktivieren des Vollbildmodus. Diese werden über die Unity-Klasse "Screen" durch Festlegen der "Screen.fullScreen"-Eigenschaft verfügbar gemacht. Eine bewährte Methode bei der Fenstertechnik ist die Implementierung der standardmäßigen Zugriffstasten zum Wechseln in und aus dem Vollbildmodus. Diese variieren je nach Herausgeber, doch gängige Tasten bzw. Tastenkombinationen zum Aktivieren und Deaktivieren des Vollbildmodus sind F11 und ALT+EINGABETASTE. Für Chomp wollten wir Spielern diese Option zum Spielen im Vollbild geben, weshalb der Vollbildmodus wie folgt aktiviert bzw. deaktiviert werden kann:

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

Ein Desktop mit mehreren Fenstern ist eine weitere erforderliche Änderung für Windows 10-Spiele: Sie müssen mit Änderungen des Eingabefokus zurechtkommen. Wenn Ihr Spiel bei einem Desktop mit mehreren Fenstern nicht den Eingabefokus hat, müssen Ihr Spiel und die Musik angehalten werden, da der Benutzer ggf. in einem anderen Fenster aktiv ist. Unity abstrahiert diese Interaktion mit derselben API, die es auf anderen Plattform verfügbar macht: der "OnApplicationPause"-Methode. Diese Methode wird in allen aktiven MonoBehaviours aufgerufen, wenn sich der Eingabefokus geändert hat. Für Chomp setzen wir das wie in Abbildung 4 gezeigt um.

Abbildung 4: Anhalten des Spiels bei geändertem Eingabefokus

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);
  }
}

Beachten Sie die Asymmetrie: Wenn das Spiel nicht mehr den Eingabefokus hat, wird es samt Audio angehalten, doch wenn es wieder den Eingabefokus hat, wird nur das Audio fortgesetzt. Dies geschieht, weil wir bei Anhalten des Spiels auch ein entsprechendes Dialogfeld im Spiel selbst einblenden. Wenn es wieder den Eingabefokus hat, wartet das Spiel auf die Bestätigung des Benutzers, dass er das Spiel fortsetzen möchte. Das Dialogfeld übernimmt das Zurücksetzen des Spielstatus von "Angehalten" in "Ausgeführt".

Mit diesen beiden implementierten Änderungen bieten wir ordnungsgemäß die Möglichkeit, das Vollbild zu aktivieren/deaktivieren und das Spiel anzuhalten, wenn unser Fenster nicht mehr den Eingabefokus hat.

Eingabe Frühere Unity-Versionen boten bereits eine umfassende Unterstützung für Eingaben in Windows-Spiele, was für Windows 10 auch weiter gilt. Die Eingabe per Maus, Touch und Gamepad wird in Unity mithilfe der "Input"-Klasse und des Input Managers weiter wie gewünscht abstrahiert.

Der wichtigste anzumerkende Aspekt hinsichtlich der Eingabe ist, dass Sie so viele Eingabemechanismen implementieren müssen, wie es für Ihre Spiele sinnvoll ist. Für Chomp wollen wird die Eingabe per Tastatur, Gamepad und Touch unterstützen. Denken Sie daran, dass UWGs überall ausgeführt werden können, weshalb Sie Ihren Spielern das bestmögliche Eingabe-/Spielerlebnis bieten müssen. Die häufigste Frage, die sich bei der Eingabe stellt, ist, wie erkannt werden soll, ob Touchsteuerelemente (wie ein virtueller Joystick oder Steuerkreuz) angezeigt werden soll, wenn das Spiel auf einem Touchgerät wie einem Smartphone gespielt wird.

Eine Möglichkeit zum Bestimmen, ob der Touchjoystick angezeigt werden soll, ist festzustellen, ob das Spiel auf einem Smartphone ausgeführt wird. Falls ja, wäre es sinnvoll, den Joystick anzuzeigen und standardmäßig zu aktivieren. Um zu bestimmen, ob das Spiel auf einer bestimmten Plattform ausgeführt wird (z. B. einem Smartphone oder der Xbox), können Sie prüfen, ob der entsprechende Vertrag implementiert ist. So stellt Chomp fest, ob es unter Windows 10 Mobile ausgeführt wird:

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
  }
}

In diesem Code verwenden wir den Präprozessor UNITY_WSA_10_0 zum Bestimmen, ob die Kompilierung für Windows 10 erfolgt. Ohne diese Überprüfung könnte der Code nicht für Nicht-Windows 10-Builds kompiliert werden.

Das ständige Anzeigen des virtuellen Joysticks wäre auch ein Ansatz, doch es ist vielleicht besser, den Joystick nur anzuzeigen, wenn der Benutzer tatsächlichen den Touchbildschirm auf einem Gerät nutzt. Windows 10 bietet eine neue API, die feststellt, ob ein Benutzer Windows 10 im Tabletmodus mit Toucheingabe oder herkömmlichen Desktopmodus mit Maus-/Tastatureingabe nutzt: Windows.UI.ViewManagement.UIViewSettings.UserInteractionMode. Diese API muss im Windows UI-Thread ausgeführt werden, weshalb Sie in Unity den Aufruf des UI-Threads marshallen müssen. Wir haben Chomp den in Abbildung 5 gezeigten Code hinzugefügt, um zu bestimmen, ob der Benutzer per Touch mit der App interagiert.

Abbildung 5: Code zum Bestimmen, ob der Benutzer einen Touchbildschirm verwendet

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;
  }
}

Nach der Implementierung dieser beiden Methoden können wir Chomp aktualisieren, um eine wohl begründete Vermutung anzustellen, wann der Joystick gezeigt werden sollte. Wenn das Spiel auf einem Mobilgerät ausgeführt wird oder der interaktive Benutzermodus "Touch" ist, wird "true" von "UseJoystick" zurückgegeben, weshalb wir den Joystick anzeigen:

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

Nun da wir die Fenstertechnik und Eingabe im Griff haben, können wir uns den neuen systemeigenen Windows-APIs zuwenden, um unserem Spiel mehr Funktionalität hinzuzufügen.

Systemeigene Integration mit Windows 10: Erklärung zur Plattform Die systemeigene Integration mit dem Betriebssystem in einem Unity-Spiel erfolgt auf dieselbe Weise wie zuvor: Wenn Sie in Unity die Kompilierung mit der Option ".NET Core" (mit dem Präprozessor NETFX_CORE) durchführen, können Sie systemeigenen Code inline verwenden (siehe unsere vorherigen Beispiele).

Wenn der Code, den Sie hinzufügen möchten, größer ist, als was Sie inline verwenden möchten oder das Verhalten (für andere Plattformen) abstrahiert werden muss, können Sie weiter Plug-Ins verwenden. Für Windows 10 stellt das Microsoft Developer Experience Games Evangelism-Team (zu dem wir gehören) mehrere neue Plug-Ins als Open Source zur Verfügung, um Ihnen die Integration mit Windows 10 zu erleichtern. Sie finden diese Plug-Ins unter bit.ly/Win10UnityPlugins. Bislang wurden die folgenden Plug-Ins freigegeben:

Speichern: Ein Store-Plug-In für In-App-Einkäufe mit Unterstützung für App-Simulator, Verbrauchsgüter, Gebrauchsgüter und Einnahmen. Alles, was Sie für Transaktionen mit dem Windows Store brauchen, finden Sie hier.
AzureMobile: A Microsoft Azure-Plug-In für grundlegende Azure Storage-Vorgänge (Erstellen, Lesen, Aktualisieren, Löschen).
Core: Ein Haupt-Plug-In, das eine systemeigene Integration mit Hauptfeatures des Betriebssystems bietet, wie z. B. Live-Kacheln, lokale Benachrichtigungen, Pushbenachrichtigungen und Cortana.
Ads: Ein Plug-In, das das neue Windows 10 Microsoft Ads SDK umschließt und nun Unterbrecherwerbung per Video unterstützt.

Zuvor ermöglichte Chomp keine In-App-Käufe, weshalb wir uns entschieden haben, diese dem Spiel mithilfe des Store-Plug-Ins hinzuzufügen. Chomp unterstützt nun den Kauf von Verbrauchsgütern (Leistungsschüben) und Gebrauchsgütern (Labyrinthen).

Die einfachste Möglichkeit zum Verwenden dieser Plug-Ins ist das Herunterladen des Unity-Pakets von GitHub und dessen Import in Chomp im Unity Editor über "Assets | Import Package | Custom Packages". Nach dem Import des Pakets befinden sich die ordnungsgemäßen Binärdateien im Ordner "Unity Plugins". Nach der Installation befinden sich die Binärdateien im Verzeichnis "Plugins\WSA directory". Unity erfordert, dass (mit Microsoft .NET Framework 3.5 kompatible) Platzhalter im Editor verwendet werden, weshalb diese ebenfalls hinzugefügt und in den Ordner "Plugins" selbst kopiert werden.

Nach dem Import des Pakets können wir nun in Chomp auf die Store-API verweisen. Wir rufen zunächst "Store.LoadListingInformation" auf, und stellen eine Rückrufmethode bereit, die nach Abschluss ausgeführt wird, um eine Auflistung aller Elemente zu erhalten, die zum Kauf zur Verfügung stehen. Falls der Aufruf Erfolg hat, durchlaufen wir die zurückgegeben "ProductListing"-Elemente und verwenden sie zum Auffüllen der Preise auf unserer Benutzeroberfläche (siehe Abbildung 6).

Abbildung 6: Liste mit für In-App-Käufe verfügbaren Elementen

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

Nachdem der Benutzer das Element ausgewählt hat, das er kaufen möchte, sind für die Ausführung der Transaktion nur einige wenige Codezeilen erforderlich. Abbildung 7 zeigt den Code, den wir zum Kauf von Gebrauchsgütern (neue Labyrinthe für das Spiel) hinzugefügt haben.

Abbildung 7: Durchführen eines In-App-Kaufs

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;
        }                 
      }
    });
  }
}

Wie Sie sehen, können diese neuen Plug-Ins einfach genutzt werden, um systemeigene Funktionalität zu implementieren.

Übermittlung in den Store

Die Übermittlung in den Windows Store ist so einfach wie nie zuvor. Sie können nun ein einzelnes Paket übermitteln, das alle Binärdateien enthält, oder Sie können nach Wunsch ein Paket für jede Plattform/Architektur übermitteln.

Wenn Sie Ihre Pakete aufteilen oder Ihr Spiel nur auf bestimmten Plattformen unterstützen möchten, können Sie die Datei "package.appxmanifest" manuell bearbeiten und das "TargetDeviceFamily"-Element anpassen:

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

Die drei möglichen Gerätefamilien sind:

Windows.Universal: Ermöglicht die Bereitstellung Ihrer Binärdateien auf allen Geräten, die Ihre Hardwareanforderungen erfüllen.
Windows.Mobile: Muss für Binärdateien verwendet werden, die zu Windows 10 Mobile SKUs gehören, und zwar Windows Phone, wenngleich es künftig wahrscheinlich andere Kleingeräte (bis max. 6 Zoll) geben wird, die keine Telefone sind und auf denen diese SKU ausgeführt wird. Gehen Sie also nicht nur von Smartphones aus.
Windows.Desktop: Muss für Spiele verwendet werden, die nur auf Desktop-PCs und Tablets gespielt werden können.

Wenn Sie auf die mobile und Desktopfamilie, aber nicht auf Konsolen oder andere spätere Familien von Windows abzielen, können Sie in Ihrer Manifestdatei zwei Gerätefamilien wie folgt angeben (ersetzen Sie "x" und "y" entsprechend):

<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>

Für jede Gerätefamilie können Sie unterschiedliche Angaben für "MinVersion" und "MaxVersionTested" angeben. Dies ist für die Zukunft praktisch, da Windows 10 Mobile mit einer höheren Versionsnummer als Windows 10 Desktop ausgeliefert wird. Für den Moment empfehlen wir das Belassen der Standardversionen (10.0.10240.0).

Wenn Sie, wie bereits bei den Erörterung zu .NET Native erwähnt, Ihre Pakete an den Store übermitteln, wählen Sie die "Master"-Konfiguration. Außerdem empfehlen wir das Hinzufügen der vollständigen PDB-Symboldateien (Program Database) für die Absturzanalyse. Der neue Store bietet keine Möglichkeit zum Herunterladen von CAB-Dateien zur lokalen Analyse. Stattdessen müssen Sie Ihre PDB-Dateien an den Windows Store übermitteln, damit der Store diese Aufgabe für Sie übernimmt und Ihnen die Stapelüberwachungen für Abstürze zurückgibt (siehe Abbildung 8).

Abbildung 8: Hinzufügen von PDB-Symboldateien

Wählen Sie schließlich beim der Übermittlung in den Windows Store über das Entwicklerportal die richtige Hardwarekonfiguration. Der Store ermöglicht Ihnen nun das Angeben von Hardwareanforderungen wie Touch oder Tastatur, damit Ihr Spiel nur auf den entsprechenden Geräten installiert wird (siehe Abbildung 9).

Abbildung 9: Im Entwicklerportal verfügbare Hardwareeinstellungen

Es gibt noch viel mehr!

Dieser Artikel bietet einen Kurzüberblick für Unity-Entwickler und erläutert, wie wir unser einfaches Spiel auf Windows 10 portiert und einige neue Features hinzugefügt haben. Wir haben uns dabei auf die Grundlagen und spielspezifisch auszuführenden Schritte konzentriert, anstatt Ihnen alle neuen Features auf der Windows 10-Plattform zu präsentieren. Wenn Sie über ein faszinierendes, immersives Spiel verfügen, erwägen Sie das Nutzen zusätzlicher Features, wie z. B. des neuen Benachrichtigungscenters auf Desktops (zum Fördern der Interaktion), Cortana, der neuen Live-Kachelvorlagen und der neuen Xbox Live Services-APIs. Mit Windows 10 öffnet Microsoft stufenweise den Zugriff auf Xbox Live Services. Sie müssen kein Konsolenspiel schreiben. Sie brauchen lediglich ein tolles unter Windows 10 laufendes Spiel und wollen Dienste wie Bestenlisten, Erfolge, geräteübergreifendes Spielen usw. nutzen. Um den Zugriff zu beantragen, registrieren Sie sich für das ID@Xbox-Programm unter xbox.com/id.

Visual Studio 2015 Tools für Unity

Ab Version 5.2 enthält Unity die Visual Studio 2015 Tools für Unity (VSTU), wodurch Visual Studio der neue standardmäßige Code-Editor für Unity-Projekte unter Windows wird. Diese Änderung bringt verbessertes IntelliSense, eine farbliche Darstellung der Syntax im Editor und einen leistungsstarken C#-Debugger mit sich. Zum Konfigurieren des standardmäßigen Skript-Editors wählen Sie im Unity Editor die Menüoption "Edit | Preferences" aus. Zu Ihren Optionen zählen MonoDevelop (integriert), Visual Studio 2015, Visual Studio 2013 oder die Möglichkeit der Suche nach weiteren Optionen.

VSTU umfasst auch einige Schnellzugriffsmöglichkeiten zum einfacheren Schreiben von Code für Unity. Wenn Sie beispielsweise in einer "MonoBehaviour"-Klasse mit der rechten Maustaste klicken, enthält das Kontextmenü den neuen Eintrag "Implement MonoBehaviours", über den Sie schnell eine "MonoBehaviour"-Methodensignatur in Ihre Klasse einfügen können.

Im selben Kontextmenü gibt es auch den Eintrag "Quick MonoBehaviours", der eine ähnliche Aufgabe erfüllt, jedoch mithilfe eines weniger aufdringlichen Dialogfelds, in dem Sie den gesuchten Methodennamen eingeben können. Die Signatur wird erneut eingefügt. Für diese beiden Methoden gibt es für einen noch schnelleren Zugriff auch Tastenkombinationen (STRG+UMSCHALT+M und STRG+UMSCHALT+Q).

Über die Verbesserungen am Editor hinaus ist eines der besten Features beim Arbeiten mit VSTU die optimierte Debuggerintegration mit dem Unity Editor. Wenn ein Unity-Projekt in Visual Studio geöffnet ist, wird automatisch die Schaltfläche "An Unity anfügen" für das Debuggen auf der Debugging-Standardsymbolleiste angezeigt. Abbildung A zeigt, wo sich diese Schaltfläche befindet. Über diese Schaltfläche wird der Unity Editor-Prozess automatisch gefunden, an den das Anfügen erfolgt. Von hier aus können Sie reibungslos Haltepunkte setzen, Variablenwerte analysieren und nahezu alles erledigen, was Sie von Visual Studio erwarten. VSTU bietet sogar die experimentelle Unterstützung von Unterbrechungen bei Ausnahmen. Weitere Details zu VSTU 2.0-Features finden Sie im Blogbeitrag "Visual Studio Tools for Unity 2.0" unter bit.ly/VSTUInfo.

Hinweis: Wenn Sie nicht für Windows 10 entwickeln und Visual Studio 2013 verwenden, gibt es ein herunterladbares Paket, das all die Qualitäten, die wir hier beschrieben haben, den Benutzern von Visual Studio 2013 Community Edition zur Verfügung stellt. Sie finden diese Erweiterung unter bit.ly/VSTU2013.

Jaime Rodriguezist Leiter des Microsoft Developer Experience Games Evangelism-Teams. Sie finden ihn auf Twitter: @jaimerodriguez und in seinem Blog unter jaimerodriguez.com.

Brian Peekist ein Senior Game Developer Evangelist bei Microsoft. Er ist ein Hardcoregamer und entwickelt Spiele für Windows, Konsolen und alles, wofür sonst noch programmiert werden kann, solange er sich erinnern kann. Sie können ihm als Redner auf einer der landesweiten Entwicklerkonferenzen begegnen oder ihm auf Twitter: @BrianPeek und über seinen Blog brianpeek.com folgen.

Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Sanjeev Dwivedi und Adam Tuliper
Sanjeev Dwivedi ist ein Senior Game Developer Evangelist bei Microsoft. Sie erreichen Ihn unter sanjeev.dwivedi.net.

Adam Tuliper ist ein Senior Technical Evangelist bei Microsoft. Sie erreichen ihn auf Twitter unter @AdamTuliper.