Lerne Spiellogik mit C# in Unity umzusetzen, DEM weltweiten Industrie-Standard für Videospiel-Produktion.

In diesem Kurs lernst Du Spielregeln und Interaktionsabläufe in C# auszudrücken und in Kombination mit Unitys UI-Grafiksystem Deine eigenen Computerspiele zu produzieren. Wir setzen in diesem Kurs Kartenspiele um und programmieren Regelwerke für Tarot, Patience, Klondike und MauMau. Das Wissen, das Du während der Umsetzung dieser Spiele gewinnst, ist so aufbereitet, dass es sich auch auf andere Spielkonzepte übertragen lässt.

Der Kurs zielt darauf ab, die Funktionsweise von Unity so zu erklären, dass sie für Anfänger leicht zu verstehen sind. Für Einsteiger, die schonmal mit Unity experimentiert haben, ist dieser Kurs eine idealeGelegenheit, um das technische Verständnis von Unitys Funktionsweise und der Programmierung in C# zu vertiefen und zu trainieren.

DAS WIRST DU LERNEN:

• Unitys UI-System zur Darstellung von Spielobjekten nutzen

• Spielbrett, Karten und Kartenstapel realisieren

• Karten zeigen und/oder verdecken

• Spielkarte per Zeitleiste und Code animiert umdrehen

• Aufbau einer Spielobjektbibliothek und Wiederverwendung von Prefabs

• Kartenstapel als Liste von Karten realisieren

• Ziehen einer bestimmten oder zufälligen Karte, Mischen des Stapels, Zurücklegen einer Karte

• Gezogene Karten durch per Script auf den Tisch legen

• Unterschiedliche Spiele auf Szenen verteilen, Gemeinsamkeiten dabei wiederverwenden

• Menü zum Szenenwechsel zentral einbauen

• Beschränken von Spielzügen

• Legen von vorgegebenen Formationen

• Status-Texte, Gewonnen/Verloren-Dialoge und Hilfestellungen anzeigen

• Karten im Stock duplizieren

• einen oder mehrere Kartenablageplätze auf dem Tisch ermöglichen

• Karten mit eigenen Layout-Funktionen anordnen

• Farbe undWert einer Karte definieren und per Code verarbeiten

• Konkrete Beispiele für Rechenwege um Karten zu vergleichen

• Realisierung von Kartenspielregeln

• Eine oder mehrere Karten per Drag&Drop mit der Maus verschieben, Anzeige des Bilds am Mauszeiger (Ghost)

• Kartensatz in der Hand des Spielers anlegen

• Einen oder mehrere Computergegner für MauMau programmieren

• Spielrunden umsetzen

• ...
  
  

UND AUßERDEM LERNST DU DIESE ESSENTIELLEN C#-KONZEPTE KENNEN:

• Vorgehen zur selbständigen Fehlersuche und Problemanalyse

• Funktionen an Animationszeitpunkten aufrufen

• Trennung von Darstellungscode, Spiellogik und Kartenwerten

• Code-Organisation in Modulen, Trennung von Unterschieden, Zentralisierung von Gemeinsamkeiten

• Unity-Funktionen oder eigene Methoden an UI-Ereignisse binden, per Inspector sowie auch per Code

• Delegaten und Callbacks schreiben

• Verändern der Text-Konvertierung von C#-Objekten

• mit Timern und Coroutinen Abläufe programmieren

• Code nur per EventSystem-Interfaces in den Spielfluss integrieren

• Entwickler-Cheats für schnelles Testen einbauen

• Klassen-Hierarchien und Vererbung

• Objekte nach Klasse unterscheiden

• Spielparteien realisieren

• ...

Erweiterung des Unity-Editors:

• Grundlagen der Editor-Erweiterung

• Auslesen der im Editor markierten Assets

• Sprites erkennen, suchen und in die Kartenliste des Kartenstapels eintragen

• Kartenwerte vom Dateinamen ableiten

• ...

Typische Fehler, ihre Analyse und Behebung:

• Index out of Range

• Null Reference Exception

• Out of Memory

• Can not convert from method group

• Can't remove RectTransform

• Eingabe-Fokus vs. Tastenauswertung

• ...

DAS SETZEN WIR IN DIESEM KURS KONKRET UM:

• Ein Projekt mit verschiedenen Kartenspielen, je als separate Szenen

