Spiele entwickeln mit Unity 5

2D- und 3D-Games mit Unity und C# für Desktop, Web & Mobile. Für Unity 5.6
 
 
Hanser (Verlag)
  • 3. Auflage
  • |
  • erschienen am 11. September 2017
  • |
  • 670 Seiten
 
E-Book | ePUB mit Wasserzeichen-DRM | Systemvoraussetzungen
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-45368-5 (ISBN)
 
Der Bestseller zur Spieleentwicklung mit Unity jetzt in der dritten, aktualisierten Auflage

Begeben Sie sich mit Carsten Seifert - alias Hummelwalker auf YouTube - und Jan Wislaug - Video-Trainer für Unity - in die Welt von Unity 5. Erfahren Sie hier, wie Sie Ihre Ideen umsetzen und eigene Spiele entwickeln können. Nach einer Einführung in C# und die Skript-Programmierung lernen Sie, wie die wichtigsten Werkzeuge und Systeme in Unity funktionieren, zusammenarbeiten und wie Sie diese kombinieren können. Darauf aufbauend entwickeln Sie zwei komplette Spiele - ein 2D- und ein 3D-Game.

Die dritte Auflage wurde komplett auf Unity 5.6 aktualisiert und geht u. a. auf die neue Plattform WebGL ein, beschreibt das überarbeitete Licht-System und zeigt die neuen Möglichkeiten beim Partikelsystem. Die Spiele sowie Video-Tutorials stehen als Online-Download zur Verfügung.
3., aktualisierte und erweiterte Auflage
  • Deutsch
  • München
  • |
  • Deutschland
  • 40,88 MB
