Unity durchsuchen

Mehr als mobil

Nutzen Sie die Impulse durch Windows 10 und neue Absatzmöglichkeiten im Windows Store.

Portierungsanleitungen

Einleitung

Die Erstellung von Spielen mit Unity ist immer beliebter geworden, insbesondere, wenn es darum geht, Spielen mit nur einer Codebase auf verschiedenen Plattformen und auf verschiedenen Gerätetypen zum Durchbruch zu verhelfen. Das Gleiche gilt für die Erstellung von Spielen für Windows 10 mit der "Universal Windows Platform" (UWP). In diesem Whitepaper erfahren Sie, wie Sie Ihre Unity-Kenntnisse nutzen können, um Spiele für die UWP zu erstellen. Die behandelten Themen sind unter anderem:

  • Kompilierung Ihres Spiels für die UWP
  • optimale Vorgehensweisen in der Windows-Umgebung
  • Implementierung plattformspezifischer Funktionen
  • Erläuterung wichtiger Plug-ins
  • Veröffentlichung im Windows Store

Um wichtige Einzelheiten zu illustrieren, die notwendig sind, um ein Unity-Spiel auf die UWP zu bringen, nutzen wir ein existierendes Spiel und leiten Sie Schritt für Schritt durch die verschiedenen Aspekte und Überlegungen, die beim Export auf die UWP und für die nachfolgende Bereitstellung im Windows Store beachtet werden müssen.

Hinweis: Diese Anleitung setzt voraus, dass Sie über Grundlagen-Kenntnisse zur Benutzung von Unity3D verfügen. Mehr über Unity3D erfahren Sie jederzeit in den Unity-Tutorials.

Voraussetzungen zum Schreiben eines UWP-Spiels mit Unity

Für die Entwicklung, Kompilierung und Übertragung eines Unity-Spiels zum Windows Store benötigen Sie:

  • Unity 5.3.5. Möglich sind die kostenlose Unity-Version sowie Unity Pro. Die Add-ons für die Veröffentlichung im Windows Store sind sowohl für die Nutzer der Basic-Version als auch für Unity Pro-Nutzer kostenlos.
  • Visual Studio. Sie können eine beliebige Visual-Studio-SKU benutzen, auch das kostenlose Visual Studio Express. Für die Universal Windows Platform benötigen Sie Visual Studio 2015 Update 1.
  • Windows 10. Wenn Sie keine Windows 10-Lizenz besitzen, können Sie eine 90-Tage-Testversion benutzen. Wenn Sie Mac OS X benutzen oder auf Apple-Hardware installieren möchten, prüfen Sie die verschiedenen Installationsoptionen mit Boot Camp, VMWare oder Parallels.
  • Microsoft-Konto. Sie benötigen ein kostenloses Microsoft-Konto, um eine Entwicklerlizenz zu erhalten.
  • Windows Store-Entwicklerkonto. Dieses Konto benötigen Sie, um Ihr Spiel im Windows Store bereitzustellen. Während dieses Vorgangs werden Sie registriert und als Einzelperson oder Unternehmen verifiziert, die/das Apps und Spiele im Store einreichen kann. Diese Registrierung wird mit Windows Phone geteilt (eine Registrierung kann Apps an beide Stores übertragen). Für Einzelpersonen kann eine geringe Registrierungsgebühr anfallen, wobei über von Microsoft gesponserte Programme (z. B. für Studenten oder Start-Ups) häufig kostenlose Dev-Center-Konten zur Verfügung gestellt werden.
  • Windows 10-Testgeräte. Der Simulator kann Multi-Touch und verschiedene Bildschirmauflösungen simulieren, wir empfehlen jedoch den Test auf einem tatsächlichen ARM-Mobilgerät mit Touch-Fähigkeit, wenn Sie eine Mobil-/Touch-Erfahrung erstellen.

Dieses Dokument wurde mit Unity 5.3.5, Visual Studio 2015 Update 2 und Windows 10 Version 1511 erstellt. Wir empfehlen, dass Sie mindestens Unity 5.3.2 und Visual Studio Update 1 benutzen, da ältere Versionen ein anderes API verwenden oder andere Inkompatibilitäten vorhanden sein könnten.

Windows Store

Windows Store bietet jetzt einen einzelnen Ort, um Ihre UWP-Apps zu übertragen und hochzuladen. Sie können immer noch ältere Betriebssysteme verwenden, doch in diesem Dokument konzentrieren wir uns auf die Übertragung Ihres Spiels als UWP-App zum Windows Store.

NuGet

NuGet ist der Paket-Manager für die Microsoft-Entwicklungsplattform inklusive .NET. NuGet ermöglicht Entwicklern, Bibliotheken von Drittanbietern zu finden und sie Projekten als Kopplungen hinzuzufügen. Mit NuGet können Sie alle Windows-Bibliotheken bereitstellen, die Sie nativ nutzen müssen. NuGet kann außerdem zur Verwaltung von dynamisch gelinkten Bibliotheken (DLL) verwendet werden, die in Unity von Ihren Skripts aufgerufen werden.

NuGet wird weiterhin für die Portierung von Unity-Spielen zur UWP benötigt. Wenn Sie ein Projekt von Unity zu einer Visual Studio-UWP-App exportieren, braucht Unity NuGet, um alle Bibliotheken zu installieren, die zum Anvisieren des .NET-Core erforderlich sind.

Unity für die Bereitstellung im Windows Store einrichten

In diesem Abschnitt erfahren Sie, was notwendig ist, um ein bestehendes Unity-Spiel für die Bereitstellung als UWP-Spiel ("Universal Windows Platform"-Spiel) im Windows Store einzurichten. Die folgenden Themen werden behandelt:

  • Den Entwickler-Modus in Windows 10 aktivieren
  • Spiel-Details in Unity eingeben
  • Export zu UWP in Windows 10
  • Build Solution in Visual Studio 2015 Update 2 mit Window 10 SDK
  • Verknüpfung Ihres Spiels mit Windows Store
  • Hinzufügen erforderlicher Bilder/Inhalte (z. B. Logo, Icon, Splash), falls noch nicht in Unity erledigt
  • Ausführen des Windows App Certification Kit (WACK)
  • Veröffentlichung im Windows Store

Den Entwickler-Modus in Windows 10 aktivieren

Es ist nicht länger eine Entwickler-Lizenz für jedes Gerät notwendig, mit dem Sie Ihre App entwickeln, installieren oder testen möchten. Stattdessen können Sie jetzt ein Gerät über dessen Einstellungen einmalig für diese Aufgaben aktivieren.

Windows 10-Geräte aktivieren

Für Windows 10 müssen Sie Ihr Desktop, Tablet oder Telefon, das Sie verwenden möchten, unter "Systemeinstellungen" für die Entwicklung aktivieren.

Gehen Sie dazu zu den Systemeinstellungen und wählen Sie "Aktualisierung und Sicherheit" aus. Wählen Sie dann "Für Entwickler" aus. Hier können Sie dann ganz einfach den "Entwicklermodus" auswählen und aktivieren.

Weitere Informationen dazu finden Sie hier.

Spiel-Details in Unity eingeben

Einer der ersten Schritte zur Vorbereitung Ihres Spiels in Unity ist sicherzustellen, dass die richtigen Build-Einstellungen konfiguriert sind.

Um Unity-Spiele für UWP-Apps ("Universal Windows Platform"-Apps) zu erstellen, benötigen Sie:

Um Ihre Einstellungen in Unity zu konfigurieren, klicken Sie zunächst auf "File", dann auf "Build Settings".

Klicken Sie dann auf die "Player Settings…"- Schaltfläche.

Im Fenster Player Settings können Sie dann Ihre Spiel-Details eingeben.

Wenn Sie möchten, können Sie in diesem Fenster auch Logo- und Tile-Bilder hinzufügen, Player Settings die im Windows Store angezeigt werden. Wie viele Einzelheiten bei der Erstellung von Unity-Apps für den Windows Store können Sie dies aber auch auf vielen anderen Wegen tun; Sie können das Hinzufügen von Bildern duch die Unity IDE auch verschieben und stattdessen später mit Visual Studio erledigen.

Ihre Build-Einstellungen sind jetzt in Unity3D so konfiguriert, dass der Export zur UWP möglich ist.

Export zur Universal Windows Platform

In diesem Abschnitt wird der bestehende Unity-Support für UWP-Apps ("Universal Windows Platform"-Apps) vorgestellt und erläutert, wie man von Unity zu UWP exportiert.

Unity3D hat seit Unity 5.2 UWP-Apps unterstützt. Im Moment können Sie zu UWP exportieren, indem Sie in der "Windows Store"-Plattform im Fenster "Build Settings" das Universal 10 SDK auswählen, wie unten dargestellt:

Unity 5.3.5 exportiert Visual Studio 2015 Solutions-Dateien, die dann auf Windows 10-Geräten laufen.

Drei Architekturen werden unterstützt: ARM, x86 und x64. Zusätzlich können Sie .NET Core 5.0 für Ihre Game-Projekte benutzen.

Wenn Sie auf die "Build"-Schaltfläche im Fenster "Build Settings" klicken, erscheint ein "Build Windows Store"-Fenster, in dem Sie einen Ordner für die Erstellung Ihres Spiels auswählen müssen.

Sobald Sie den Ordner ausgewählt haben, beginnt Unity mit dem Build Ihres Spiels für die von Ihnen ausgewählte Plattform. Bei großen Spielen kann dies einige Minuten dauern.

Danach wird in einem "Windows Explorer"-Fenster der Ordner angezeigt, der alle von Unity erzeugten Dateien enthält.

Weitere Einzelheiten zu diesem Vorgang erfahren Sie in der Unity3D- Dokumentation über Windows.

Build Solution in Visual Studio 2015 Update 2 mit Windows 10 SDK

Um Ihre UWP-App ("Universal Windows Platform"-App) zu verkaufen oder zu verbreiten, müssen Sie ein appxupload-Paket dafür erstellen. Dieses Paket erleichtert den Verkauf Ihrer App im Windows Store und ihre Verbreitung unter Nutzern. Wenn Sie dasappxupload-Paket erstellen, wird ein weiteres appx-Paket zum Testen und zum Sideloaden erstellt.Sie können Ihre App durch das Sideloaden des appx-Pakets auf ein Gerät direkt verbreiten.

Für Windows 10 erstellen Sie ein Paket (.appxupload), das zum Windows Store hochgeladen werden kann. Ihre App ist dann verfügbar und kann auf jedem beliebigen Windows 10-Gerät installiert und ausgeführt werden.

Hinweis: Wenn Sie ein App-Paket für eine Windows 8.1-App erstellen müssen, folgen Sie dieser Anleitung.

Jetzt können Sie Ihr Spiel in Visual Studio kompilieren.

Wählen Sie zunächst x86 oder x64 als Plattform aus.

Klicken Sie im Menü auf Build -> Build Solution.

Erlauben Sie dem "NuGet Package Manager", Pakete wiederherzustellen.

Klicken Sie auf "Run" und stellen Sie sicher, dass "Local Machine" ausgewählt ist.

Bestätigen Sie den abgeschlossenen Vorgang durch Klicken auf "Build succeeded".

Nach diesen Schritten können Sie Ihre App im Windows Store verkaufen. Wenn es sich um eine LOB-App ("Line of Business"-App) handelt, die Sie nicht verkaufen möchten, da Sie ausschließlich zur Nutzung durch interne Benutzer gedacht ist, können Sie diese App sideloaden, um Sie auf jedem beliebigen Windows 10-Gerät zu installieren.

Weitere Einzelheiten finden Sie unter Packen von Universal-Windows-Apps für Windows 10

Verknüpfung Ihrer App mit Windows Store

Wählen Sie im ProjektMenü "Store" -> "Associate App with the Store..." aus..

Daraufhin werden die meisten Felder im "Packaging"-Reiter des Manifest-Designers automatisch aktualisiert. Die folgenden Werte werden in die App-Manifest-Datei des aktuellen Projekts auf Ihrem Computer heruntergeladen:

  • Paket-Anzeigename
  • Paketname
  • Herausgeber-ID
  • Herausgeber-Anzeigename
  • Version

Wenn Sie die Standard-package.appxmanifest- Datei mit einer benutzerdefinierten .xml-Datei überschreiben, können Sie Ihre App nicht mit dem Store verknüpfen. Wenn Sie versuchen, eine benutzerdefinierte Manifest-Datei mit dem Store zu verknüpfen, erscheint eine Fehlermeldung. Wir raten dementsprechend davon ab, eine benutzerdefinierte Paket-Manifest-Datei zu erstellen.

Weitere Einzelheiten finden Sie unter Packen von Universal-Windows-Apps für Windows 10.

So übertragen Sie Ihre App zum Store

Sobald Sie Ihre App durch die Reservierung eines Namens erstellt haben, können Sie daran arbeiten, mit der Veröffentlichung zu beginnen. Zunächst müssen Sie dazu eine Eingabe vornehmen.

Typischerweise werden diese Eingaben gemacht, wenn die App fertig und zur Veröffentlichung bereit ist. Sie können aber auch schon Informationen eingeben, bevor Sie eine einzige Code-Zeile geschrieben haben. Die Eingabe wird in Ihrem Dashboard gespeichert, sodass Sie daran arbeiten können, wann immer Sie bereit dazu sind.

Nachdem Ihre App veröffentlicht ist, können Sie eine aktualisierte Version veröffentlichen, indem Sie eine weitere Eingabe in Ihrem Dashboard erstellen. Durch die Erstellung einer neuen Eingabe können Sie alle notwendigen Veränderungen vornehmen und veröffentlichen, unabhängig davon, ob Sie neue Pakete hochladen oder lediglich Details wie den Preis oder die Kategorie ändern.

Um eine neue Eingabe für eine App zu erstellen, klicken Sie auf "Update" neben der aktuellsten Eingabe, die auf der App-Überblicksseite angezeigt wird.

App-Eingabe-Kontrollliste

Unity stellt Ihnen die erforderlichen Assets für die Eingabe einer App zur Verfügung, aber wir empfehlen, dass Sie auch eigene Bilder und Assets verwenden. Im Folgenden sehen Sie einen Screenshot des Visual Assets-Abschnitts der Package.appxmanifest-Datei:

Sie können alle Assets prüfen, die vom Build-Prozess bereitgestellt werden.

Weitere Einzelheiten finden Sie unter App-Eingaben auf MSDN.

Ausführen des Windows App Certification Kit (WACK)

Damit Ihre App die besten Chancen hat, im Windows Store veröffentlicht oder Windows-zertifiziert zu werden, überprüfen und testen Sie sie, bevor Sie sie zur Zertifizierung einreichen. In diesem Abschnitt erfahren Sie, wie Sie das "Windows App Certification Kit" installieren und ausführen. WACK unterzieht Ihrer App einer Reihe von Tests und überprüft dabei beispielsweise die Performance und API-Konformität. Weitere Einzelheiten zu den Tests, die von diesem Kit durchgeführt werden, erfahren Sie in den folgenden Themenbereichen:

Voraussetzungen

Wenn Sie eine UWP-App ("Universal Windows Platform"-App) entwickeln, müssen Sie …

  • Windows 8, Windows 8.1 oder Windows 10 (empfohlen) installieren und ausführen
  • Windows App Certification Kit Version 10 installieren.

Um Windows App Certification Kit Version 10 zu installieren, das im Windows Software Development Kit (SDK) für Windows 10 enthalten ist, müssen Sie zunächst ein App-Paket erstellen, um den Test durchführen zu können. Wählen Sie im Menü "Project" Store -> Create App Packages… aus:

Wenn die Paketerstellung beendet ist, erscheint das folgenden Fenster, in dem Sie das Windows App Certification Kit (WACK) starten können:

Wenn Sie WACK starten, erscheint das folgende Dialogfenster:

Klicken Sie auf "Next", um mit der Überprüfung fortzufahren. Erschrecken Sie nicht, wenn jetzt mehrere Fenster angezeigt werden. Das Tool führt einfach nur Ihr Spiel aus und testet es dabei. Diese Tests können einige Minuten dauern.

Wenn die Tests abgeschlossen sind, erscheint das folgende Fenster. Wenn bei den Tests Fehler festgestellt wurden ("FAILED"), können Sie sie hier einsehen und korrigieren, um die Überprüfung danach zu wiederholen und ohne Fehler zu durchlaufen.

Durch Klicken auf den Link "Click here to view the results" öffnen Sie ein Browser-Fenster mit den Testergebnissen.

Hier können Sie jeden Test einsehen, herausfinden, was genau einen Fehler verursacht hat und ihn korrigieren. Wenn Sie alle Probleme behoben und die Tests wiederholt haben, sollte das folgende Fenster angezeigt werden:

Weitere Einzelheiten finden Sie unter Das Windows App Certification Kit benutzen auf MSDN.

Veröffentlichung im Windows Store

Ihr Spiel ist jetzt erstellt und hochgeladen und Sie können es über Ihr Entwickler-Konto im Store einreichen. Die folgenden Schritte führen Sie durch den Eingabeprozess.

  1. Öffnen Sie einen Browser und gehen Sie zu https://dev.windows.com.
  2. Melden Sie sich bei Ihrem Konto an und klicken Sie auf den Dashboard-Link.
  3. Wählen Sie den Namen des App-Pakets aus, das Sie in Visual Studio erstellt haben.
  4. Klicken Sie auf "Start your submission".
  5. In diesem Schritt müssen Sie Informationen über Ihr Spiel eingeben, bevor Sie Ihre Einreichung abschließen können. Wenn Sie auf einen der Links klicken, öffnet sich jeweils einen neue Seite, auf der Sie durch die Einzelheiten des Eingabeprozesses geführt werden.

Auf der "Packages"- Seite laden Sie die Paket-Dateien für die App hoch, die Sie einreichen (.xap, .appx, .appxupload und/oder appxbundle). Sie können in diesem Schritt Pakete für jedes Betriebssystem hochladen, auf das Ihre App abzielt.

Wenn ein Kunde Ihre App herunterlädt, durchsucht Windows Store alle für Ihre App verfügbaren Pakete und stellt dem Kunden automatisch das Paket zur Verfügung, das für sein Gerät am besten geeignet ist.

Weitere Informationen darüber, was ein Paket enthält und wie es struktutiert sein muss, finden Sie unter App-Paket-Anforderungen. Vielleicht möchten Sie auch mehr zu folgenden Themen erfahren:

Pakete zur Einreichung hochladen

Um Pakete hochzuladen, ziehen Sie sie in das "Upload"-Feld oder klicken Sie darauf, um Ihre Dateien zu durchsuchen. Die "Packages"- Seite lässt .xap-, .appx-, .appxupload- und/oder .appxbundle- Dateien zum Hochladen zu.

Hinweis: Für Windows 10 sollten Sie hier immer die .appxupload- Datei hochladen, nicht die .appx- oder .appxbundle-Datei. Weitere Informationen zum Packen von UWP-Apps ("Universal Windows Platform"-Apps) für den Store finden Sie unter Packen von Universal-Windows-Apps für Windows 10.

Wenn bei der Überprüfung Ihrer Pakete Probleme festgestellt werden, müssen Sie das Paket entfernen, die Fehler beheben und versuchen, es erneut hochzuladen. Weitere Informationen dazu finden Sie unter Paket-Upload-Fehler beheben.

Referenz-Implementierung

In diesem Abschnitt beziehen wir uns auf ein einfaches 3D-Basketball-Spiel, das Jb Evain in weniger als 20 Minuten live auf der Build erstellt hat. Wenn Sie das Spiel von Anfang an erstellen möchten, folgen Sie hier Jbs Erläuterungen. Das einzige externe Asset, das Sie für dieses Spiel erstellen müssen, ist diese Hoop.3ds- Datei.

Wenn Sie das fertige Projektpaket lieber herunterladen möchten, Basketball-At-Build.zip - es ist vollständig und spielbar. Sie können den restlichen Erklärungen in diesem Abschnitt folgen, sobald Sie die komprimierte Datei extrahiert haben.

Im Folgenden sehen Sie eine Szene aus dem fertigen Spiel:

Basketball

In den nächsten Schritten erläutern wir anhand eines Spiels die oben erklärten Abläufe, mit denen man ein Spiel für die Einreichung im Windows Store vorbereitet.

Wenn Sie das Spiel von Grund auf erstellen, müssen Sie diesen Schritten folgen. Wenn Sie das fertige Projekt heruntergeladen haben, können Sie die Schritte 1 bis 8 überspringen.

  1. Öffnen Sie Unity und erstellen Sie ein neues Projekt Sie können es "Basketball" oder "Fantastisches Spiel" nennen, wenn Sie möchten.
  2. Erstellen Sie eine Spielszene.
  3. Ziehen Sie Hoop.3ds vom Download-Speicherort ins Assets-Fenster.
  4. Wählen Sie Assets -> Import Packages -> Characters aus.
  5. Wenn das Asset heruntergeladen ist, klicken Sie auf die Schaltfläche "Import". Jetzt sind alle Assets in Ihrem Projekt verfügbar.
  6. Erstellen Sie eine Sphäre und fügen Sie Materialien hinzu, sodass sie Farbe und Sprünge enthält.
  7. Positionieren Sie Komponenten in der Szene.
  8. Schreiben Sie das Shooter-Skript, sodass Sie Bälle in den Basketballkorb werfen können.
  9. Klappen Sie im Reiter Projekt den Assets- Baum aus und klicken Sie auf den Scenes- Ordner.
  10. Doppelklicken Sie auf die Spiel Szene, um sie zu laden. Bevor wir fortfahren, lassen Sie das Spiel einmal laufen, um zu sehen, ob alles funktioniert.
  11. Da wir jetzt wissen, dass das Spiel funktioniert, können wir Ihre Fertigkeiten testen!

Das Visual-Studio-Projekt mit Unity erstellen

Sie haben jetzt das Spiel in Unity erstellt und getestet und können mit der Erstellung einer Visual-Studio-Solution fortfahren.

