Laden Sie die Unity 3D-App für Android herunter. Verwenden von Unity zum Entwickeln von Anwendungen. So erstellen Sie Spiele in Unity
Die Entwicklung von Spielen für Android-Geräte erfordert einen ähnlichen Ansatz wie die Entwicklung für iOS. Andererseits unterliegt die Hardware von Android-Geräten keinen klaren Standards, was es notwendig macht, Probleme zu lösen, die bei der Arbeit mit iOS fehlen. Es gibt auch Unterschiede zwischen den Android- und iOS-Versionen von Unity.
Vorbereiten der Android-Entwicklungsumgebung
Bevor Sie Ihre Spiele auf dem Gerät testen können, müssen Sie Ihre Entwicklungsumgebung vorbereiten. Laden Sie insbesondere das Android SDK der gewünschten Plattform herunter und installieren Sie es und fügen Sie Ihr Gerät zum System hinzu (dieser Vorgang ist für Windows und Mac unterschiedlich). Dies ist im Detail auf der Website der Android-Entwickler beschrieben, und zusätzliche Informationen können vom Hersteller Ihres Geräts bereitgestellt werden. Da dies ein ziemlich komplizierter Prozess ist, haben wir eine kleine Anleitung vorbereitet, die Ihnen hilft, alles vorzubereiten, was Sie für die Entwicklung benötigen. Wenn Sie weitere Informationen benötigen, erhalten Sie diese im Android Developer Portal.
Zugriff auf Android-Funktionen
Unity bietet eine API für den Zugriff auf Eingaben und Einstellungen von Android. Die verfügbaren Klassen sind auf der Seite Code für Android-Assemblys dokumentiert.
Verknüpfen von C-, C++- oder Java-Code mit Skripten
Mit Unity können Sie in C/C++ geschriebene Funktionen direkt aus Skripten aufrufen (Java-Funktionen können indirekt aufgerufen werden). Um zu erfahren, wie Sie auf Funktionen aus nativem Code von Unity zugreifen können, besuchen Sie die Seite zum Erstellen von Android-Plugins.
Occlusion Culling (Ausschneiden unsichtbarer Geometrie)
Unity bietet Unterstützung für Occlusion Culling, was bei der Optimierung für mobile Plattformen sehr nützlich ist. Weitere Informationen finden Sie auf der Seite Occlusion Culling.
Anpassen des Startbildschirms
Der Begrüßungsbildschirm, der beim Start des Spiels angezeigt wird, kann angepasst werden – siehe diese Seite für weitere Informationen.
Fehlerbehebung und Fehlerberichterstattung
Es gibt viele Gründe, warum Ihre App abstürzt oder nicht richtig funktioniert. Unser Leitfaden zur Lösung von Android-spezifischen Problemen hilft Ihnen, die Fehlerursachen in kürzester Zeit zu beheben. Wenn Sie nach dem Lesen des Handbuchs annehmen, dass das Problem in Unity liegt, sollten Sie einen Fehlerbericht einreichen. Auf dieser Seite finden Sie Anweisungen.
Wie sich Unity für Android von der Desktop-Version unterscheidet
JavaScript mit starker Typisierung
Um die Leistung in der Android-Version von Unity zu verbessern, ist die dynamische Eingabe in JavaScript immer deaktiviert (als ob #pragma strict automatisch auf jedes Skript angewendet würde). Dies ist wichtig, wenn Sie ein Projekt von älteren Plattformen auf Android portieren, und wenn Sie auf Kompilierungsfehler stoßen, sollte das Problem zuerst beim Tippen gesucht werden. Solche Fehler können normalerweise leicht behoben werden, indem sichergestellt wird, dass die Typen aller Variablen während der Initialisierung explizit angegeben oder umgewandelt werden.
Während Unity Android DXT/PVRTC/ATC-Texturen unterstützt, dekomprimiert Unity Texturen zur Laufzeit in das RGB(A)-Format, wenn diese Komprimierungsmethoden auf dem jeweiligen Gerät nicht unterstützt werden. Dies kann die GPU-Rendering-Leistung ernsthaft beeinträchtigen, daher wird empfohlen, das ETC-Format zu verwenden. Es ist der De-facto-Standard für Android und sollte von allen modernen Geräten unterstützt werden. Andererseits unterstützt ETC keinen Alphakanal, und manchmal sind 16-Bit-RGBA-Texturen die beste Wahl in Bezug auf Qualität, Größe und Rendergeschwindigkeit, wenn ein Alphakanal benötigt wird.
Beitragsaufrufe: 19 374
Wir haben darüber gesprochen, wie Sie mit der Unreal Engine Ihr eigenes Spiel auf Android erstellen können. In diesem Artikel werden wir uns eine andere ebenso beliebte Spieleentwicklungs-Engine ansehen - Einheit.
Unity ist eine sehr bekannte Engine unter Indie-Entwicklern. Tatsächlich handelt es sich um eine plattformübergreifende Engine, mit der Sie sich entwickeln können 3D- und 2D-Spiele. Das Merkmal, das Unity von anderen Engines unterscheidet, ist die niedrige Einstiegsschwelle für Anfänger, während ein reichhaltiges Toolkit für Profis vorhanden ist. Plattformübergreifend können Sie Anwendungen für jede Plattform entwickeln, von Desktop-Spielen bis hin zu mobilen.
Unabhängig davon ist das Abonnementsystem zu erwähnen, da Unity kein vollständig kostenloses Produkt ist. Es gibt verschiedene Arten von Abonnements:
- persönlich. Kostenlose Version, die alle Hauptfunktionen der Engine enthält. Es gilt folgende Einschränkung: Das Jahreseinkommen bzw. die Höhe der eingeworbenen Mittel darf nicht überschritten werden 100000$ .
- Plus. Pro $35 pro Monat Es werden verschiedene Berichte und Analysen bereitgestellt sowie die Möglichkeit, den Begrüßungsbildschirm zu ändern. 20% -ten Rabatt auf Einkäufe in Asset Store und verschiedene kleinere Vorteile. Es gilt folgende Einschränkung: Das Jahreseinkommen bzw. die Höhe der eingeworbenen Mittel darf nicht überschritten werden 200000$ .
- Profi. Pro $125 pro Monat enthält alle Vorteile der Version Plus und zusätzlich professionellen Service und Premium-Support. Keine Umsatz- oder Geldbetragsbeschränkungen.
- Separate Versionen für Unternehmen (von großen Unternehmen verwendet).
Somit dürften Indie-Entwickler mit kleinem Budget mit der Version zufrieden sein persönlich oder Plus andernfalls müssen Sie sich anmelden Profi. In diesem Artikel werden wir verwenden Freie Version für den ersten Lauf.
Schritt 1Installieren Sie Unity
Um mit der Installation von Unity zu beginnen, müssen Sie zur Unity Store-Website gehen, wo Sie aufgefordert werden, die Art des Abonnements auszuwählen. Wie oben erwähnt, wählen wir persönlich.
Sie werden dann aufgefordert, die Nutzungsbedingungen zu akzeptieren und das Installationsprogramm herunterzuladen. Sie können auch auschecken System Anforderungen mit Unity zu arbeiten.
Nach dem Start des Installationsprogramms werden Sie aufgefordert, die zu installierenden Komponenten auszuwählen. Da wir eine Android-Anwendung erstellen müssen, aktivieren wir das Kontrollkästchen für Android-Build-Unterstützung. Auf Wunsch können Sie auch statt mit Unity installieren Visual Studio-Community 2017 zum Programmieren an C#.
Danach müssen Sie nur noch den Installationspfad auswählen und mit der Installation von Unity beginnen.
Schritt 2: Unity registrieren und einrichten
Nach Abschluss der Installation und dem Ausführen von Unity werden wir aufgefordert, uns mit unserem Konto anzumelden.
Dann werden Sie erneut aufgefordert, ein Abonnement auszuwählen, wir konzentrieren uns auch auf Personal. In diesem Fall müssen Sie bestätigen, dass das Jahreseinkommen des Unternehmens weniger als 100.000 US-Dollar beträgt oder dass Unity zu Schulungszwecken verwendet wird.
Am Ende wird vorgeschlagen, an einer kleinen Umfrage teilzunehmen, in der Sie beantworten müssen, was Sie tun und zu welchem Zweck Sie Unity installieren.
Schritt 3. Erstellen Sie ein neues Projekt
Nachdem wir Unity konfiguriert haben, gelangen wir zum Bildschirm zum Auswählen / Erstellen eines Projekts. Klick hier Neu um Ihre zu erstellen neues Projekt.
Danach werden Sie im angezeigten Fenster aufgefordert, den Namen des Projekts und das Verzeichnis einzugeben, in dem es sich befinden wird. Vergessen Sie auch nicht, das Kontrollkästchen zu aktivieren 3D um den Editor im 3D-Modus zu verwenden.
Wenn Sie damit fertig sind, klicken Sie auf Projekt erstellen um ein Projekt zu erstellen. Danach öffnet sich ein Editorfenster mit einer vorgenerierten Szene.
Wir werden uns jetzt noch nicht mit den Feinheiten der Programmierung befassen und zum Beispiel nehmen fertiges Spiel. Dafür gibt es Asset Store, das eine große Anzahl vorgefertigter Modelle, Animationen, Sounds (und sogar Spiele) enthält, sowohl kostenpflichtig als auch kostenlos.
Um den Asset Store zu öffnen, müssen Sie in das Menü Fenster wählen Asset Store(Tastenkombination Strg-9).
Das Schaufenster öffnet sich. Geben Sie in die Suchleiste " Beispielspiel im Flappy-Vogel-Stil" und öffnen Sie ein kostenloses Beispiel, das wir in unserem Projekt verwenden werden.
Klicken Download Nachdem Sie es heruntergeladen haben, können Sie es dann in Ihr Projekt importieren. Klicken Sie dazu auf Importieren, danach erscheint eine Warnung, dass die Projekteinstellungen nach dem Import geändert werden.
Nachdem Sie dem Import zugestimmt haben, sehen Sie ein Fenster, in dem Sie auswählen müssen, welche Komponenten importiert werden sollen. Alles auswählen und anklicken Importieren.
Sobald der Import abgeschlossen ist, sehen Sie die neuen Dateien im Projektbrowser. Das sind die Spieldateien. Erweitern Sie die Szene, um sie im Editor zu öffnen Flappy Bird-Stil - Szenen und doppelklicken Sie auf Hauptsächlich.
Als Ergebnis erscheint die Spielszene im 3D-Editorfenster.
Sie können überprüfen, wie das Spiel direkt in Unity funktioniert, indem Sie auf die Schaltfläche klicken abspielenüber dem Editorfenster.
Schritt 4: Konfigurieren Sie die Android-Tools
Notiz: wenn Sie verwenden Android-Studio, dann hast du schon alles installiert notwendigen Komponenten und so können Sie sicher zum nächsten Schritt übergehen.
Um das resultierende Spiel auf Android zusammenzustellen, müssen Sie die folgenden Tools installieren:
- Java-Entwicklungskit (JDK). Sie können es von der Java-Website herunterladen. Wenn Sie auf den Link klicken, sehen Sie ganz oben Java-Plattform (JDK), klicke auf Download neben der Inschrift, wählen Sie dann Ihr Betriebssystem aus und starten Sie den Download. Danach folgen Sie einfach den Anweisungen des Installers.
- Android SDK. bei den meisten auf einfache Weise Um die neueste Version zu installieren, müssen Sie das Android Studio herunterladen, mit dem dieses SDK geliefert wird. Gehen Sie dazu auf die Website von Android Studio und klicken Sie auf Laden Sie Android Studio herunter. Das Android Studio-Installationsprogramm installiert die Kernkomponenten des Android SDK, die für die Android-Entwicklung erforderlich sind.
Schritt 5. Bereiten Sie das Projekt für den Start vor
Zunächst müssen Sie die Entwicklungsplattform auf Android umstellen. Öffnen Sie dazu in Unity das Menü Datei und wählen Sie Build-Einstellungen aus.
Wählen Sie im angezeigten Fenster aus Android und dann drücken Plattform wechseln.
Der Plattformwechsel teilt uns mit, dass wir eine Android-App erstellen werden. Das bedeutet, dass Unity beim Erstellen der Anwendung erstellt APK-Datei. Der Plattformwechsel zwingt Unity auch dazu, alle Assets im Projekt neu zu importieren. Dies dauert bei einem kleinen Projekt nicht lange, aber denken Sie daran, dass dieser Vorgang bei großen Projekten lange dauern kann.
Jetzt müssen wir einen Paketnamen für die Anwendung angeben.
Notiz: Der Paketname ist ein eindeutiger Bezeichner für die Anwendung und wird im umgekehrten DNS-Stil im Format geschrieben com.Firmenname.Produktname. Sobald die App auf Google Play veröffentlicht wurde, kann der Paketname nicht mehr geändert werden.
Gehen Sie dazu in das Menü Bearbeiten und wähle Projekteinstellungen - Player.
Auf der rechten Seite von Unity öffnet sich ein Fenster mit vielen verschiedenen Einstellungen, wie z. B. Anwendungsversion, Ziel- und Mindest-SDK, Symbolauswahl usw. Hier brauchen wir im Block Andere Einstellungen finden Identifikation und legen Sie den Paketnamen im Feld fest Paketnamen. Sie können auch andere Einstellungen ändern, wenn Sie dies wünschen.
Jetzt muss nur noch der Pfad zum Android SDK und JDK angegeben werden. Gehen Sie dazu in das Menü und wählen Sie aus Einstellungen bearbeiten.
Gehen Sie im angezeigten Fenster zu Externe Tools und auf den Feldern SDK und JDK Geben Sie die entsprechenden Pfade an und schließen Sie dann das Fenster.
Schritt 6: Erstellen und Ausführen der Anwendung
Es ist an der Zeit, Ihre erste Unity-App zu erstellen. Wählen Sie dazu im Menü aus Datei - Build-Einstellungen. Es öffnet sich ein Fenster, in dem Sie die Szene hinzufügen müssen, die Sie zusammenstellen möchten. Da wir diese Szene bereits im Editor geöffnet haben, klicken Sie einfach Offene Szenen hinzufügen Um es der Baugruppe hinzuzufügen, sehen Sie es nach dem Hinzufügen in der Liste der Szenen.
Es bleibt nur zu drücken Bauen, woraufhin Unity mit dem Erstellen der Anwendung beginnt. Zuvor werden Sie möglicherweise aufgefordert, einen Ordner auszuwählen, in dem die gesammelten Anwendungsdateien gespeichert werden, sowie den Namen der APK-Datei.
Notiz: im Moment, wenn Sie die Alpha-Version im Android SDK installiert haben Build-Tools(Ausführung 28.0.0-rc1), beim Erstellen von Gradle wird ein Fehler ausgegeben. Um dies zu beheben, entfernen Sie diese Version einfach aus dem Android SDK.
Als Ergebnis wird die erstellte APK-Datei in dem von Ihnen angegebenen Ordner angezeigt und kann auf dem Emulator oder auf einem echten Gerät installiert werden.
Mal sehen, was in der gebauten APK ist. Dazu verwenden wir das Dienstprogramm APK-Analysator, das in Android Studio enthalten ist,
Die Größe der unkomprimierten APK-Datei beträgt 21,1 MB, in einem komprimierten 20,9 MB. Wie Sie der Grafik entnehmen können, wird der größte Teil des Volumens von Bibliotheken von Drittanbietern belegt, die von Unity hinzugefügt wurden. Dann in Vermögenswerte alle Ressourcen, die in der zusammengesetzten Szene verwendet werden, sind lokalisiert. Datei Klassen.dex enthält nur 89 Klassen und 479 Methoden.
Darüber hinaus, wenn Sie sich ansehen AndroidManifest.xml, besteht die Anwendung aus einer Aktivität.
Fazit
Das ist alles. In diesem Artikel haben wir gelernt, wie Unity installiert und konfiguriert wird, und wir haben auch unsere erste Android-App entwickelt.
Unity ist der Motor, auf dem die meisten der moderne Spiele auf verschiedenen Plattformen. Durch die Engine ist es wirklich möglich, Spiele zu erstellen, die darauf ausgerichtet sind, auf Computern (Windows, Linux, MacOS) ausgeführt zu werden. Mobiltelefone, Tablet-Computer (Android, iOS) und sogar Spielekonsole Playstation, Xbox, Nintendo.
Wie erstelle ich Spiele in Unity?
Unity basiert auf einem komponentenorientierten Konzept. Tatsächlich besteht jedes Spiel aus einer Masse von Objekten, die mit zusätzlichen Komponenten verdünnt sind. Zum Beispiel erstellen wir während der Erstellung eines Plattformers ein GameObject, hängen zusätzlich eine Grafikkomponente daran an, die für die Anzeige des Charakters verantwortlich ist, und eine Steuerungskomponente, die die Steuerung des Charakters mit einer Maus, einer Tastatur, einem Joystick oder ermöglicht Berührungssensitiver Bildschirm. Die Engine erlegt der Anzahl solcher Module keine Beschränkungen auf. Wir können dem GameObject beliebig viele Komponenten hinzufügen. Alle Arbeiten an der Engine basieren auf der eigentlichen Erstellung von GameObject und der Anwendung geeigneter Komponenten darauf.
Anfänger können durch die scheinbare Einfachheit des Prozesses in die Irre geführt werden, obwohl dies nicht der Fall ist. Um ein einzigartiges und beliebtes Spiel zu erstellen, müssen Sie viele Komponenten von Grund auf neu schreiben. Genauer gesagt wird dies in der Unity-Umgebung als Skript bezeichnet. Die native Skriptsprache ist C#, teilweise kommen aber auch JavaScript und Boo (eine abgespeckte Version von Python) zum Einsatz. Das Erstellen eigener Komponenten ist nicht einfach, man könnte sogar sagen, es ist ein komplexer Vorgang, der direkt mit der klassischen Programmierung verbunden ist. Ohne ausreichende Programmierkenntnisse wird es schwierig.
Unterstützte Plattformen
Viele große Projekte bevorzugen Unity wegen der riesigen Liste von Plattformen, die mit der Engine kompatibel sind. Die fertige Anwendung kann auf jedem Computer-Betriebssystem, gängigen mobilen Plattformen und SmartTV gestartet werden. Was sollen wir sagen, sogar Browserspiele und Anwendungen für bestimmte Plattformen ( wie Tizen OS) werden überwiegend in Unity entwickelt.
Allerdings ist hier nicht alles so glatt. Bei Bedarf können Sie spezifische Algorithmen auf Basis von Low-Level-Code schreiben, für dasselbe Android müssen Sie jedoch über fundierte Java-Kenntnisse verfügen.
Dasselbe gilt für iOS. Ein weiteres Merkmal von iOS ist, dass es nur von einem Computer oder Tablet von Apple aus entwickelt werden kann. In Ermangelung eines Macbooks oder ähnlichen Geräts wird die Veröffentlichung des Spiels schnell ins Stocken geraten und Unity hat damit nichts zu tun, Apple selbst erlegt eine ähnliche Einschränkung auf. Das Fazit ist einfach: Ist eine iOS-Entwicklung in Planung, sollte man sich vorab ein passendes Gerät zum Zusammenbau aussuchen.
Wie und wo entwickelt man ein Spiel auf der Engine?
Wir können sowohl unter Windows als auch unter Mac OS X einen langen Prozess der Spieleentwicklung durchführen. Es gibt bereits Versionen des Editors für Linux, aber bisher können wir nicht mit einem stabilen Betrieb rechnen. Ein Entwickler verbringt die meiste Zeit damit, ein Spiel im Unity-Editor zu erstellen. Wir haben noch viel Zeit, um Skriptcode zu schreiben, wir können ihn entweder im Standard-MonoDevelop oder in einem beliebigen Drittanbieter-Editor erstellen. Jetzt verwenden sie aktiv Visual Studio sowie Sublime Text, aber nur mit der richtigen Konfiguration.
Entwicklung mobile Anwendungen ist einer der profitabelsten Berufe in der Computerindustrie. Die Erstellung eines Android-Spiels kostet Hunderte oder Tausende von Dollar, und der Gewinn kann bis zu einer Million Dollar betragen. In dieser Hinsicht sind viele Menschen daran interessiert, Anwendungen für das Telefon zu entwickeln. In diesem Artikel erfahren Sie, wie Sie mit einem Computer ein Android-Spiel von Grund auf neu erstellen, welche Engine und welcher Designer besser zu wählen sind.
Keiner erfolgreiches Spiel kann nicht auf schöne Grafiken verzichten, daher ist die Erstellung von Design eine der wichtigsten Phasen der Entwicklung. Das Design auf dem Android-Betriebssystem wird mithilfe eines „Designdokuments“ oder Designdokuments implementiert. Sie müssen mit der Erstellung eines Spielzeugs mit seiner detaillierten Studie beginnen. Die Datei enthält:
- Objektmodelle;
- Funktionsspezifikationen;
- Spielinhalt;
- Schnittstelle.
Betrachten wir jeden der Punkte genauer.
Objektmodelle
Dies sind Informationen über die Funktionalität der einzelnen Elemente. Objektmodelle sind für die Fähigkeit, Gegenstände zu kaufen und zu verkaufen, sowie für die Verbesserung der Spieleigenschaften von Charakteren verantwortlich.
Funktionale Spezifikationen
Es beschreibt das Gameplay, die Hauptmerkmale jedes Charakters. Es beschreibt auch die Funktionen Spielgegenstände- Waffen, Erste-Hilfe-Sets, Rüstungen und andere. Im Wesentlichen sind funktionale Spezifikationen die Regeln, nach denen Spielablauf. Je besser dieser Abschnitt ausgearbeitet ist, desto einfacher wird es, ein hochwertiges Android-Spiel zu erstellen.
Spielinhalt
Dies ist die Textfüllung des Spiels. Es beschreibt die Dialoge der Charaktere und welche Waffen verwendet werden können, um Schaden zu verursachen, wie viel Gesundheit ein Treffer kostet, welche Eigenschaften sich beim Verwenden verschiedener Ausrüstungsgegenstände erhöhen. Es enthält auch detaillierte Beschreibung jeder Gegenstand.
Schnittstelle
Die Schnittstelle ist, wie der Benutzer mit dem Spiel interagiert. Es enthält Schaltflächen, mit denen Sie den Charakter steuern können, und Menüabschnitte: zum Beispiel Spielen, Punktestand, Einstellungen, Top-Spieler, Hilfe. Wenn Sie keine Erfahrung mit der Erstellung von Android-Anwendungen haben, laden Sie sie aus dem Play Market herunter und analysieren Sie sie, bevor Sie Ihre eigenen erstellen beliebte Spiele und übertragen die besten Lösungen auf Ihr Projekt.
Spiel-Engine
Das Herzstück eines jeden Spiels ist die Engine. Das Software, sodass Sie es entwickeln und ausführen können. Es enthält eine ganze Reihe von Programmen, darunter eine Rendering-Engine, eine Physik-Engine, Sound, Animation und vieles mehr. Um das Schreiben von Programmen zu erleichtern, erstellen Drittentwickler ihre eigenen Spiel-Engines speziell für Android-Anwendungen.
Jeder von ihnen bietet unterschiedliche Funktionen: einige sind für 3D ausgelegt, andere für 2D, Multi-Plattform kann unterstützt werden. Es gibt eine große Anzahl solcher Engines, aber wenn Sie ein Anfänger sind, ist es besser, eine der beliebtesten zu wählen, da dort alle notwendigen Funktionen vorhanden sind.
UDK
Drehmoment 2d/3d
Was ist ein Spieledesigner?
Constructor ist ein Programm, das eine Spiel-Engine und eine integrierte Entwicklungsumgebung kombiniert. Der Konstruktor macht den Entwicklungsprozess für Personen ohne Programmierkenntnisse zugänglich. Einige der Designer ermöglichen es Ihnen, Spiele bestimmter Genres zu erstellen, andere haben maximale Funktionalität, kosten aber viel mehr Geld. Für einen unerfahrenen Entwickler mobiler Anwendungen ist die Wahl eines Designers einer der wichtigsten Momente, da das Schicksal der zukünftigen Anwendung von ihren Fähigkeiten abhängen wird.
Mit dem Konstruktor können Sie Spiele verschiedener Genres für Windows, Android und iOS erstellen. Bietet an große Auswahl vorgefertigte Orte, Objekte, Charaktere und Sounddesign, sodass die Erstellung des ersten Android-Spiels nicht viel Zeit in Anspruch nehmen wird. Benutzer, die mit den Programmiersprachen JS und C++ vertraut sind, können das eingebettete GML verwenden. Der einzige Nachteil ist, dass das Programm nicht ins Russische übersetzt wird.
Fazit
Das Erstellen eines Android-Spiels ist kein einfaches, aber sehr profitables Geschäft. Wenn Sie sich entscheiden, ein Spiel zu entwickeln und damit Geld zu verdienen, arbeiten Sie zuerst die Idee aus. Schreiben Sie als Nächstes ein „Designdokument“ und entscheiden Sie sich für eine Spiel-Engine, die ihr Potenzial maximieren kann. Danach können Sie direkt mit der Erstellung der Anwendung im Konstruktor fortfahren.
Video
Um mehr über den Prozess der Erstellung von Android-Spielen zu erfahren, sehen Sie sich eine Reihe von Videos an, die dieser Aktivität gewidmet sind.
So schreiben Sie schnell ein Android-Spiel mit Unity
Heutzutage kann jeder ein erfolgreicher Entwickler von Handyspielen oder Anwendungen werden, ohne sich titanisch anstrengen zu müssen. Ein Beispiel für einen solchen Fall ist Dong Nguyen, der Flappy Bird entwickelt hat. Das Spiel hatte keine komplexe Mechanik oder Grafik, aber das hinderte es nicht daran, populär zu werden und seinem Schöpfer fünfzigtausend Dollar pro Tag einzubringen. Es gab jedoch nichts Bemerkenswertes an dem Spiel. Um erfolgreich zu sein, brauchte es nur, zur richtigen Zeit am richtigen Ort zu sein und ein bisschen Glück. Ähnliches kann heute passieren, man braucht nur die richtige Idee.
Um zu demonstrieren, wie einfach es ist, so etwas zu schreiben, werden wir heute unseren eigenen Flappy Bird mit Unity in nur 10 Minuten schreiben.
Spielfigur
Erstellen Sie zuerst ein neues Projekt und stellen Sie sicher, dass die Option 2D ausgewählt ist.
Laden Sie Ihr Vogel-Sprite in die Szene. Vergessen Sie nicht, Ihrer Fantasie freien Lauf zu lassen!
Passen Sie dann die Größe des Sprites Ihren Wünschen an, indem Sie es um die Ecke in die gewünschte Richtung ziehen. Das Sprite sollte im Hierarchiefenster auf der linken Seite sichtbar sein. Alle Objekte in der Szene sind darin sichtbar, und im Moment sollte es nur zwei davon geben: eine Kamera und einen Vogel.
Ziehen Sie die Kamera auf den Vogel und lassen Sie sie los. Die Kamera sollte sich unter dem Vogel befinden, was bedeutet, dass die Kamera jetzt das "Kind" des Vogels ist. Jetzt wird die Kameraposition relativ zum Vogel fixiert. Bewegt sich der Vogel vorwärts, macht die Kamera dasselbe.
Wählen Sie den Vogel erneut in der Szene oder im Hierarchiefenster aus. Auf der rechten Seite sehen Sie in einem Fenster namens Inspector eine Liste mit Optionen und Attributen. Hier können Sie verschiedene Variablen verwalten, die an ein bestimmtes Objekt gebunden sind.
Klicken Sie nun auf Komponente hinzufügen . Wählen Sie Physics2D > Rigidbody2D - das ist fertig eingestellt Anweisungen zur Anwendung der Schwerkraft auf unseren Charakter. Klicken Sie in diesem Bereich auf Constraints und wählen Sie dann Freeze Rotation Z . Dadurch wird verhindert, dass sich der Vogel mit der Kamera dreht.
Fügen Sie auf die gleiche Weise einen Polygon Collider hinzu, der Unity mitteilt, wo sich die Grenzen des Charakters befinden. Drücken Sie Play und sehen Sie, wie das Sprite zusammen mit der Kamera endlos herunterfällt.
Bisher läuft alles gut!
Jetzt ist es an der Zeit, den Charakter zu fliegen, da es nicht schwierig sein wird.
Zuerst müssen Sie ein C#-Skript erstellen. Erstellen Sie einen Ordner dafür (klicken Sie mit der rechten Maustaste irgendwo in Assets und erstellen Sie einen Ordner „Scripts“), klicken Sie mit der rechten Maustaste und wählen Sie Create > C# Script aus.
Nennen wir es „Charakter“. Doppelklicken Sie darauf, um es in Ihrer IDE zu öffnen, sei es MonoDevelop oder Visual Studio. Fügen Sie dann den folgenden Code hinzu:
Öffentliche Klasse Character: MonoBehaviour ( public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // Dies dient der Initialisierung void Start () ( rb = GetComponent(); ) // Update wird einmal pro Frame aufgerufen void Update () ( rb .velocity = new Vector2(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) ( rb.velocity = new Vector2(rb.velocity.x, flapHeight); ) if (transform.position.y > 18 || Transformationsposition.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }
Dieser Code macht zwei Dinge. Dadurch bewegt sich der Charakter mit einer Geschwindigkeit vorwärts, die wir im Inspektor definieren, und erweckt den Eindruck eines fliegenden Vogels. Die Update()-Methode wird während des Spiels wiederholt aufgerufen, sodass alles, was Sie hier eingeben, kontinuierlich ausgeführt wird. In diesem Fall fügen wir unserem Objekt etwas Geschwindigkeit hinzu. Die rb-Variable ist das RigidBody2D-Skript, das wir zuvor auf unser Objekt angewendet haben. Wenn wir also rb.velocity schreiben, beziehen wir uns auf die Geschwindigkeit des Objekts.
Ein Tippen auf den Bildschirm wird von Unity als Mausklick interpretiert, wenn Sie ein mobiles Gerät verwenden. Nach dem Drücken zwingen wir den Charakter, sich ein wenig zu erheben.
Die Variable moveSpeed ist für die Bewegungsgeschwindigkeit und die Variable flapHeight für die Erhöhung der Flughöhe des Vogels nach jedem Klick verantwortlich. Da diese Variablen öffentlich sind, können wir sie außerhalb des Skripts ändern.
Die Methode Death() ist ebenfalls als public deklariert, was bedeutet, dass andere Objekte und Skripte sie aufrufen können. Diese Methode gibt einfach die Position des Zeichens an den Anfang zurück. Es wird auch jedes Mal verwendet, wenn der Charakter zu hoch oder zu niedrig fliegt. Sie werden schnell verstehen, warum es als öffentlich deklariert ist. Die Zeile rb.velocity = Vector3.zero; benötigt, um den Schwung zu entfernen - wir wollen nicht, dass der Charakter nach jedem Tod immer schneller fällt, oder?
Jetzt können Sie die IDE verlassen und das Skript als Komponente zum Charakter hinzufügen. Wählen Sie dazu unseren Vogel aus und klicken Sie auf Add Component > Scripts > Character . Jetzt können wir moveSpeed und flapHeight im Inspektor definieren (dafür sind die öffentlichen Variablen da). Zuordnen variable Werte 3 bzw. 5.
Und noch etwas: Im Inspektor müssen Sie dem Charakter ein Tag hinzufügen. Klicken Sie dazu auf die Stelle, an der Tag: Untagged steht, und wählen Sie dann Player aus der Dropdown-Liste aus.
Hindernis
Jetzt fügen wir Hindernisse hinzu: Rohre. Jemand findet Pilze in den Rohren und jemand findet seinen eigenen Tod.
Ziehen Sie das Pipe-Sprite in die Szene, wo das erste Hindernis sein soll, und nennen Sie es pipe_up .
Lassen Sie uns nun ein neues Skript namens Pipe erstellen:
Öffentliche Klasse Pipe: MonoBehaviour ( private Character character; // Wird für die Initialisierung benötigt void Start () ( character = FindObjectOfType(); ) // Update wird einmal pro Frame aufgerufen void Update () ( if (character.transform.position.x - transform.position.x >
Fügen Sie dieses Skript auf die gleiche Weise wie zuvor zum Pipe-Sprite hinzu. Somit kehrt die Röhre zum Bildschirm zurück, nachdem sie ihren linken Rand verlassen hat. Wir haben hier noch nichts gemacht, aber wir werden darauf zurückkommen.
Die Methode OnCollisionEnter2D() wird jedes Mal aufgerufen, wenn die Pipe mit einem Zeichen interagiert. Danach wird die zuvor erstellte Death()-Methode aufgerufen, die den Spieler zum Ausgangspunkt zurückbringt.
Wir haben also eine Röhre, die von Zeit zu Zeit verschwindet und am anderen Ende des Bildschirms wieder auftaucht. Schlag sie, du stirbst.
umgekehrte Rohre
Im Moment haben wir nur ein Pipe-Sprite. Fügen wir noch eine hinzu. Klicken Sie dazu mit der rechten Maustaste in das Hierarchiefenster, klicken Sie auf Neues 2D-Objekt > Sprite und wählen Sie dann das Sprite aus, das Sie verwenden möchten. Noch einfacher ist es, die Datei einfach wieder in die Szene zu ziehen.
Nennen Sie dieses Sprite pipe_down . Wählen Sie im Inspektor unter Sprite-Renderer die Option Flip Y, um das Rohr auf den Kopf zu stellen. Fügen Sie denselben RigidBody2D hinzu.
Lassen Sie uns nun ein neues C#-Skript mit dem Namen PipeD schreiben. Es wird einen ähnlichen Code haben:
Öffentliche Klasse PipeD: MonoBehaviour ( private Character character; //Dies wird für die Initialisierung benötigt void Start() ( character = FindObjectOfType(); ) // Update wird einmal pro Frame aufgerufen void Update() ( if (character.transform.position. x - transform.position.x > 30) ( ) ) void OnCollisionEnter2D(Collision2D other) ( if (other.gameObject.tag == "Player") ( character.Death(); ) ) )
Fertighäuser
Dieser Code reicht uns also aus, um das ganze Spiel zu erstellen. Wir könnten die Rohre jedes Mal, wenn sie verschwinden, auf die rechte Seite des Bildschirms verschieben oder während des Spiels so viele Rohre kopieren und einfügen, wie wir möchten.
Wenn Sie den ersten Weg gehen, stellen Sie sicher, dass die Rohre nach der Zufallsgenerierung richtig sind, und es wäre schwierig, einen fairen Lauf der Dinge aufrechtzuerhalten. Nach dem Tod des Charakters könnten sie Kilometer von der ersten Pfeife entfernt erscheinen!
Wenn Sie den zweiten Weg gehen, endet alles in einem übermäßigen Speicherverbrauch, mit der daraus resultierenden Verlangsamung des Spiels und einem begrenzten Wiederspielwert, weil. alles bleibt immer an der gleichen Stelle.
Verwenden wir stattdessen Prefabs. Einfach ausgedrückt verwandeln wir unsere Pfeifen in Vorlagen, mit denen wir dann nach Belieben effektiv mehr Pfeifen erstellen können. Wenn es hier Programmierer gibt, dann betrachten Sie das Pipe-Skript als Klasse und Pipes als Instanzen dieses Objekts.
Erstellen Sie dazu einen neuen Ordner „Prefabs“. Ziehen Sie dann pipe_up und pipe_down aus dem Hierarchiefenster in den Ordner.
Jedes Mal, wenn Sie ein Objekt aus diesem Ordner in die Szene ziehen, hat es dieselben Eigenschaften, sodass Sie nicht ständig Komponenten hinzufügen müssen. Wenn Sie die Größe einer Komponente in einem Ordner ändern, wirkt sich dies außerdem auf alle Rohre im Spiel aus, und Sie müssen die Größe nicht für jede einzeln ändern.
Wie Sie sich vorstellen können, werden dadurch unsere Ressourcen erheblich geschont. Es bedeutet auch, dass wir mit Objekten aus Code interagieren können. Wir können unsere Pipes instanziieren.
Fügen Sie zuerst diesen Code zum Bedingungsausdruck in der Methode Update() des Pipe-Skripts hinzu, den wir leer gelassen haben:
Void Update () (if (character.transform.position.x - transform.position.x > 30) (float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); Instanziieren (gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); ) )
Dies wird benötigt, um eine Instanz unseres gameObject zu erstellen. Das Ergebnis ist eine neue identische Kopie. Wenn Sie in Unity das Wort gameObject verwenden, bezieht es sich auf das Objekt, an das das Skript derzeit gebunden ist – in unserem Fall die Pipe.
Wir generieren unsere Pfeifen in zufälligen Variationen neu, damit es mehr Spaß macht.
Aber anstatt im PipeD-Skript dasselbe zu tun, generieren wir beide Objekte an derselben Stelle. So können wir die Position des zweiten Rohrs relativ zum ersten leicht einstellen. Es bedeutet auch, dass wir weniger Code für PipeD benötigen.
Erstellen Sie ein öffentliches gameObject namens pipeDown . Aktualisieren Sie dann den Code wie folgt:
If (character.transform.position.x - transform.position.x > 30) (float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); float gapRan = Random.Range (0, 3); Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate(pipeDown, new Vector2(character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Destroy(gameObject); )
Gehen Sie zurück zu Unity und ziehen Sie das Pipe_down-Prefab aus dem Prefabs-Ordner (das ist wichtig!) an die Stelle, an der "Pipe Down" steht (beachten Sie, wie unser Camel-Case durch ein Leerzeichen ersetzt wird) auf das Pipe-Sprite pipe up . Wenn Sie sich erinnern, haben wir Pipe Down als öffentliches gameObject definiert, was uns die Möglichkeit gibt, von überall aus zu bestimmen, was dieses Objekt ist – in diesem Fall durch den Inspektor. Indem wir ein Prefab für dieses Objekt auswählen, stellen wir sicher, dass die Pipe bei der Instanziierung alle zuvor hinzugefügten Attribute und Skripte enthält. Wir erstellen nicht nur ein Sprite, sondern erstellen ein Objekt mit einem Collider, der den Charakter töten kann.
Alles, was wir an derselben Stelle im PipeD-Skript hinzufügen, ist nur Destroy(gameObject) , sodass sich die Pipe selbst zerstört, wenn sie die linke Seite des Bildschirms verlässt.
Wenn Sie das Spiel jetzt starten, bewegt sich der Bildschirm automatisch weiter und Sie sterben, wenn Sie eines der Rohre treffen. Fliegen Sie weit genug und diese Rohre werden verschwinden und vor Ihnen wieder auftauchen.
Leider gibt es einen großen Abstand zwischen den Rohren und der Bildschirm sieht leer aus. Wir könnten dies beheben, indem wir unserer Szene einige Prefabs hinzufügen, um eine Pipeline von ständig spawnenden Pipes zu erstellen. Besser wäre es jedoch, die Pipes in einem Skript zu generieren. Dies ist wichtig, da sonst nach dem Tod des Charakters die Rohre am Anfang des Pfades zerstört werden und sich wieder leere Räume bilden.
Auf diese Weise können wir bei jedem Spielladevorgang die ersten Pfeifen erstellen und nach dem Tod des Charakters alles an seinen Platz zurückbringen.
Endloser Flug
Lassen Sie uns nun die öffentlichen Variablen pipe_up und pipe_down im Zeichenskript erstellen. Dadurch können Sie auf die erstellten Objekte verweisen, indem Sie Prefabs auf das Zeichenobjekt ziehen, genau wie beim Hinzufügen von pipe_down zum Pipe-Skript.
Wir müssen diese Variablen hinzufügen:
Öffentliches Spielobjekt pipe_up; öffentliches GameObject pipe_down;
Dann schreiben wir eine Methode wie diese:
Public void BuildLevel() ( Instantiate(pipe_down, new Vector3(14, 12), transform.rotation); Instantiate(pipe_up, new Vector3(14, -11), transform.rotation); Instantiate(pipe_down, new Vector3(26, 14), transform.rotation); Instantiate(pipe_up, new Vector3(26, -10), transform.rotation); Instantiate(pipe_down, new Vector3(38, 10), transform.rotation); Instantiate(pipe_up, new Vector3( 38, -14), transform.rotation); Instantiate(pipe_down, new Vector3(50, 16), transform.rotation); Instantiate(pipe_up, new Vector3(50, -8), transform.rotation); Instantiate(pipe_down, new Vector3(61, 11), transform.rotation); Instantiate(pipe_up, new Vector3(61, -13), transform.rotation); )
Wir werden es einmal in der Methode Update() und einmal in der Methode Death() aufrufen.
Nachdem das Spiel gestartet wurde, wird Update() aufgerufen und unsere Pipes werden entsprechend der gegebenen Konfiguration platziert. Aus diesem Grund befinden sich die ersten Hindernisse immer an der gleichen Stelle. Nach dem Tod des Spielers kehren die Pfeifen an die gleichen Stellen zurück.
Kehren Sie zur Szene in Unity zurück und löschen Sie die beiden Rohre, die jetzt dort sind. Ihr "Spiel" wird einfach wie ein leerer Bildschirm mit einem Vogel aussehen. Drücken Sie Play und die Rohre erscheinen, nach den ersten paar wird ihre Position zufällig bestimmt.
Abschließend
Das haben wir getan gesamtes Spiel! Fügen Sie einen Punktezähler hinzu, versuchen Sie, ihn origineller zu gestalten, und erhöhen Sie die Schwierigkeit des Spiels, während Sie fortschreiten. Außerdem ist es nicht überflüssig, ein Menü zu erstellen. Eine weitere gute Idee ist es, die Rohre auf dem Bildschirm nach dem Tod des Charakters zu zerstören. Wenn Sie damit fertig sind, betrachten Sie es als bereit für die Veröffentlichung in Spielladen Spiel in der Tasche! Es war einmal ähnliches Spiel machte einen anderen Entwickler sehr reich, was beweist, dass man kein Programmiergenie sein oder einen reichen Publisher hinter sich haben muss, um erfolgreich zu sein. Du brauchst nur eine gute Idee und zehn Minuten!
Sie möchten Android-Apps schreiben, wissen aber nicht, wo Sie anfangen sollen? Dann sehen Sie sich unser großartiges Tutorial zum Erlernen der Android-Entwicklung an.