978-3-446-45368-5 (9783446453685)
3446453687 (3446453687)
http://dx.doi.org/10.3139/9783446453685
weitere Ausgaben werden ermittelt
Dipl-Ing (FH) Carsten Seifert ist Spiele- und Softwareentwickler, Blogger und YouTuber. Der Unity-Community ist er mit seinen Tutorials bestens bekannt.
Jan Wislaug arbeitet als Unity 3D-Entwickler bei einer Spieleentwicklungsfirma in Bochum. Privat entwickelt er Indie Games. Als Softwareentwickler und Technical Artist ist er sowohl mit der technischen als auch mit der künstlerischen Seite des Game Developments vertraut.
1 - Inhalt [Seite 5]
2 - Vorwort [Seite 20]
3 - 1 Einleitung [Seite 22]
3.1 - 1.1 Multiplattform-Publishing [Seite 22]
3.2 - 1.2 Das kann Unity (nicht) [Seite 23]
3.3 - 1.3 Lizenzmodelle [Seite 23]
3.4 - 1.4 Aufbau und Ziel des Buches [Seite 24]
3.5 - 1.5 Weiterentwicklung von Unity [Seite 25]
3.6 - 1.6 Online-Zusatzmaterial [Seite 26]
4 - 2 Grundlagen [Seite 28]
4.1 - 2.1 Installation [Seite 28]
4.2 - 2.2 Oberfläche [Seite 28]
4.2.1 - 2.2.1 Hauptmenü [Seite 30]
4.2.2 - 2.2.2 Scene View [Seite 31]
4.2.3 - 2.2.3 Game View [Seite 33]
4.2.4 - 2.2.4 Toolbar [Seite 35]
4.2.5 - 2.2.5 Hierarchy [Seite 37]
4.2.6 - 2.2.6 Inspector [Seite 38]
4.2.7 - 2.2.7 Project Browser [Seite 42]
4.2.8 - 2.2.8 Console [Seite 44]
4.3 - 2.3 Das Unity-Projekt [Seite 44]
4.3.1 - 2.3.1 Neues Projekt anlegen [Seite 45]
4.3.2 - 2.3.2 Bestehendes Projekt öffnen [Seite 46]
4.3.3 - 2.3.3 Projektdateien [Seite 47]
4.3.4 - 2.3.4 Szene [Seite 47]
4.3.5 - 2.3.5 Game Objects [Seite 48]
4.3.6 - 2.3.6 Tags [Seite 50]
4.3.7 - 2.3.7 Layer [Seite 51]
4.3.8 - 2.3.8 Assets [Seite 52]
4.3.9 - 2.3.9 Frames [Seite 55]
4.4 - 2.4 Das erste Übungsprojekt [Seite 55]
5 - 3 C# und Unity [Seite 58]
5.1 - 3.1 Die Sprache C# [Seite 58]
5.2 - 3.2 Syntax [Seite 59]
5.3 - 3.3 Kommentare [Seite 60]
5.4 - 3.4 Variablen [Seite 60]
5.4.1 - 3.4.1 Namenskonventionen [Seite 60]
5.4.2 - 3.4.2 Datentypen [Seite 61]
5.4.3 - 3.4.3 Schlüsselwort var [Seite 62]
5.4.4 - 3.4.4 Datenfelder/Array [Seite 62]
5.5 - 3.5 Konstanten [Seite 64]
5.5.1 - 3.5.1 Enumeration [Seite 64]
5.6 - 3.6 Typkonvertierung [Seite 65]
5.7 - 3.7 Rechnen [Seite 65]
5.8 - 3.8 Verzweigungen [Seite 66]
5.8.1 - 3.8.1 if-Anweisungen [Seite 67]
5.8.2 - 3.8.2 switch-Anweisung [Seite 69]
5.9 - 3.9 Schleifen [Seite 70]
5.9.1 - 3.9.1 for-Schleife [Seite 70]
5.9.2 - 3.9.2 Foreach-Schleife [Seite 71]
5.9.3 - 3.9.3 while-Schleife [Seite 71]
5.9.4 - 3.9.4 do-Schleife [Seite 72]
5.10 - 3.10 Klassen [Seite 72]
5.10.1 - 3.10.1 Komponenten per Code zuweisen [Seite 73]
5.10.2 - 3.10.2 Instanziierung von Nichtkomponenten [Seite 73]
5.10.3 - 3.10.3 Werttypen und Referenztypen [Seite 75]
5.10.4 - 3.10.4 Überladene Methoden [Seite 76]
5.11 - 3.11 Der Konstruktor [Seite 76]
5.11.1 - 3.11.1 Konstruktoren in Unity [Seite 77]
5.12 - 3.12 Lokale und globale Variablen [Seite 77]
5.12.1 - 3.12.1 Namensverwechslung verhindern mit this [Seite 77]
5.13 - 3.13 Zugriff und Sichtbarkeit [Seite 78]
5.14 - 3.14 Statische Klassen und Klassenmember [Seite 78]
5.15 - 3.15 Parametermodifizierer out/ref [Seite 79]
5.16 - 3.16 Array-Übergabe mit params [Seite 80]
5.17 - 3.17 Eigenschaften und Eigenschaftsmethoden [Seite 81]
5.18 - 3.18 Vererbung [Seite 82]
5.18.1 - 3.18.1 Basisklasse und abgeleitete Klassen [Seite 83]
5.18.2 - 3.18.2 Vererbung und die Sichtbarkeit [Seite 83]
5.18.3 - 3.18.3 Geerbte Methode überschreiben [Seite 84]
5.18.4 - 3.18.4 Zugriff auf die Basisklasse [Seite 84]
5.18.5 - 3.18.5 Klassen versiegeln [Seite 85]
5.19 - 3.19 Polymorphie [Seite 85]
5.20 - 3.20 Schnittstellen [Seite 86]
5.20.1 - 3.20.1 Schnittstelle definieren [Seite 86]
5.20.2 - 3.20.2 Schnittstellen implementieren [Seite 86]
5.20.3 - 3.20.3 Zugriff über eine Schnittstelle [Seite 87]
5.21 - 3.21 Namespaces [Seite 88]
5.21.1 - 3.21.1 Eigene Namespaces definieren [Seite 89]
5.22 - 3.22 Generische Klassen und Methoden [Seite 90]
5.22.1 - 3.22.1 List [Seite 90]
5.22.2 - 3.22.2 Dictionary [Seite 91]
6 - 4 Skript-Programmierung [Seite 94]
6.1 - 4.1 MonoDevelop [Seite 94]
6.1.1 - 4.1.1 Hilfe in MonoDevelop [Seite 95]
6.1.2 - 4.1.2 Syntaxfehler [Seite 95]
6.2 - 4.2 Nutzbare Programmiersprachen [Seite 96]
6.2.1 - 4.2.1 Warum C#? [Seite 97]
6.3 - 4.3 Unitys Vererbungsstruktur [Seite 97]
6.3.1 - 4.3.1 Object [Seite 98]
6.3.2 - 4.3.2 GameObject [Seite 98]
6.3.3 - 4.3.3 ScriptableObject [Seite 98]
6.3.4 - 4.3.4 Component [Seite 98]
6.3.5 - 4.3.5 Transform [Seite 99]
6.3.6 - 4.3.6 Behaviour [Seite 99]
6.3.7 - 4.3.7 MonoBehaviour [Seite 99]
6.4 - 4.4 Skripte erstellen [Seite 99]
6.4.1 - 4.4.1 Skripte umbenennen [Seite 100]
6.5 - 4.5 Das Skript-Grundgerüst [Seite 101]
6.6 - 4.6 Unitys Event-Methoden [Seite 101]
6.6.1 - 4.6.1 Update [Seite 102]
6.6.2 - 4.6.2 FixedUpdate [Seite 102]
6.6.3 - 4.6.3 Awake [Seite 103]
6.6.4 - 4.6.4 Start [Seite 103]
6.6.5 - 4.6.5 OnGUI [Seite 103]
6.6.6 - 4.6.6 LateUpdate [Seite 104]
6.6.7 - 4.6.7 Aufruf-Reihenfolge [Seite 104]
6.7 - 4.7 Komponentenprogrammierung [Seite 105]
6.7.1 - 4.7.1 Auf GameObjects zugreifen [Seite 105]
6.7.2 - 4.7.2 GameObjects aktivieren und deaktivieren [Seite 107]
6.7.3 - 4.7.3 GameObjects zerstören [Seite 107]
6.7.4 - 4.7.4 GameObjects erstellen [Seite 107]
6.7.5 - 4.7.5 Auf Components zugreifen [Seite 108]
6.7.6 - 4.7.6 Components hinzufügen [Seite 110]
6.7.7 - 4.7.7 Components entfernen [Seite 110]
6.7.8 - 4.7.8 Components aktivieren und deaktivieren [Seite 110]
6.7.9 - 4.7.9 Attribute [Seite 111]
6.8 - 4.8 Zufallswerte [Seite 112]
6.9 - 4.9 Parallel Code ausführen [Seite 113]
6.9.1 - 4.9.1 WaitForSeconds [Seite 114]
6.10 - 4.10 Verzögerte und wiederholende Funktionsaufrufe mit Invoke [Seite 115]
6.10.1 - 4.10.1 Invoke [Seite 115]
6.10.2 - 4.10.2 InvokeRepeating, IsInvoking und CancelInvoke [Seite 115]
6.11 - 4.11 Daten speichern und laden [Seite 116]
6.11.1 - 4.11.1 PlayerPrefs-Voreinstellungen [Seite 116]
6.11.2 - 4.11.2 Daten speichern [Seite 117]
6.11.3 - 4.11.3 Daten laden [Seite 118]
6.11.4 - 4.11.4 Key überprüfen [Seite 118]
6.11.5 - 4.11.5 Löschen [Seite 118]
6.11.6 - 4.11.6 Save [Seite 118]
6.12 - 4.12 Szeneübergreifende Daten [Seite 119]
6.12.1 - 4.12.1 Werteübergabe mit PlayerPrefs [Seite 119]
6.12.2 - 4.12.2 Zerstörung unterbinden [Seite 121]
6.13 - 4.13 Debug-Klasse [Seite 123]
6.14 - 4.14 Kompilierungsreihenfolge [Seite 123]
6.14.1 - 4.14.1 Programmsprachen mischen und der sprachübergreifende Zugriff [Seite 124]
6.15 - 4.15 Ausführungsreihenfolge [Seite 124]
6.16 - 4.16 Plattformabhängig Code kompilieren [Seite 125]
6.17 - 4.17 Eigene Assets mit ScriptableObject [Seite 126]
6.17.1 - 4.17.1 Neue ScriptableObject-Subklasse erstellen [Seite 126]
6.17.2 - 4.17.2 Instanzen eines ScriptableObjects erstellen [Seite 127]
7 - 5 Objekte in der zweiten und dritten Dimension [Seite 130]
7.1 - 5.1 Das 3D-Koordinatensystem [Seite 130]
7.2 - 5.2 Vektoren [Seite 131]
7.2.1 - 5.2.1 Ort, Winkel und Länge [Seite 132]
7.2.2 - 5.2.2 Normalisieren [Seite 133]
7.3 - 5.3 Das Mesh [Seite 134]
7.3.1 - 5.3.1 Normalenvektor [Seite 135]
7.3.2 - 5.3.2 MeshFilter und MeshRenderer [Seite 136]
7.4 - 5.4 Transform [Seite 138]
7.4.1 - 5.4.1 Kontextmenü der Transform-Komponente [Seite 138]
7.4.2 - 5.4.2 Objekthierarchien [Seite 139]
7.4.3 - 5.4.3 Scripting mit Transform [Seite 140]
7.4.4 - 5.4.4 Quaternion [Seite 140]
7.5 - 5.5 Shader und Materials [Seite 141]
7.5.1 - 5.5.1 Der Standard-Shader [Seite 142]
7.5.2 - 5.5.2 Texturen [Seite 159]
7.5.3 - 5.5.3 UV Mapping [Seite 162]
7.6 - 5.6 3D-Modelle einer Szene zufügen [Seite 163]
7.6.1 - 5.6.1 Primitives [Seite 163]
7.6.2 - 5.6.2 3D-Modelle importieren [Seite 165]
7.6.3 - 5.6.3 In Unity modellieren [Seite 166]
7.6.4 - 5.6.4 Prozedurale Mesh-Generierung [Seite 167]
7.6.5 - 5.6.5 Level Of Detail [Seite 167]
7.7 - 5.7 2D in Unity [Seite 169]
7.7.1 - 5.7.1 Sprites [Seite 170]
7.7.2 - 5.7.2 SpriteRenderer [Seite 175]
7.7.3 - 5.7.3 Parallax Scrolling [Seite 178]
8 - 6 Kameras, die Augen des Spielers [Seite 182]
8.1 - 6.1 Die Kamera [Seite 182]
8.1.1 - 6.1.1 Komponenten eines Kamera-Objektes [Seite 184]
8.1.2 - 6.1.2 HDR - High Dynamic Range-Rendering [Seite 184]
8.1.3 - 6.1.3 Linearer- und Gamma-Farbraum [Seite 187]
8.2 - 6.2 Kamerasteuerung [Seite 190]
8.2.1 - 6.2.1 Statische Kamera [Seite 190]
8.2.2 - 6.2.2 Parenting-Kamera [Seite 191]
8.2.3 - 6.2.3 Kamera-Skripte [Seite 191]
8.3 - 6.3 ScreenPointToRay [Seite 193]
8.4 - 6.4 Mehrere Kameras [Seite 194]
8.4.1 - 6.4.1 Kamerawechsel [Seite 194]
8.4.2 - 6.4.2 Split-Screen [Seite 195]
8.4.3 - 6.4.3 Einfache Minimap [Seite 196]
8.4.4 - 6.4.4 Render Texture [Seite 198]
8.5 - 6.5 Image Effects [Seite 200]
8.5.1 - 6.5.1 Beispiel: Haus bei Nacht [Seite 200]
8.6 - 6.6 Skybox [Seite 202]
8.6.1 - 6.6.1 Mehrere Skyboxen gleichzeitig einsetzen [Seite 203]
8.6.2 - 6.6.2 Skybox selber erstellen [Seite 204]
8.7 - 6.7 Occlusion Culling [Seite 205]
8.7.1 - 6.7.1 Occluder Static und Occludee Static [Seite 207]
8.7.2 - 6.7.2 Occlusion Culling erstellen [Seite 207]
9 - 7 Licht und Schatten [Seite 210]
9.1 - 7.1 Environment Lighting [Seite 210]
9.2 - 7.2 Lichtarten [Seite 212]
9.2.1 - 7.2.1 Directional Light [Seite 213]
9.2.2 - 7.2.2 Point Light [Seite 214]
9.2.3 - 7.2.3 Spot Light [Seite 215]
9.2.4 - 7.2.4 Area Light [Seite 216]
9.3 - 7.3 Schatten [Seite 217]
9.3.1 - 7.3.1 Einfluss des MeshRenderers auf Schatten [Seite 218]
9.4 - 7.4 Light Cookies [Seite 219]
9.4.1 - 7.4.1 Import Settings eines Light Cookies [Seite 219]
9.4.2 - 7.4.2 Light Cookies und Point Lights [Seite 220]
9.5 - 7.5 Light Halos [Seite 221]
9.5.1 - 7.5.1 Unabhängige Halos [Seite 222]
9.6 - 7.6 Lens Flares [Seite 222]
9.6.1 - 7.6.1 Eigene Lens Flares [Seite 223]
9.7 - 7.7 Projector [Seite 223]
9.7.1 - 7.7.1 Standard Projectors [Seite 223]
9.8 - 7.8 Lightmapping [Seite 225]
9.8.1 - 7.8.1 Light Probes [Seite 228]
9.9 - 7.9 Rendering Paths [Seite 230]
9.9.1 - 7.9.1 Forward Rendering [Seite 231]
9.9.2 - 7.9.2 Vertex Lit [Seite 232]
9.9.3 - 7.9.3 Deferred Lighting [Seite 233]
9.10 - 7.10 Global Illumination [Seite 234]
9.10.1 - 7.10.1 Baked GI [Seite 235]
9.10.2 - 7.10.2 Realtime Lighting [Seite 236]
9.10.3 - 7.10.3 Lightmapping Settings [Seite 237]
9.11 - 7.11 Light Explorer [Seite 238]
9.12 - 7.12 Reflexionen (Spiegelungen) [Seite 239]
9.12.1 - 7.12.1 Reflection Probes [Seite 240]
9.13 - 7.13 Qualitätseinstellungen [Seite 243]
9.13.1 - 7.13.1 Quality Settings [Seite 243]
9.13.2 - 7.13.2 Qualitätsstufen per Code festlegen [Seite 243]
10 - 8 Physik in Unity [Seite 246]
10.1 - 8.1 Physikberechnung [Seite 246]
10.2 - 8.2 Rigidbodies [Seite 247]
10.2.1 - 8.2.1 Rigidbodies kennenlernen [Seite 248]
10.2.2 - 8.2.2 Masseschwerpunkt [Seite 249]
10.2.3 - 8.2.3 Kräfte und Drehmomente zufügen [Seite 250]
10.3 - 8.3 Kollisionen [Seite 253]
10.3.1 - 8.3.1 Collider [Seite 253]
10.3.2 - 8.3.2 Trigger [Seite 257]
10.3.3 - 8.3.3 Static Collider [Seite 259]
10.3.4 - 8.3.4 Kollisionen mit schnellen Objekten [Seite 259]
10.3.5 - 8.3.5 Terrain Collider [Seite 260]
10.3.6 - 8.3.6 Layer-basierende Kollisionserkennung [Seite 260]
10.3.7 - 8.3.7 Mit Layer-Masken arbeiten [Seite 261]
10.4 - 8.4 Wheel Collider [Seite 263]
10.4.1 - 8.4.1 Wheel Friction Curve [Seite 264]
10.4.2 - 8.4.2 Entwicklung einer Fahrzeugsteuerung [Seite 266]
10.4.3 - 8.4.3 Autokonfiguration [Seite 273]
10.4.4 - 8.4.4 Fahrzeugstabilität [Seite 275]
10.5 - 8.5 Physic Materials [Seite 275]
10.6 - 8.6 Joints [Seite 276]
10.6.1 - 8.6.1 Fixed Joint [Seite 276]
10.6.2 - 8.6.2 Spring Joint [Seite 277]
10.6.3 - 8.6.3 Hinge Joint [Seite 277]
10.7 - 8.7 Raycasting [Seite 277]
10.8 - 8.8 Character Controller [Seite 279]
10.8.1 - 8.8.1 SimpleMove [Seite 279]
10.8.2 - 8.8.2 Move [Seite 280]
10.8.3 - 8.8.3 Kräfte zufügen [Seite 281]
10.8.4 - 8.8.4 Einfacher First Person Controller [Seite 282]
10.9 - 8.9 2D-Physik [Seite 284]
10.9.1 - 8.9.1 OnCollision2D- und OnTrigger2D-Methoden [Seite 286]
10.9.2 - 8.9.2 2D Physic Effectors [Seite 287]
11 - 9 Maus, Tastatur, Touch [Seite 290]
11.1 - 9.1 Virtuelle Achsen und Tasten [Seite 290]
11.1.1 - 9.1.1 Der Input-Manager [Seite 290]
11.1.2 - 9.1.2 Virtuelle Achsen [Seite 292]
11.1.3 - 9.1.3 Virtuelle Tasten [Seite 292]
11.1.4 - 9.1.4 Steuern mit Mauseingaben [Seite 293]
11.1.5 - 9.1.5 Joystick-Inputs [Seite 293]
11.1.6 - 9.1.6 Anlegen neuer Inputs [Seite 294]
11.2 - 9.2 Achsen- und Tasteneingaben auswerten [Seite 294]
11.2.1 - 9.2.1 GetAxis [Seite 294]
11.2.2 - 9.2.2 GetButton [Seite 295]
11.3 - 9.3 Tastatureingaben auswerten [Seite 296]
11.3.1 - 9.3.1 GetKey [Seite 296]
11.3.2 - 9.3.2 anyKey [Seite 296]
11.4 - 9.4 Mauseingaben auswerten [Seite 297]
11.4.1 - 9.4.1 GetMouseButton [Seite 297]
11.4.2 - 9.4.2 Mauseingaben auf Objekten per Event [Seite 298]
11.4.3 - 9.4.3 mousePosition [Seite 298]
11.4.4 - 9.4.4 Mauszeiger ändern [Seite 299]
11.5 - 9.5 Touch-Eingaben auswerten [Seite 301]
11.5.1 - 9.5.1 Der Touch-Typ [Seite 301]
11.5.2 - 9.5.2 Input.touches [Seite 302]
11.5.3 - 9.5.3 TouchCount [Seite 302]
11.5.4 - 9.5.4 GetTouch [Seite 302]
11.5.5 - 9.5.5 CrossPlatformInput [Seite 303]
11.6 - 9.6 Beschleunigungssensor auswerten [Seite 304]
11.6.1 - 9.6.1 Input.acceleration [Seite 305]
11.6.2 - 9.6.2 Tiefpass-Filter [Seite 306]
11.7 - 9.7 Steuerungen bei Mehrspieler-Games [Seite 307]
11.7.1 - 9.7.1 Split-Screen-Steuerung [Seite 307]
11.7.2 - 9.7.2 Netzwerkspiele [Seite 308]
12 - 10 Audio [Seite 310]
12.1 - 10.1 AudioListener [Seite 310]
12.2 - 10.2 AudioSource [Seite 311]
12.2.1 - 10.2.1 Durch Mauern hören verhindern [Seite 313]
12.2.2 - 10.2.2 Sound starten und stoppen [Seite 315]
12.2.3 - 10.2.3 Temporäre AudioSource [Seite 316]
12.3 - 10.3 AudioClip [Seite 317]
12.3.1 - 10.3.1 Länge ermitteln [Seite 317]
12.4 - 10.4 Reverb Zone [Seite 317]
12.5 - 10.5 Filter [Seite 319]
12.6 - 10.6 Audio Mixer [Seite 319]
12.6.1 - 10.6.1 Das Audio Mixer-Fenster [Seite 319]
12.6.2 - 10.6.2 Audiosignalwege [Seite 323]
12.6.3 - 10.6.3 Mit Snapshots arbeiten [Seite 327]
12.6.4 - 10.6.4 Views erstellen [Seite 328]
12.6.5 - 10.6.5 Parameter per Skript bearbeiten [Seite 328]
13 - 11 Partikeleffekte mit Shuriken [Seite 332]
13.1 - 11.1 Editor-Fenster [Seite 333]
13.2 - 11.2 Particle Effect Control [Seite 334]
13.3 - 11.3 Numerische Parametervarianten [Seite 334]
13.4 - 11.4 Farbparameter-Varianten [Seite 335]
13.5 - 11.5 Default-Modul [Seite 335]
13.6 - 11.6 Effekt-Module [Seite 337]
13.6.1 - 11.6.1 Emission [Seite 337]
13.6.2 - 11.6.2 Shape [Seite 337]
13.6.3 - 11.6.3 Velocity over Lifetime [Seite 339]
13.6.4 - 11.6.4 Limit Velocity over Lifetime [Seite 339]
13.6.5 - 11.6.5 Inherit Velocity [Seite 340]
13.6.6 - 11.6.6 Force over Lifetime [Seite 340]
13.6.7 - 11.6.7 Color over Lifetime [Seite 340]
13.6.8 - 11.6.8 Color by Speed [Seite 341]
13.6.9 - 11.6.9 Size over Lifetime [Seite 341]
13.6.10 - 11.6.10 Size by Speed [Seite 341]
13.6.11 - 11.6.11 Rotation over Lifetime [Seite 341]
13.6.12 - 11.6.12 Rotation by Speed [Seite 342]
13.6.13 - 11.6.13 External Forces [Seite 342]
13.6.14 - 11.6.14 Noise [Seite 342]
13.6.15 - 11.6.15 Collision [Seite 343]
13.6.16 - 11.6.16 Triggers [Seite 344]
13.6.17 - 11.6.17 Sub Emitter [Seite 346]
13.6.18 - 11.6.18 Texture-Sheet-Animation [Seite 346]
13.6.19 - 11.6.19 Lights [Seite 347]
13.6.20 - 11.6.20 Trails [Seite 347]
13.6.21 - 11.6.21 Renderer [Seite 348]
13.7 - 11.7 Partikelemission starten, stoppen und unterbrechen [Seite 350]
13.7.1 - 11.7.1 Play [Seite 351]
13.7.2 - 11.7.2 Stop [Seite 351]
13.7.3 - 11.7.3 Pause [Seite 351]
13.7.4 - 11.7.4 enableEmission [Seite 351]
13.8 - 11.8 OnParticleCollision [Seite 352]
13.8.1 - 11.8.1 GetCollisionEvents [Seite 352]
13.9 - 11.9 Feuer erstellen [Seite 353]
13.9.1 - 11.9.1 Materials erstellen [Seite 353]
13.9.2 - 11.9.2 Feuer-Partikelsystem [Seite 354]
13.9.3 - 11.9.3 Rauch-Partikelsystem [Seite 357]
13.10 - 11.10 Wassertropfen erstellen [Seite 361]
13.10.1 - 11.10.1 Tropfen-Material erstellen [Seite 361]
13.10.2 - 11.10.2 Wassertropfen-Partikelsystem [Seite 362]
13.10.3 - 11.10.3 Kollisionspartikelsystem [Seite 364]
13.10.4 - 11.10.4 Kollisionssound [Seite 366]
14 - 12 Landschaften gestalten [Seite 368]
14.1 - 12.1 Was Terrains können und wo die Grenzen liegen [Seite 369]
14.2 - 12.2 Terrainhöhe verändern [Seite 369]
14.2.1 - 12.2.1 Pinsel [Seite 370]
14.2.2 - 12.2.2 Oberflächen anheben und senken [Seite 370]
14.2.3 - 12.2.3 Plateaus und Schluchten erstellen [Seite 371]
14.2.4 - 12.2.4 Oberflächen weicher machen [Seite 372]
14.2.5 - 12.2.5 Heightmaps [Seite 372]
14.3 - 12.3 Terrain texturieren [Seite 374]
14.3.1 - 12.3.1 Textur-Pinsel [Seite 375]
14.3.2 - 12.3.2 Texturen verwalten [Seite 375]
14.4 - 12.4 Bäume und Sträucher [Seite 377]
14.4.1 - 12.4.1 Bedienung des Place Tree-Tools [Seite 378]
14.4.2 - 12.4.2 Wälder erstellen [Seite 378]
14.4.3 - 12.4.3 Mit Bäumen kollidieren [Seite 378]
14.5 - 12.5 Gräser und Details hinzufügen [Seite 379]
14.5.1 - 12.5.1 Detail-Meshs [Seite 380]
14.5.2 - 12.5.2 Gräser [Seite 381]
14.5.3 - 12.5.3 Quelldaten nachladen [Seite 381]
14.6 - 12.6 Terrain-Einstellungen [Seite 382]
14.6.1 - 12.6.1 Base Terrain [Seite 382]
14.6.2 - 12.6.2 Resolution [Seite 382]
14.6.3 - 12.6.3 Tree & Details Objects [Seite 383]
14.6.4 - 12.6.4 Wind Settings [Seite 383]
14.6.5 - 12.6.5 Zur Laufzeit Terrain-Eigenschaften verändern [Seite 384]
14.7 - 12.7 Der Weg zum perfekten Terrain [Seite 385]
14.8 - 12.8 Gewässer [Seite 386]
15 - 13 Wind Zones [Seite 388]
15.1 - 13.1 Spherical vs. Directional [Seite 389]
15.2 - 13.2 Wind Zone - Eigenschaften [Seite 390]
15.3 - 13.3 Frische Brise [Seite 391]
15.4 - 13.4 Turbine [Seite 391]
16 - 14 GUI [Seite 392]
16.1 - 14.1 Das UI-System uGUI [Seite 393]
16.1.1 - 14.1.1 Canvas [Seite 393]
16.1.2 - 14.1.2 RectTransform [Seite 397]
16.1.3 - 14.1.3 UI-Sprite Import [Seite 401]
16.1.4 - 14.1.4 Grafische Controls [Seite 402]
16.1.5 - 14.1.5 Interaktive Controls [Seite 406]
16.1.6 - 14.1.6 Controls designen [Seite 413]
16.1.7 - 14.1.7 Animationen in uGUI [Seite 414]
16.1.8 - 14.1.8 Event Trigger [Seite 415]
16.2 - 14.2 Screen-Klasse [Seite 416]
16.2.1 - 14.2.1 Schriftgröße dem Bildschirm anpassen [Seite 416]
16.3 - 14.3 OnGUI-Programmierung [Seite 417]
16.3.1 - 14.3.1 GUI [Seite 418]
16.3.2 - 14.3.2 GUILayout [Seite 420]
16.3.3 - 14.3.3 GUIStyle und GUISkin [Seite 421]
17 - 15 Prefabs [Seite 424]
17.1 - 15.1 Prefabs erstellen und nutzen [Seite 424]
17.2 - 15.2 Prefab-Instanzen erzeugen [Seite 424]
17.2.1 - 15.2.1 Instanzen per Code erstellen [Seite 425]
17.2.2 - 15.2.2 Instanzen weiter bearbeiten [Seite 426]
17.3 - 15.3 Prefabs ersetzen und zurücksetzen [Seite 426]
17.4 - 15.4 Prefab-Verbindungen auflösen [Seite 427]
18 - 16 Internet und Datenbanken [Seite 428]
18.1 - 16.1 Die WWW-Klasse [Seite 428]
18.1.1 - 16.1.1 Rückgabewert-Formate [Seite 429]
18.1.2 - 16.1.2 Parameter übergeben [Seite 430]
18.2 - 16.2 Datenbank-Kommunikation [Seite 431]
18.2.1 - 16.2.1 Daten in einer Datenbank speichern [Seite 431]
18.2.2 - 16.2.2 Daten von einer Datenbank abfragen [Seite 432]
18.2.3 - 16.2.3 Rückgabewerte parsen [Seite 434]
18.2.4 - 16.2.4 Datenhaltung in eigenen Datentypen [Seite 435]
18.2.5 - 16.2.5 HighscoreCommunication.cs [Seite 437]
18.2.6 - 16.2.6 Datenbankverbindung in PHP [Seite 438]
19 - 17 Animationen [Seite 440]
19.1 - 17.1 Allgemeiner Animation-Workflow [Seite 441]
19.2 - 17.2 Animationen erstellen [Seite 441]
19.2.1 - 17.2.1 Animation View [Seite 442]
19.2.2 - 17.2.2 Curves vs. Dope Sheet [Seite 443]
19.2.3 - 17.2.3 Animationsaufnahme [Seite 443]
19.2.4 - 17.2.4 Beispiel Fallgatter-Animation [Seite 448]
19.3 - 17.3 Animationen importieren [Seite 449]
19.3.1 - 17.3.1 Rig [Seite 450]
19.3.2 - 17.3.2 Animationen [Seite 452]
19.4 - 17.4 Animationen einbinden [Seite 455]
19.4.1 - 17.4.1 Animator Controller [Seite 456]
19.4.2 - 17.4.2 Animator-Komponente [Seite 471]
19.4.3 - 17.4.3 Beispiel Fallgatter: Animator Controller [Seite 472]
19.5 - 17.5 Controller-Skripte [Seite 474]
19.5.1 - 17.5.1 Parameter des Animator Controllers setzen [Seite 475]
19.5.2 - 17.5.2 Animation States abfragen [Seite 475]
19.5.3 - 17.5.3 Beispiel Fallgatter Controller-Skript [Seite 476]
19.6 - 17.6 Animation Events [Seite 478]
19.7 - 17.7 Das "alte" Animationssystem [Seite 479]
20 - 18 Künstliche Intelligenz [Seite 482]
20.1 - 18.1 NavMeshAgent [Seite 483]
20.1.1 - 18.1.1 Eigenschaften der Navigationskomponente [Seite 484]
20.1.2 - 18.1.2 Zielpunkt zuweisen [Seite 485]
20.1.3 - 18.1.3 Pfadsuche unterbrechen und fortsetzen [Seite 485]
20.2 - 18.2 Navigation-Fenster [Seite 486]
20.2.1 - 18.2.1 Agents Tab [Seite 487]
20.2.2 - 18.2.2 Object Tab [Seite 488]
20.2.3 - 18.2.3 Bake Tab [Seite 488]
20.2.4 - 18.2.4 Areas Tab [Seite 489]
20.3 - 18.3 NavMeshObstacle [Seite 490]
20.4 - 18.4 Off-Mesh Link [Seite 491]
20.4.1 - 18.4.1 Automatische Off-Mesh Links [Seite 491]
20.4.2 - 18.4.2 Manuelle Off-Mesh Links [Seite 492]
20.5 - 18.5 Point & Click-Steuerung für Maus und Touch [Seite 493]
21 - 19 Fehlersuche und Performance [Seite 496]
21.1 - 19.1 Fehlersuche [Seite 496]
21.1.1 - 19.1.1 Breakpoints [Seite 497]
21.1.2 - 19.1.2 Variablen beobachten [Seite 498]
21.1.3 - 19.1.3 Console Tab nutzen [Seite 499]
21.1.4 - 19.1.4 GUI- und GUILayout nutzen [Seite 499]
21.1.5 - 19.1.5 Fehlersuche bei mobilen Plattformen [Seite 500]
21.2 - 19.2 Performance [Seite 502]
21.2.1 - 19.2.1 Rendering-Statistik [Seite 503]
21.2.2 - 19.2.2 Batching-Verfahren [Seite 504]
21.2.3 - 19.2.3 Analyse mit dem Profiler [Seite 505]
21.2.4 - 19.2.4 Echtzeit-Analyse auf Endgeräten [Seite 507]
22 - 20 Spiele erstellen und publizieren [Seite 510]
22.1 - 20.1 Der Build-Prozess [Seite 510]
22.1.1 - 20.1.1 Szenen des Spiels [Seite 511]
22.1.2 - 20.1.2 Plattformen [Seite 512]
22.1.3 - 20.1.3 Notwendige SDKs [Seite 512]
22.1.4 - 20.1.4 Plattformspezifische Optionen [Seite 513]
22.1.5 - 20.1.5 Developer Builds [Seite 513]
22.2 - 20.2 Publizieren [Seite 514]
22.2.1 - 20.2.1 App [Seite 515]
22.2.2 - 20.2.2 Browser-Game [Seite 515]
22.2.3 - 20.2.3 Desktop-Anwendung [Seite 516]
23 - 21 Erstes Beispiel-Game: 2D-Touch-Game [Seite 518]
23.1 - 21.1 Projekt und Szene [Seite 518]
23.1.1 - 21.1.1 Die Kamera [Seite 520]
23.1.2 - 21.1.2 Texturen importieren und Sprites definieren [Seite 521]
23.2 - 21.2 Gespenster und Hintergrund [Seite 523]
23.2.1 - 21.2.1 Gespenster animieren [Seite 526]
23.2.2 - 21.2.2 Gespenster laufen lassen [Seite 530]
23.2.3 - 21.2.3 Gespenster-Prefab erstellen [Seite 532]
23.3 - 21.3 Der GameController [Seite 533]
23.3.1 - 21.3.1 Der Spawner [Seite 533]
23.3.2 - 21.3.2 Level-Anzeige [Seite 535]
23.3.3 - 21.3.3 Der Input-Controller [Seite 536]
23.3.4 - 21.3.4 Game Over-UI [Seite 538]
23.3.5 - 21.3.5 Hintergrundmusik [Seite 545]
23.4 - 21.4 Punkte zählen [Seite 546]
23.5 - 21.5 Spielende [Seite 547]
23.6 - 21.6 Spiel erstellen [Seite 548]
24 - 22 Zweites Beispiel-Game: 3D Dungeon Crawler [Seite 550]
24.1 - 22.1 Level-Design [Seite 551]
24.1.1 - 22.1.1 Modellimport [Seite 552]
24.1.2 - 22.1.2 Materials konfigurieren [Seite 553]
24.1.3 - 22.1.3 Prefabs erstellen [Seite 554]
24.1.4 - 22.1.4 Dungeon erstellen [Seite 556]
24.1.5 - 22.1.5 Dekoration erstellen [Seite 561]
24.2 - 22.2 Inventarsystem erstellen [Seite 563]
24.2.1 - 22.2.1 Verwaltungslogik [Seite 563]
24.2.2 - 22.2.2 Oberfläche des Inventarsystems [Seite 571]
24.2.3 - 22.2.3 Inventar-Items [Seite 574]
24.3 - 22.3 Game Controller [Seite 581]
24.4 - 22.4 Spieler erstellen [Seite 581]
24.4.1 - 22.4.1 Lebensverwaltung [Seite 583]
24.4.2 - 22.4.2 Spielersteuerung [Seite 594]
24.4.3 - 22.4.3 Wurfstein entwickeln [Seite 602]
24.4.4 - 22.4.4 Lautstärke steuern [Seite 608]
24.5 - 22.5 Quest erstellen [Seite 609]
24.5.1 - 22.5.1 Erfahrungspunkte verwalten [Seite 609]
24.5.2 - 22.5.2 Questgeber erstellen [Seite 611]
24.5.3 - 22.5.3 Sub-Quest erstellen [Seite 620]
24.6 - 22.6 Gegner erstellen [Seite 625]
24.6.1 - 22.6.1 Model-, Rig- und Animationsimport [Seite 625]
24.6.2 - 22.6.2 Komponenten und Prefab konfigurieren [Seite 626]
24.6.3 - 22.6.3 Animator Controller erstellen [Seite 628]
24.6.4 - 22.6.4 NavMesh erstellen [Seite 630]
24.6.5 - 22.6.5 Umgebung und Feinde erkennen [Seite 631]
24.6.6 - 22.6.6 Gesundheitszustand verwalten [Seite 634]
24.6.7 - 22.6.7 Künstliche Intelligenz entwickeln [Seite 638]
24.7 - 22.7 Eröffnungsszene [Seite 647]
24.7.1 - 22.7.1 Szene erstellen [Seite 647]
24.7.2 - 22.7.2 Startmenü-Logik erstellen [Seite 648]
24.7.3 - 22.7.3 Menü-GUI erstellen [Seite 650]
24.8 - 22.8 WebGL-Anpassungen [Seite 652]
24.8.1 - 22.8.1 WebGL-Input ändern [Seite 652]
24.8.2 - 22.8.2 Quit-Methode in WebGL abfangen [Seite 653]
24.9 - 22.9 Finale Einstellungen [Seite 654]
24.10 - 22.10 So könnte es weitergehen [Seite 657]
25 - 23 Der Produktionsprozess in der Spieleentwicklung [Seite 658]
25.1 - 23.1 Die Produktionsphasen [Seite 658]
25.1.1 - 23.1.1 Ideen- und Konzeptionsphase [Seite 659]
25.1.2 - 23.1.2 Planungsphase [Seite 659]
25.1.3 - 23.1.3 Entwicklungsphase [Seite 659]
25.1.4 - 23.1.4 Testphase [Seite 660]
25.1.5 - 23.1.5 Veröffentlichung und Postproduktion [Seite 660]
25.2 - 23.2 Das Game-Design-Dokument [Seite 660]
26 - 24 Schlusswort [Seite 662]
27 - Index [Seite 664]
01 Einleitung