Klicken Sie im Menü auf File | Build Settings …, um das "Build Settings"- Fenster zu öffnen und sicherzustellen, dass Sie in der Ansicht "Scenes In Build" eine Szene ausgewählt haben. Überprüfen Sie, ob folgende Einstellungen vorliegen …

  • Plattform ist eingestellt auf Windows Store (wenn nicht, klicken Sie auf Windows Store -> Switch Platform).
  • SDK ist eingestellt auf Universal 10.
  • UWP Build Type ist eingestellt auf XAML.
  • Unity C# Projects und Development Build sind jeweils ausgewählt.

Klicken Sie als Nächstes auf die "Player Settings…"- -Schaltfläche und überprüfen Sie, ob die dortigen Informationen korrekt sind. Dieses Spiel ist für den Landscape- Modus gedacht. Überprüfen Sie, dass die ausgewählte Default Orientation hier Landscape- ist:

Klicken Sie dann auf die Erstellen Schaltfläche im Build Settings- Fenster. Sie werden aufgefordert, einen Ordner für das Projekt auszuwählen. In diesem Ordner werden Ihre Visual-Studio-Solution und Ihr Projekt erstellt.

Mit Visual Studio ein App-Paket und WACK erstellen

Wir haben unsere Visual-Studio-Solution erstellt und können jetzt zu ihr übergehen, um das Setup fortzusetzen.

Doppelklicken Sie auf die für Sie erstellte Solution.

Visual Studio 2015 öffnet sich und lädt drei Projekte. Machen Sie sich keine Sorgen, wenn Sie Fehler sehen. Visual Studio lädt Ressourcen asynchron. Warten Sie einfach ab, bis alle Ressourcen geladen sind und erstellen Sie das Projekt im Debug- Modus, indem Sie Build | Build Solution im Menü auswählen.

Als Nächstes …

  1. Bestätigen Sie, dass das Build erfolgreich war.
  2. Ändern Sie den Modus von Debug- auf Master. Dies ist wichtig, da Sie für das Einreichen Ihrer UWP-Apps im Windows Store den Master- Modus benutzen müssen. (Master- -Modus entfernt Sicherheitsüberprüfungen und deaktiviert den Profiler, um die beste Performance zu bieten.)
  3. Auswählen Store | Create App Packages ... im Projekt -Menü aus.

Wenn Sie dies zum ersten Mal tun oder seit dem letzten Mal mehrere Tage vergangen sind, werden Sie dazu aufgefordert, sich mit Ihren Windows Store-Entwickler-Anmeldedaten zu authentifizieren. Sie müssen einen Sicherheitscode eingeben, um Ihre Anmeldedaten zu bestätigen.

Wenn die Build-Erstellung abgeschlossen ist, klicken Sie auf die Schaltfläche "Launch Windows App Certification Kit". Dieser Testvorgang kann einige Zeit dauern und überprüft, ob Ihr Spiel zur Einreichung im Windows Store bereit ist.

Wenn keine Probleme festgestellt werden, wird folgendes Fenster angezeigt:

Ihr Unity-Spiel für UWP entwerfen

Unity bietet ein ausgereiftes Toolset, mit dem Sie Ihr Spiel für zahlreiche Plattformen entwerfen können, darunter auch den Tooling-Support für UWP-Apps ("Universal Windows Platform"-Apps). Das Unity-Tooling deckt neben vielen anderen folgende Bereiche ab:

  • Zahlreiche Auflösungen und Anpassungen an die Bildschirmgröße
  • Bildformate

Zahlreiche Auflösungen und Anpassungen an die Bildschirmgröße

Ihr Unity-Spiel kommt von vorneherein mit verschiedenen Auflösungen und Bildschirmgrößen zurecht. Ein Aspekt dieses Supports, der eventuell nicht intuitiv, aber für Ihr Spiel trotzdem äußerst wichtig ist, ist Ihr Menü und das HUD (Heads Up Display).

Unity bietet ein neues User-Interface-System, das Unity UI. Dieses neue UI-System sorgt dafür, dass Sie keine Plug-ins von Drittanbietern mehr benötigen und ermöglicht ausgereifte Interfaces in Ihrem Spiel. Es ist wichtig, dass Sie Ihr Menü und das HUD richtig konfigurieren und in verschiedenen Auflösungen testen. Wenn Sie sich noch an Windows Forms oder WPF erinnern, wissen Sie, dass man dort UI-Elemente verankern konnte, sodass diese ihre Größe je nach Bildschirmgröße anpassen. Unity bietet die gleiche Funktion. Zusätzlich zum Verankern von Positionen können Sie festlegen, ob Ihre UI-Elemente die Größe mit der Bildschirmgröße verändern sollen oder ob die Größe der Elemente gleich bleiben soll.

Bildformate

Neben verschiedenen Bildschirmauflösungen und Bildschirmgrößen unterstützt Unity auch verschiedene Bildformate. Es ist immer wichtig, die verschiedenen Bildformate zu testen, die in Ihrem Spiel unterstützt werden sollen, aber Unity macht es sehr einfach, dies für jedes beliebige Bildformat zu tun.

Testen Sie auf Emulatoren und Zielgeräten, auf die Sie Zugriff haben, um sicherzustellen, dass alles einsatzbereit ist.

Visual Studio 2015-Tools für Unity

Visual Studio bietet unzählige Tools, mit denen Sie Ihr Unity-Spiel zur Veröffentlichung im Windows Store vorbereiten können. Einige davon sind:

  • Unity Project Explorer
  • Skripts in Visual Studio schreiben und debuggen
  • Graphics Debugger

Visual Studio Tools for Unity

Ab Unity 5.2 müssen Sie die "Visual Studio Tools for Unity" nicht mehr gesondert importieren. Gehen Sie in Visual Studio 2015 einfach zu Tools | Extensions and Updates, um "Visual Studio 2015 Tools for Unity" zu installieren.

Der folgende Abschnitt führt Sie durch die erforderlichen Schritte, wenn Sie die neueste Version der VSTU erhalten möchten oder eine Unity-Version verwenden, die älter als 5.2 ist. Wenn Sie Visual Studio 2015 mit Unity 5.2 oder höher benutzen, sind die folgenden Schritte für Sie nicht notwendig und Sie können sie überspringen.

Visual Studio Tools for Unity ermöglicht Ihnen, Ihre Unity-Spiele in Microsoft Visual Studio zu schreiben und zu debuggen. Zusätzlich zu der Möglichkeit, Breakpoints hinzuzufügen und Variablen und komplexe Ausdrücke auszuwerten, können Sie Ihr Projekt durchsuchen, als ob Sie in Unity mit dem Unity Project Explorer arbeiten. Weiterhin sehen Sie in Visual Studio genau den gleichen Konsolen-Output, den Sie auch in Unity sehen würden.

Im Folgenden sehen Sie einen Screenshot der Installation der Visual Studio 2015 Tools for Unity. Markieren Sie das Kontrollkästchen, um die Nutzungsbedingungen zu akzeptieren:

Nach der Installation erscheint ein Dialogfenster, das den Abschluss der Installation anzeigt:

Jetzt haben wir die Installation beendet und müssen Unity öffnen, um dieses Tool unserem Projekt hinzuzufügen.

Es erscheint das folgende Unity-Dialogfenster. Lassen Sie alle Kontrollkästchen ausgewählt und klicken Sie auf die "Import". -Schaltfläche:

Sie können sehen, dass ein neuer Ordner in Ihrer Projekt-Hierarchie erstellt wurde:

Überprüfen Sie, ob Ihre Build-Einstellungen für die Nutzung von Visual Studio richtig konfiguriert sind, wie unten dargestellt. Stellen Sie sicher, dass "Unity C# Projects" und "Development Build" ausgewählt sind:

Jetzt können Sie mit Visual Studio Skripts schreiben und debuggen. Bitte beachten Sie: dieser Installationsprozess ist nur für Unity-Versionen notwendig, die älter als 5.2 sind.

Skripts in Visual Studio schreiben und debuggen

Wenn Sie auf ein Skript in Unity doppelklicken, wird Visual Studio gestartet. Wenn wir beispielsweise das Shooter.cs- Skript auswählen und in Visual Studio starten, sehen wir Folgendes:

Wenn wir jetzt den GetButtonDown- Abruf debuggen möchten, der einen Ballwurf initiiert, können wir in Zeile 12 einen Breakpoint hinzufügen und klicken dann auf die "Attach to Unity"- -Schaltfläche:

Jetzt, wieder zurück in Unity, müssen Sie nur noch auf die "Play"- Schaltfläche klicken und das Spiel startet. Da wir wissen, dass Update ausgeführt werden wird, sehen wir, dass das Spiel an Zeile 12 in Visual Studio pausiert, wenn wir mit der linken Maustaste klicken:

Die Arbeitsabläufe beim Debuggen sind mit den üblichen Abläufen für jedes Visual Studio-Projekt identisch.

Graphics Debugger

Visual Studio 2015 enthält einen leistungsstarken Graphics-Debugger, mit dem Sie Ihr Spiel optimieren können.

Stellen wir zunächst sicher, dass die Graphics Tools Ihrem System hinzugefügt sind. Gehen Sie in Windows zu Einstellungen, wählen Sie dann System, wählen Sie dann Apps & Features, wählen Sie dann Optionale Features verwalten. Wenn es installiert ist, wird Graphic Tools angezeigt:

Ist das nicht der Fall, wählen Sie Feature hinzufügen aus und klicken Sie in der Liste auf Graphic Tools. Bitte konsultieren Sie die MSDN-Dokumentation zu Graphics Diagnostic Tools, wenn bei der Installation Probleme auftreten.

Um Graphics Tools zu nutzen, müssen Sie das Visual Studio-Build von Unity benutzen und das Spiel mit Visual Studio öffnen. In Visual Studio können Sie das Tool über das Menü benutzen, indem Sie auf Debug | Graphics | Start Graphics Debugging klicken, wie unten dargestellt:

Wenn das Spiel startet, sehen Sie das folgende UI:

Klicken Sie auf das "Capture Frame"-Symbol, um den aktuellen Frame des Spiels zu erfassen. Sie können verschiedene Teile des Gameplay erfassen.

Mit einem Doppelklick auf einen Frame erhalten Sie detaillierte Angaben zu diesem Frame. Sie können im "Graphics Event List"- Fenster zu vorherigen und nachfolgenden Draw Calls gehen sowie einzelne Pixel auswählen und das "Graphics Pixel History"- Fenster aufrufen:

Bitte beachten Sie, dass die Grafikdiagnose-Datei sehr groß werden kann. Wenn Sie mehr darüber wissen möchten, finden Sie weitere Informationen unter Visual Studio-Grafikdiagnose.

Windows Store Asset-Erzeugung

Damit Ihre App im Windows Store eingereicht werden kann, müssen Ihre Bilder die richtige Größe haben. Es gibt eine Visual Studio-Erweiterung, die für genau diesen Zweck sehr praktisch ist: den UWP Tile Generator. Sie können ein Bild auswählen und er erstellt alle Größen, die Sie benötigen, in einer .zip-Datei.

Die Unterschiede zwischen Unity- und UWP-Apps

Unity verwendet ein Framework namens "Scripting Backend", um das Skripting zu unterstützen. Aktuell werden drei Backends unterstützt: Mono, .NET und IL2CPP. Wenn Ihre App für den Windows Store gedacht ist, stehen nur .NET und IL2CPP zur Verfügung. Sie können das Scripting Backend auswählen, indem Sie in Unity im "Build Settings"-Fenster auf die Schaltfläche "Player Settings" klicken.

Im Unity-IDE referenzieren Skripts, die .NET benutzen, auf .NET Version 3.5. Wenn Sie Ihr Spiel jedoch zu Visual Studio exportieren, wird Ihr gesamter C#-Code gegen .NET Core kompiliert, was eine Untergruppe von .NET Version 4.5 ist ( Hinweis: Wenn Sie IL2CPP als Skripting-Backend verwenden, verwendet Ihre Windows Store-App hingegen weiterhin .NET 3.5). Schreiben Sie, um diesen Umstand deutlicher zu machen, die folgende Code-Zeile in ein Unity-Skript:

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

Wenn SieF12 auf der SortedList in Visual Studio anwenden, um die Typ-Definition zu sehen, werden Sie erkennen, dass sich diese Klasse in der Bibliothek "mscorlib" befindet.

Wenn Sie den gleichen Code in Ihr exportiertes Projekt einfügen und F12 auf dem SortedList -Typ anwenden, sehen Sie, dass diese Version der Klasse in einem NuGet-Paket enthalten ist, das zum .NET Core gehört.

Früher konnte dies zu Problemen führen, wenn in .NET 3.5 Typen oder Methoden vorhanden waren, die .NET Core nicht aufwies. Das machte wiederum Bibliotheken wie WinRTLegacy erforderlich, die Lücken schließen und nicht nur Typen, sondern auch Erweiterungsmethoden zur Verfügung stellen sollten.

Tipp: Seien Sie vorsichtig, wenn Sie Anleitungen zu fehlenden Typen zwischen Unity und .NET Core lesen. Viele dieser Anleitungen sind veraltet und demnach eventuell nicht zutreffend.

Es ist nach wie vor wichtig, diesen wesentlichen Unterschied zwischen Unity und UWP zu verstehen, wobei die Probleme mit fehlenden Typen und Methoden bei der Portierung von .NET 3.5 zu .NET Core immer geringer werden, je größer .NET Core wird. So ist beispielsweise System.Threading.Tasks, das nach .NET 3.5 eingeführt wurde, ein Teil von .NET Core. Auch auf umgekehrtem Weg, wenn Sie also Funktionen von .NET Core implementieren möchten, die in .NET 3.5 nicht vorhanden sind, können Probleme entstehen.

Es ist weiterhin beachtenswert, dass, wenn Sie IL2CPP als Skripting-Backend verwenden, die API-Oberfläche zwischen dem Unity-Editor und Ihrer Windows Store-App identisch wird.

Plattformspezifische Funktionen

Da es sich bei Unity und der Universal Windows Platform (UWP) um verschiedene Plattformen handelt, ergeben sich bei der Portierung sowohl Vorteile aus auch Herausforderungen.

Performance-Optimierung

UWP-Apps nutzen .NET Native, das optimierten, nativen Maschinencode erzeugt. Dies führt für Ihr Spiel zu schnelleren Startzeiten und zu geringerem Akkuverbrauch. Wie stark sich diese Optimierungen auswirken, hängt von der Komplexität Ihres Spiels ab, aber Unity-Spiele, die das .NET-Skripting Backend verwenden, profitieren in der Regel deutlich davon. In einem erzeugten Spielprojekt kompiliert nur eine "Master"-Buildkonfiguration zu .NET Native.

Anweisungen