• Menü über das der Spieler zwischen den Kartenspielen wechseln kann

• Tarot: Kleines Kreuz

  · Es werden 4 zufällige Karten aus dem Kartenstapel gezogen.

  · Die Karten werden in bestimmter Reihenfolge auf vorgegebene Ablageplätze der Formation "Kleines Kreuz"gelegt.

  · Jedem Platz ist eine Bedeutung zugeordnet, die die Interpretation der Karte beeinflusst.

• Paare finden

  · Jedes Kartenbild liegt zweimal im Kartenstapel.

  · Die Karten werden alle gleichzeitig verdeckt ausgelegt.

  · Der Spieler dreht zwei Karten um. Sind sie identisch, werden sie vom Tisch genommen. Sind sie unterschiedlich, werden beide wieder verdeckt.

  · Ziel ist es, alle Paare zu finden.

• Minimale Patience

  · Aus dem verdeckten und gemischten Kartenstock zieht der Spieler eine Karte.

  · Die Karte kann in eine von vier Ablagespalten platziert werden.

  · Ist die Spalte leer, ist nur ein Ass platzierbar.

  · Liegen Karten in der Spalte kann nur eine Karte mit umgekehrter Farbe (rot auf schwarz) und dem nächst niedrigen Wert (9 auf 10) abgelegt werden.

  · Ist keine Ablage möglich, wandert die Karte nach unten zurück in den Stapel und die nächste obere Stapelkarte wird gezogen.

  · Ziel ist es, alle Karten abzulegen.

• Klondike- Patience

  Wie Minimale Patience, aber mit folgender Erweiterung:

  · Es stehen sieben Ablagespalten zur Verfügung.

  · Zu Beginn werden die sieben Spalten mit Karten befüllt. Dabei enthält jede Spalte eine Karte mehr als die vorherige. In der ersten Spalte liegt eine Karte, in der zweiten zwei, in der dritten drei, usw. Nur die oberste Karte jeder Spalte ist aufgedeckt.

  · Übrige Karten verbleiben im Stock von dem jeweils die oberste umgedreht und ins Spiel eingebracht werden kann.

  · Nur aufgedeckte Karten sind spielbar. Eine verdeckte Karte wird automatisch umgedreht, wenn sie die oberste Karte in der Spalte ist.

  · Um verdeckte Karten zu erreichen, ist es möglich, bereits gelegte Kartenserien zwischen den Stapeln zu bewegen, sofern die Ablage gemäß den Patience-Regeln erlaubt ist.

  · Zudem stehen vier Endablagestapel bereit. Das Spiel ist gewonnen, wenn alle Karten einer Farbe (z.B. Herz) in umgekehrter Reihenfolge (2 als erstes, Ass als letztes) auf den vier Endablagestapeln liegen.

• Mau-Mau
  · Der Spieler spielt gegen einen oder mehrere Computergegner.

  · Aus dem gemischten Kartenstapel erhält jeder Spieler fünf Karten. Eine weitere Karte wird offen auf den Tisch ausgelegt.

  · Abwechselnd darf jeder Spieler eine Karte ablegen. Eine Karte passt auf eine andere Karte, wenn die gewählte Karte und die bereits liegende Karte die gleiche Farbe oder den gleichen Wert haben.

  · Hat der Spieler keine passende Karte, kann einmal pro Runde eine Karte vom Stock aufgenommen werden. Passt sie, kann sie abgelegt werden. Passt sie nicht, ist der nächste Spieler an der Reihe.

  · Wer als erster alle Karten ablegen konnte, hat gewonnen.

ES WIRD NOCH BESSER:

• Übungen mit Musterlösungen zur eigenen Vertiefung der Themen

• kostenloses Asset-Paket mit den nötigen 3D-Modellen und Ressourcen, um sofort selbst mitzumachen

• "Sicherungspunkte" mit dem kompletten Abschnitts-Code für Fehlersuche und Vergleich mit dem Deinem Code

• pures Kompaktwissen - keine Compiler- oder Wartezeiten in den Videos!

• ... und natürlich Udemy's extrem kundenfreundliche Benefits: 30-Tage Rückgaberecht, integriertes Support-Forum und Abschlusszertifikat

Los geht's - starte jetzt mit der Programmierung Deiner Spiele!