Computerspiele gehören heutzutage zu den beliebtesten Freizeitgestaltungen unserer Zeit. Mit Zunahme der Popularität ist aber auch der Anspruch an diese Spiele gestiegen. Während in den ersten Jahren bis Jahrzehnten dieser jungen Branche noch ein einziger Programmierer ausreichte, um alle notwendigen Aufgaben zu erledigen, werden anspruchsvolle Computerspiele heutzutage meist von großen Teams umgesetzt. Hier arbeiten 3D-Modellierer, Grafiker, Sounddesigner, Level-Designern und natürlich auch Programmierer aus unterschiedlichen Sparten Hand in Hand.

Um den stetig wachsenden Ansprüchen zu genügen, sind aber auch die Werkzeuge der Entwickler ständig mitgewachsen. Eines dieser Werkzeuge ist Unity. Unity ist eine Spieleentwicklungsumgebung für Windows- und Mac OS X-Systeme und wird von der aus Dänemark stammenden Firma Unity Technologies entwickelt. Mit ihr können Sie sowohl interaktive 3D- als auch 2D-Inhalte erstellen. Wir sprechen deshalb von Inhalten und nicht nur von Spielen, weil Unity zwar eigentlich für die Entwicklung von 3D-Spielen gedacht war, mittlerweile aber auch immer häufiger Anwendung in anderen Bereichen findet. So wird es beispielsweise für Architekturvisualisierungen genutzt, im E-Learning-Bereich eingesetzt oder in der Digital-Signage-Branche für das Erstellen digitaler Werbe- und Informationssysteme genommen.