Wenn Sie ein UWP-Toast oder ein Tile von Ihrem Spiel aufrufen wollten, wie würden Sie das machen? Diese Funktionen sind nicht Teil von .NET 3.5, dem Skripting-Backend, das Sie bei der Entwicklung mit Unity benutzt haben. In diesem Fall scheint es, dass Ihr Code funktionieren würde, wenn Sie ihn zu Visual Studio exportieren, aber keinesfalls im Unity-IDE.

Um diese Art von Problemen zu umgehen, bietet Unity eine Bibliothek, UnityEngine.WSA, die Platzhalter-Klassen wie Application, Cursor, Launcher, Tile und Toast enthält. Sie können in Ihren Unity C#-Skripts gegen diese Typen programmieren, um ein Interop zwischen Unity und UWP zu ermöglichen.

Eine zweite Methode, in .NET 3.5 fehlende Funktionen auszugleichen, ist die Nutzung der NETFX_CORE -Anweisung in Ihren Skripts. Diese Anweisung wird benutzt, um Code-Blöcke zu ignorieren, von denen Sie wissen, dass Sie nicht in .NET 3.5 kompilieren - die Sie aber in Ihrem Spiel benötigen, um es gegen .NET Core zu kompilieren. Das folgende Beispiel, zu finden im Unity bitbucket- Repository, zeigt, wie Code, der im Unity-IDE als Fehler gelten würde, mithilfe von Anweisungen ignoriert werden kann.

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

Wenn Sie konkreter werden möchten, können Sie die Unity_WSA_10_0 -Anweisung verwenden, anstelle von NETFX_CORE. Während letztere eine Anweisung für jede Windows Store-App ist, wird Unity_WSA_10_0 speziell für Windows 10-Geräte benutzt.

Plug-ins schreiben

Die Unterschiede zwischen .NET 3.5 und .NET Core können auch Plug-ins betreffen. Manchmal ist der Code kompatibel und es treten keinen Schwierigkeiten auf. Ist er es nicht, können Sie mit Unity Ihre App so konfigurieren, dass zwei verschiedene Versionen des gleichen Plug-ins verwendet werden, eine für das Unity-IDE (das auf .NET 3.5-API basiert) und die andere für das vollständige Spiel (das gegen .NET Core kompiliert ist).

Um mehrere Plug-ins zu implementieren, müssen Sie bestimmten Regeln folgen. Ihre Plug-ins müssen den gleichen Namen und die gleiche Assembly-Versionsnummer tragen. Die beiden Plug-ins müssen in verschiedenen Ordnern gespeichert sein. Ihr Editor-kompatibles Plug-in sollte sich beispielsweise im Ordner ...\Assets\Plugins\MyPlugin.dll und das UWP-spezifische Plug-in im Ordner ... \Assets\Plugins\WSA\MyPlugin.winmd befinden.

Weiterhin müssen Sie die Version Ihres Plug-ins konfigurieren, das Sie für den Editor als Platzhalter für Ihr .NET Core-Plug-in geschrieben haben – damit Unity weiß, welche Bibliothek der Platzhalter und welche die Live-Version ist, die für den Windows Store bereitgestellt wird.

Wählen Sie in Ihrem Unity Project Explorer Assets\Plugins\MyPlugin.dll aus und markieren Sie "Editor" als Plattform.

Gehen Sie dann zu Assets\Plugins\WSA\MyPlugin.winmd und wählen Sie Windows Store Apps als die richtige Plattform für das Plug-in aus.

Um diesen Vorgang besser zu verdeutlichen, erstellen wir im Folgenden einen Satz von Plug-ins.

Öffnen Sie Visual Studio 2015 und erstellen Sie ein neues Projekt mit dem Namen "MyPlugin". Nutzen Sie die Projektvorlage für Visual C# | Windows | Universal | Windows Runtime Component. (Sie könnten auch eine "Class Library"- Projektvorlage nutzen, aber "Windows Runtime Component" enthält einige interessante Funktionen und kann z. B. von jeder Windows Runtime Language Projection verarbeitet werden, was Ihnen zusätzliche Vorteile bringt.)

Klicken Sie mit der rechten Maustaste auf Ihre Solution und wählen Sie Add -> New Project aus. Dies wird die Platzhalter-Version der Bibliothek, die ausschließlich im Unity-Editor verwendet wird. Da diese gegen .NET 3.5 kompiliert, muss sie mit der "Visual C# | Windows | Classic Desktop | Class Library"- Projektvorlage erstellt werden. Nennen Sie dieses Projekt "MyPluginStub", da Sie innerhalb einer Solution nicht den gleichen Namen für zwei Projekte verwenden können.

Da aber die beiden Bibliotheken den gleichen Namen haben müssen, müssen Sie die Output-Datei für "MyPluginStub" konfigurieren, sodass sie "MyPlugin" heißt, wie Ihr anderes Projekt. Klicken Sie dazu im Solution Explorer mit der rechten Maustaste auf das "MyPluginStub"-Projekt und wählen Sie "Properties" aus. Geben Sie im Application-Reiter sowohl für das Feld "Assembly Name" als auch für das "Default Namespace"-Feld "MyPlugin" ein, damit diese dem anderen Projekt entsprechen. Ändern Sie außerdem das Feld "Target Framework" zu ".NET Framework 3.5".

Löschen Sie die Class1.cs-Dateien, die Visual Studio für jedes Ihrer Projekte erstellt hat. Erstellen Sie dann im "MyPlugin Windows Runtime Component"-Projekt eine neue Klasse mit dem Namen "Foo.cs". Statt eine gleiche Klasse für das Windows-Desktop-Projekt zu erstellen, werden wir Foo.cs freigeben, indem wir sie als verlinkte Datei hinzufügen.

Jetzt können Sie die gleiche physische Datei, Foo.cs, sowohl vom MyPlugin-Projekt als auch vom MyPluginStub-Projekt aus bearbeiten. Sehen Sie sich die Datei im Code-Editor beider Projekte an. Sie werden feststellen, dass Visual Studio im Projekt MyPluginStub rote "Schnörkel" um Ihre Using-Aussage System.Threading.Tasks gesetzt hat. Das liegt daran, dass dieser Typ in .NET Core existiert, aber nicht in .NET Framework 3.5.

Wir könnten die Zeile einfach löschen, um diesen Fehler zu beheben, da wir nicht vorhaben, sie zu benutzen. Stattdessen werden wir aber eine Anweisung testen um zu zeigen, wie das funktioniert. Ersetzen Sie die Using-Aussage für Tasks durch die folgenden drei Codezeilen.

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

Nach dem Hinzufügen sollten die Projekte erneut kompilieren. Jetzt brauchen wir noch eine Methode für die Foo-Klasse, die wir naturgemäß "Bar" nennen. "Bar" gibt eine Meldung aus, wenn es vom Unity Editor aufgerufen wird, und eine andere, wenn es in der Windows Runtime Component aufgerufen wird. Fügen Sie die folgende Implementierung der Bar-Methode Ihrer Foo-Klasse hinzu (fügen Sie dabei der Klassenangabe auch das "Sealed"-Schlüsselwort hinzu, da das für Runtime Components erforderlich ist).

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

Erstellen Sie die beiden Bibliotheken.

Als Nächstes konfigurieren Sie Ihr Unity-Projekt zur Benutzung dieser Bibliotheken. Öffen Sie dazu Ihr Projekt in Unity und erstellen Sie unter "Assets" einen neuen Ordner namens "Plugins". Erstellen Sie neben Plugins ein weiteres Verzeichnis namens WSA (kurz für Windows Store Application). Gehen Sie jetzt zur MyPlugins.dll-Datei Ihres MyPluginsStub-Projekts und ziehen Sie sie in ... \Assets\Plugins. Ziehen Sie dann die kompilierte MyPlugins.winmd-Datei in ...\Assets\Plugins\WSA.