Da Unity ursprünglich für die Entwicklung von 3D-Spielen konzipiert wurde, lautet die Internet-Adresse der Firma unity3d.com. Dies ist der Grund, weshalb die Entwicklungssoftware auch gerne mal "Unity3D" genannt wird, was aber eben nicht ganz korrekt ist.

1.1 Multiplattform-Publishing

Eine besondere Stärke von Unity ist die Unterstützung von Multiplattform-Publishing. Das bedeutet, dass Sie in Unity ein Spiel einmal entwickeln können, das Sie dann aber für mehrere Plattformen exportieren können. Aktuell werden mehr als 25 Plattformen unterstützt, die sich grob in folgende Kategorien einteilen lassen:

  • Die sogenannten "Standalones". Hierzu gehören: Windows Desktop, Mac, Linux (und Steam OS)

  • Die mobilen Smartphone-/Tablet-Plattformen: iOS, Android, Windows Phone, Fire OS

  • Die Spielekonsolen: PlayStation 4, PlayStation Vita, Xbox One, Nintendo Switch, Wii U, Nintendo 3DS

  • Die Kategorie "Smart-TV". Hier werden folgende Systeme unterstützt: AndroidTV, Samsung SMART-TV, tvOS

In Verbindung mit diesen Plattformen bietet Unity die Möglichkeit, Inhalte direkt für verschiedene Virtual-Reality-Systeme zu entwickeln. Hierzu gehören: Occulus-Rift, Google-Cardboard, Steam-VR, Playstation-VR, Gear-VR, Microsoft Hololens und Daydream.

Auch für Web-Inhalte bietet Unity entsprechende Features. Mit der Plattform "WebGL", die im Browser läuft und auf HTML5 basiert, können Sie Nutzern direkten Zugriff auf Ihre Inhalte geben.

Bei den erwähnten Spielekonsolen müssen Sie allerdings noch eine Einschränkung beachten: Sie müssen hier extra Lizenzen erwerben, die zum einen nicht günstig und zum anderen nur für Firmen verfügbar sind, die von den jeweiligen Konsolenherstellern auch als Entwickler akzeptiert wurden. Deshalb werden wir die Konsolenentwicklung in diesem Buch auch außen vor lassen und nicht näher beleuchten.

1.2 Das kann Unity (nicht)

Unity bringt eine ganze Reihe an nützlichen Werkzeugen mit, um Spiele und andere 2D- und 3D-Anwendungen zu entwickeln. So gibt es neben einer ausgeklügelten Physik-Engine auch Tools für Partikeleffekte, zur Landschaftsgestaltung oder auch für Animationen. Außerdem wird Unity mit einer extra angepassten Version der Softwareentwicklungsumgebung MonoDevelop ausgeliefert, in der die Programmierung umgesetzt und das Debugging vorgenommen werden kann.

Eines ist Unity allerdings nicht: Es ist keine 3D-Modellierungssoftware. Unity bietet zwar von Haus aus einige 3D-Grundobjekte an, sogenannte Primitives, die für kleinere Aufgaben genutzt werden können, aber für richtige Modellierungsaufgaben sollten Sie auf die dafür entwickelten Spezialtools wie 3ds Max oder das kostenlose Blender zurückgreifen.