Klicken Sie im Assets-Fenster auf Plugins\MyPlugin. Dadurch werden die MyPlugin-Importeinstellungen im Inspector-Fenster angezeigt. Entfernen Sie die Markierung bei "Any Platform" und wählen Sie stattdessen "Editor" aus. So weiß das IDE, dass dies die Version der Bibliothek ist, die benutzt werden soll, wenn Sie im Unity Editor sind.

Wählen Sie jetzt eine Stufe darunter Plugins\WSA\MyPlugin aus. Der Inspector sollte bereits den WSAPlayer und keine andere Plattform ausgewählt haben. So weiß Unity, dass dies die Version der Bibliothek ist, die im Windows Store veröffentlicht werden soll. Gehen Sie nach unten zum Feld "Placeholder" und wählen Sie Ihre Platzhalter-Bibliothek im Plugins-Ordner aus. Damit erklären Sie den Zusammenhang zwischen den beiden Bibliotheken. Plugins\MyPlugin.dll ist der Platzhalter für Ihre tatsächliche Bibliothek, Plugins\WSA\MyPlugin.winmd.

Jetzt sollten wir die beiden Bibliotheken testen, um sicherzustellen, dass sie in Unity richtig konfiguriert sind. Erstellen Sie in Unity ein neues C#-Skript namens "TestFooBar". Erstellen Sie eine private Instanz der Foo-Klasse und schreiben Sie den Return-Wert von Bar im Logger aus.

        
          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 () {

              }
            }
        
      

Ziehen Sie jetzt dieses Skript in eins Ihrer Game-Objekte wie z. B. "Player", um es anzufügen. So stellen Sie sicher, dass die Start-Methode des Skripts aufgerufen wird. Lassen Sie das Spiel in Unity ablaufen und es wird, sofern alles planmäßig funktioniert, die richtige Nachricht im Console-Fenster angezeigt.

Gehen Sie als letzten Schritt zu "Build Settings"- und klicken Sie auf die "Build"-Schaltfläche, um Ihr Projekt zu Visual Studio zu exportieren.

Lassen Sie Ihr Spiel dieses Mal in Visual Studio laufen. Sie sollten die folgende Nachricht in Ihrem Visual-Studio-Output-Fenster sehen:

Dieses Plug-in-Beispiel ist die Grundlage für fast alle Interaktionen zwischen der Universal Windows Platform (UWP) und Unity. Wenn bei Ihnen die richtigen Nachrichten in den Console-Fenstern erscheinen, wissen Sie den größten Teil dessen, was Sie wissen müssen, um UWP-Code einzubinden und von Ihrem Unity-Spiel aus darauf zuzugreifen.

Werbung

Sie können Microsoft Ads als ein Unity-Plug-in verwenden, indem Sie Unity Plugins for Windows Store and Azure Services herunterladen und installieren. Das Plug-in enthält außerdem API für In-App-Käufe, Lizenzprüfungen und Empfangsbestätigungen.

Am einfachsten können Sie die Unity-Plug-ins für Windows Store benutzen, indem Sie das Unity-Paket von GitHub herunterladen und es im Unity-Editor über Assets | Import Package | Custom Packages in Ihre App importieren. Nach dem Import des Pakets befinden sich die entsprechenden Binärdateien im "Unity Plugins"-Ordner und im "Unity Plugins\WSA"-Ordner.

Alternativ können Sie auch die neueste Microsoft Store Engagement and Monetization SDK -Erweiterung Ihrer exportierten UWP-App verwenden, um Bannerwerbung und Video-Ads anzuzeigen. Das "Microsoft Store Engagement and Monetization SDK" integriert die Werbefunktionen des Microsoft Universal Ad Client SDK mit anderen Funktionen für verschiedenen Store-Dienste in einen einzelnen, einheitlichen Installer.

Analytics

Sie können Analysedaten über Ihre Spieler entweder über die Unity-Plattform oder über die Universal Windows Platform (UWP) sammeln. Sie können auch beide Plattformen verwenden, um ergänzende Daten zu sammeln. Wenn Sie Unity verwenden möchten, müssen Sie Ihr Projekt mit einer Unity-Services-ID verbinden und dann Analytics für Ihr Projekt aktivieren. Weitere Informationen dazu finden Sie im Unity-Benutzerhandbuch.

Sobald Sie Ihr Spiel bereitgestellt haben, werden in Ihrem Windows Dev Center Dashboard automatisch Daten für Sie gesammelt. Das Dashboard versorgt Sie mit aktuellen Berichten über:

  • Anschaffungen
  • Gesundheit
  • Bewertungen
  • Rezensionen
  • Feedback
  • Benutzung
  • In-App-Käufe
  • Ad Mediation
  • Werbe-Performance
  • App-Install-Werbung
  • Kanäle und Umstellungen

Sofern die Funktion aktiviert ist, können Sie sogar die Benutzungstelemetrie für Ihr Spiel einsehen.

Schließlich können Sie auch REST API nutzen, um diese Analysedaten anzuzeigen, wie es für Sie am sinnvollsten ist, ohne den Weg über das Windows Dev Center gehen zu müssen.

In-App-Käufe (In-App Purchases/IAP)

Da sich Unity-Spiele, die zur Universal Windows Platform (UWP) exportiert wurden, auf zwei Plattformen stützen (Unity und UWP), haben Sie zwei Möglichkeiten, In-App-Käufe zu aktivieren: Sie können Unity IAP benutzen oder die Unity Plugins for Windows Store and Azure Services herunterladen und installieren.

Um Unity IAP zu benutzen, müssen Sie im Services-Fenster in Unity eine "Unity Services Project ID" anlegen. Sie werden durch einige Dialogfenster geführt, um Ihre In-App-Käufe für Windows Store zu aktivieren. Weitere Informationen dazu finden Sie auf der Unity-Website. Bitte beachten Sie, dass Unity IAP nicht mit dem IL2CPP-Skripting-Backend funktioniert.

Mit den Unity-Plug-ins für Windows Store nutzen Sie das Store-API, um Ihre Listings aus einer Unity-Skriptdatei abzurufen. Sie müssen zunächst für Ihre App über das Windows Store Dev Center In-App-Produkte erstellen. Dann können Sie Ihre App aktualisieren, um Käufe Ihrer IAP aufzulisten und zu ermöglichen. Der ausschlaggebende Abruf über das Plug-in erfordert, dass Sie die LoadListingInformation Methode aufrufen, um Ihre In-App-Produkte abzufragen, wie im Beispiel-Code unten gezeigt.

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

Die vollständige Beispiel-Implementierung, die die Benutzung des Store API erläutert, finden Sie auf GitHub.

Optimale Vorgehensweisen

Wenn das Herzstück Ihres Spiels fertiggestellt ist, möchten Sie ihm noch den nötigen Feinschliff geben, um Ihre App für die Windows 10-Gerätefamilie bereit zu machen. In diesem Abschnitt erläutern wir einige Vorgehensweisen, die die Bereitstellung im Windows Store erleichtern.

Startbildschirm und Ladevorgang

Wenn Ihr Spiel startet, ist es wichtig, den Fortschritt des Ladevorgangs anzuzeigen. So wissen die Benutzer, dass das Spiel nicht "eingefroren" oder abgestürzt ist.