1.3 Lizenzmodelle

Sie haben die Möglichkeit, auf verschiedene Modelle zurückzugreifen, wenn Sie Unity nutzen möchten. Zum eine gibt es eine komplett kostenfreie Variante, welche bereits alle oben genannten Zielplattformen unterstützt und eine komplette Spieleentwicklung bis hin zum fertigen Spiel erlaubt. Es gibt jedoch auch einige Einschränkungen, die sich allerdings nur auf erweiterte oder visuelle Features beziehen. So müssen Sie zum Beispiel auf die dunkle Oberfläche (Skin) Ihres Unity-Programms verzichten oder haben auch keinen Zugriff auf den Premium-Support von Unity.

Bei der kostenpflichtigen Variante unterscheidet man die drei Abo-Modelle "Plus", "Pro" und "Enterprise", welche jeweils monatlich zu bezahlen sind. Je teurer das Abo ist, umso mehr Funktionen stehen zur Verfügung.

Da sowohl die kostenfreie als auch die kostenpflichtige Edition kommerziell genutzt werden darf, gibt es beim Einsatz der kostenlosen Version die Vorgabe, dass nur Firmen bzw. Entwickler diese einsetzen dürfen, die nicht mehr als 100.000 US-Dollar Umsatz in einem Geschäftsjahr machen.

1.4 Aufbau und Ziel des Buches

Mit diesem Buch werden Sie lernen, auf Basis von Unity eigene 2D- und 3D-Spiele zu entwickeln. Sie werden sich mit den unterschiedlichen Tools der Game Engine vertraut machen und die Skript-Programmierung erlernen. Dabei steht aber nicht das Ziel im Fokus, wirklich jede einzelne Funktion und Möglichkeit zu beleuchten, die Unity dem Entwickler anbietet. Vielmehr zeigen wir Ihnen, wie die unterschiedlichen Bereiche von Unity funktionieren und miteinander zusammenarbeiten. Denn der Funktionsumfang dieser Spieleentwicklungsumgebung ist mittlerweile so umfangreich geworden, dass es gar nicht mehr möglich ist, alle Tools und deren Möglichkeiten bis ins letzte Detail in einem einzigen Buch ausführlich zu behandeln. Daher liegt der Schwerpunkt auf den Kernfunktionen und wichtigen Optimierungstechniken, die in Unity für die 2D- und 3D-Spieleentwicklung bereitgestellt werden, ergänzt um Anwendungsbeispiele und Praxistipps.

Möchten Sie weiter in die Tiefe eines speziellen Tools gehen oder mehr Informationen zu bestimmten Scripting-Klassen erhalten, empfehlen wir Ihnen die mit Unity mitgelieferten Hilfe-Dokumente, die Sie über das Help-Menü erreichen. Dort finden Sie sowohl ein ausführliches Manual über die in Unity integrierten Tools sowie eine Scripting-Referenz über alle Unity-Klassen und deren Möglichkeiten. Letztere finden Sie auch über die Hilfe von MonoDevelop, der mitgelieferten Programmierumgebung.