In dieser Abhandlung gehen wir davon aus, dass Sie ein XAML-Projekt benutzen. Ist dies nicht der Fall, treffen die meisten hier dargestellten Vorgehensweisen zwar auf ein DirectX-Projekt zu, doch die Implementierungen unterscheiden sich.

Beim Laden eines Spiels zum Windows Store mit Unity gibt es zwei wichtige Bereiche:

  1. App Splash Screen (App-Startbildschirm)
  2. Extended Splash Experience (Erweiterter Startbildschirm)

Das anfängliche Bild des Startbildschirms wird vom Betriebssystem angezeigt und Sie können es konfigurieren, indem Sie Ihr Applications-Manifest wie folgt aktualisieren:

Windows zeigt den anfänglichen App-Startbildschirm nur so lange an, wie das Betriebssystem zum Laden der Seite (geschrieben in XAML-Markup), die Ihre Unity-Szenen hostet, braucht.

Normalerweise benötigt die Unity-Szene eine längere Ladezeit. Um einen erweiterten Startbildschirm zu erstellen, nutzen Sie XAML, um das gleiche Splash-Screen-Bild mit einer Fortschrittsanzeige für den Benutzer anzuzeigen, während Ihre Unity-Szene lädt. In MainPage.xaml fügen Sie dazu neben dem Splash-Screen-Bild eine Fortschrittsanzeige hinzu.

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

Nutzen Sie den Constructor in MainPage.xaml.cs – die Code-Behind-Datei für das XAML UI – um einen Timer zu starten, der die Fortschrittsanzeige ablaufen lässt und dem Benutzer ein visuelles Feedback bietet.

Gerät-Formfaktor

Eine Codebasis für viele Formfaktoren ist eine Schlüsselfunktion der Universal Windows Platform (UWP), doch viele Spiele erfordern dennoch einige Optimierungen für bestimmte Formfaktoren. Meistens beinhaltet dies Eingabemechanismen (z. B. Touch, Tastatur, Maus, Gamepad), Änderungen der Fenstergröße, Optimierungen von Ressourcen und Assets und die Implementierung nativer Plattformintegration für jeden spezifischen Formfaktor.

Ausrichtungs-Support

Aufgrund des vorherrschenden Breitbildformats auf neuen Geräten exportiert der Unity-Editor Projekte mit der Standardeinstellung "Landscape" . Wenn Ihr Projekt die "Portrait"-Ausrichtung unterstützt, müssen Sie das App-Manifest in Visual Studio ändern. Dies können Sie nicht im Unity-Editor tun.

Um das Manifest zu ändern, doppelklicken Sie auf die Package.appxmanifest -Datei, die Sie unten in Ihrem" Windows Store Visual Studio"-Projekt finden. Markieren Sie im Manifest-Editor die Ausrichtungen/Formate, die Sie unterstützen möchten.

Die Ausrichtungs-API (Input.deviceOrientation und Screen.orientation) funktionieren in Unity gut. Sie können sie nutzen, um die Ausrichtung des Geräts abzufragen und sogar, um die Ausrichtung für bestimmte Szenen festzulegen.

Windowing-Support

Universal Windows Platform-Apps (UWP-Apps) werden in größenveränderbaren Fenstern statt im Vollbild-Modus wie bei Windows 8 und 8.1 gehostet. Damit wird "Windowing", die Veränderung der Fenstergröße, auch für Ihre Spiele und Apps zum Thema.

Für Sie als Unity-Entwickler sind die meisten Unterschiede schnell durchschaubar, da die Screen.height- und Screen.width- Eigenschaften nach wir vor den verfügbaren Platz in nativen (Pixel-) Größen angeben.

Ändert der Benutzer die Größe des Fensters, wird empfohlen, das Spiel anzuhalten, damit sich der Benutzer entscheiden kann, was er als Nächstes tun möchte. Da Fenster auch im Desktop-Modus den Fokus verlieren können, wenn mehrere Fenster gleichzeitig geöffnet sind, sollten Sie ebenso Fokus-Veränderungen einbeziehen und das Spiel anhalten, wenn Ihr Spiel-Fenster nicht länger im Fokus steht.

Das Spiel anhalten und fortsetzen

In Windows sorgt die Unity-Game Engine automatisch dafür, dass Ihr Spiel angehalten und fortgesetzt wird, wenn es vorübergehend nicht mehr im Fokus steht. In Szenarien, in denen Sie Ihr Spiel außerhalb dieses automatischen Pausierens anhalten möchten, zum Beispiel während der Navigation zwischen XAML-Seiten, können Sie die UnityPause -Methode aufrufen.

Wenn Sie zusätzlich etwas tun möchten, wenn die Anwendung pausiert, nutzen Sie stattdessen OnApplicationPause -Callback in Ihren Skripts.

Gamepad- und Maus-Eingabe

Die Windows-Gerätefamilie unterstützt eine Reihe von Eingabemethoden, von Tastatur und Maus über Touch bis zu Gamepads. Glücklicherweise werden alle diese Eingabemethoden nicht nur von Unity unterstützt, sondern auch über Unitys Input Manager abstrahiert.

Im Shooter-Verhalten unseres Basketballspiels warten wir auf das Auslösen der "Fire1"-Eingabeachse, bevor das Spiel einen Ball wirft.

        
          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" ist standardmäßig sowohl der linken Maustaste als auch einer Gamepad-/Joystick-Taste zugeordnet, wie unten im Input Manager dargestellt. Um den Input Manager im Unity-IDE anzuzeigen, wählen Sie Edit -> Project Settings -> Input aus.

Auf einem Xbox One-Controller entspricht "joystick button 0", dem "Fire1" zugewiesen ist, der A-Taste. Andere Eingaben sind bereits der FPS-Controller-Komponente für Bewegungen und Sprünge zugeordnet. Mausbewegungen, die "Links"-, "Rechts"-, "Oben"- und "Unten"-Tasten der Tastatur sowie die a-, d-, s- und w-Tasten und der linke Joystick des Xbox One-Controllers dienen alle standardmäßig der Bewegung des Spielers. Die rechte Maustaste, die Leertaste und die Xbox-B-Taste lassen den Spieler jeweils springen.

Sie können die Eingaben auch weiter anpassen, indem Sie die Zuordnungen der Input-Achsen ändern oder sogar weitere Achsen hinzufügen, um Ihr Spiel zu unterstützen. Weitere Informationen über virtuelle Achsen finden Sie im Unity-Benutzerhandbuch.

Fazit

Dieses Dokument hat gezeigt, wie Sie Ihr Spiel in Visual Studio konfigurieren und von Unity zu einem Universal Windows Platform-Projekt (UWP-Projekt) exportieren. Weiterhin wurde dargestellt, wie Sie Ihr UWP-Spiel im Windows Store einreichen. Wir haben einige feine Unterschiede zwischen der Unity-Plattform und der Universal Windows Platform erläutert und außerdem plattformspezifische Codes und Features behandelt, die Ihnen als Spiele-Entwickler geläufig sein sollten. Im Abschluss wurden in diesem Dokument die besten Vorgehensweisen genannt, mit denen Sie Ihrem Spiel den Feinschliff für die Veröffentlichung geben können.

Literaturhinweise

Nach oben
Alles klar

Wir verwenden Cookies, damit wir Ihnen die beste Erfahrung auf unserer Website bieten können. Klicken Sie hier für weitere Informationen.