Spieleentwicklung wird häufig auch als Spieleprogrammierung bezeichnet, auch wenn viele Aufgaben in der Spieleentwicklung heutzutage nicht mehr programmiert, sondern mithilfe von Tools erledigt werden. Nichtsdestotrotz ist der Programmieranteil bei der Entwicklung eines Spiels doch immer noch sehr hoch. Deshalb wird auch das Buch zunächst mit zwei größeren programmierbezogenen Kapiteln beginnen. Das erste behandelt allgemeine Grundlagen der Programmierung, das zweite geht auf die Unity-spezifischen Themen ein. Erst danach werden wir in die 3D-Welt von Unity eintauchen und die verschiedenen Werkzeuge behandeln. Der Aufbau ist deshalb so gewählt, weil wir in den folgenden Kapiteln immer wieder kleinere Skript-Beispiele zeigen, die Einsatzmöglichkeiten in der Praxis demonstrieren.

Ganz grundsätzlich ist die Reihenfolge der einzelnen Kapitel so gewählt, dass die Inhalte aufeinander aufbauen. Aus diesem Grund kommen auch erst zum Ende des Buches die beiden Beispiel-Games, eines für 2D und eines für 3D. In diesen werden alle angesprochenen Themen noch einmal aufgegriffen und die gesamten Zusammenhänge in der Praxis gezeigt. Nichtsdestotrotz können Sie gerne diese Kapitel auch vorziehen. Speziell das 2D-Spiel eignet sich hierfür gut.

Im Buch werden wir Hinweiskästen, wie den obigen, einsetzen, um Hinweise und Tipps zu geben. Je nach Typ des Hinweises werden diese mit unterschiedlichen Icons ausgezeichnet.

Hinweise zu weiterführenden Inhalten im InternetPraxistippsAllgemeine Hinweise

1.5 Weiterentwicklung von Unity

Die Spieleindustrie gehört zu den Branchen, die sich aktuell am schnellsten verändern. Kein Wunder also, dass auch Unity ständig weiterentwickelt wird und neue Funktionen erhält. Sollten Sie Unterschiede zwischen dem Buch und Ihrer Unity-Version erkennen, wird dies sicher der ständigen Weiterentwicklung von Unity geschuldet sein.

Aber nicht nur der Funktionsumfang wird ständig weiterentwickelt, auch das Lizenzmodell von...

Dateiformat: EPUB
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie eine Lese-Software, die das Dateiformat EPUB verarbeiten kann: z.B. Adobe Digital Editions oder FBReader - beide kostenlos (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat EPUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.

Inhalt (1) (PDF)
Inhalt (2) (PDF)

Download (sofort verfügbar)

31,99 €
inkl. 19% MwSt.
Download / Einzel-Lizenz
ePUB mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters
E-Book bestellen

Unsere Web-Seiten verwenden Cookies. Mit der Nutzung dieser Web-Seiten erklären Sie sich damit einverstanden. Mehr Informationen finden Sie in unserem Datenschutzhinweis. Ok