Alle Beiträge

  • Halloween-Kürbis in Blender 2.8 modellieren

    Halloween-Kürbis in Blender 2.8 modellieren

    Kürbis formen

    • Füge eine UV-Sphere mit 6 Segmenten und 6 Ringen hinzu.
    • Wähle im Edit Mode mittels Shift+Alt+LinkeMaus alle vertikalen Edges der Kugel aus.
    • Rufe Bevel Edges aus dem Edge-Menü (oder Strg+B) auf und erzeuge so Streifen um die gewählten Kanten herum. Rolle das Mausrad einmal um zusätzlich eine Kante in der Mitte zu erzeugen.
    Erzeuge Face-Bänder mit dem Bevel Edges-Befehl entlang der vertikalen Kugelkanten.
    • Wähle anschließend wieder die mittleren Edges aus und skaliere sie, so dass Sie Einkerbungen in die Kugel bilden.
    • Wechsel zurück in den Object Mode und füge dem Objekt den Modifikator Subdivision Surface hinzu. Setze dessen Render-Auflösung auf 2.
    • Klicke mit der rechten Maustaste auf das Objekt und wähle Shade Smooth, um die Oberfläche geglättet zu zeichnen.
    • Gehe nach Bedarf zurück in den Edit Mode und runde die Ober- und Unterseite des Meshs durch Verschieben der Vertices und Faces ab.
    Basisform des Kürbis.

    Einfärben der Frucht

    • Wähle den Kürbis im Object Mode aus und wechsle in den Material-Tab (rote Kugel).
    • Erzeuge ein neues Material durch Klick auf den +New-Schalter.
    • Ändere die Base Color zu einem Orange-Ton.
    Eingefärbter Kürbis.

    Arrangieren der Szene

    • Erzeuge im Object Mode mittels Alt+D Klone des Kürbis.
    • Verteile die Klone und erzeuge Variationen durch Skalieren und Rotieren.
    • Füge mit Shift+A eine Plane als Bodenebene hinzu und skaliere sie über die Szene.
    • Platziere die Kamera so, dass sie einen attraktiven Blickwinkel einfängt. Schalte bei Bedarf mit Strg+Alt+Q in die Vierfachansicht.
    Erzeugen von Klonen und Arrangieren einer Szene.

    Gesicht schnitzen

    Schnittform erzeugen

    • Erzeuge im Object Mode mittels Shift+D eine Kopie von einem der Kürbisse.
    • Füge über Shift+A eine Plane als Ausgangsobjekt für die Stanzform in die Szene ein. Stelle die Form ggf. mit R Y 9 0 Enter aufrecht.
    • Wechsle in den Edit Mode der Stanzform und verforme die rechteckige Ebene zu einem dreieckigen Auge.
    • Dupliziere diese Augenform mit Shift+D (immernoch im Edit Mode des selben Objekts!), verschiebe sie horizontal und spiegel sie durch negative Skalierung mit der Tastenfolge S X - 1 Enter.
    • Dupliziere ein Auge erneut und verschiebe es an die Mund-Position.
    • Lösche einen Vertex-Punkt des Munds, um eine Linie zu erhalten.
    • Extrudiere einen Endpunkt mit der Taste E, um die Linie zu verlängern und dabei Streckenpunkte zu erzeugen. Forme so eine Kontur für den Mund.
    • Schließe die Form durch Verbinden (F) oder Verschmelzen (Vertex > Merge Vertices > At Center) der letzten beiden Punkte.
    • Wähle die Mundform mit Alt+LinkeMaus aus und fülle sie mit der Taste F.
    • Wähle nun alle Vertex-Punkte (beide Augen und Mund) mit der Taste A aus.
    • Drücke E, um die Auswahl zu einer dreidimensionalen Form zu extrudieren.
    Modellierte Schnittform.

    Gesicht ausschneiden

    • Gehe zurück in den Object Mode.
    • Schiebe die Schnittform an die gewünschte Schnittstelle in den Kürbis.
    • Wähle den Kürbis aus. Klicke im Subsurf Modifikator auf Apply, um die höhere Auflösung dauerhaft anzuwenden und im Ausschnitt scharfe Kanten zu erhalten.
    • Füge dem Kürbis einen Solidify-Modifikator hinzu, um ein doppelwandiges Objekt zu erhalten und Rückwände im Ausschnitt zu vermeiden. Erhöhe den Thickness-Wert auf 0.08.
    • Füge dem Kürbis einen Boolean-Modifikator hinzu und wähle die Schnittform als Partnerobjekt aus. Blende die Schnittform in der Szene per Klick auf das Auge im Szenenbaum aus.
    • Schließe die Schnittform aus dem Rendering aus, in dem Du in ihren Objekteigenschaften (oranges Rechteck-Symbol) im Abschnitt Visibility den Haken bei Show in Renders entfernst.
    • Markiere nun zuerst die Schnittform, dann den Kürbis und drücke Strg+P, um die Form an die Frucht zu hängen. Wird der Kürbis verschoben, verschiebt sich der Ausschnitt nun korrekt mit.
    Kürbis mit ausgeschnittenem Gesicht

    Szene beleuchten

    • Wähle im Object Mode das vorhandene Licht aus und dupliziere es mit Shift+D.
    • Verschiebe das duplizierte Licht ins Innere des Kürbis und setze seinen Power-Wert auf 50 herab. Setze die Lichtfarbe auf einen Gelbton.
      • Scrolle zum Abschnitt Shadow und setze dort den Wert Exponent auf 111.
      • Setze den Haken bei Contact Shadows.
    • Wähle die andere Lichtquelle aus, platziere sie gegenüber der Kamera, so dass Lichtkanten auf den Objektoberflächen entstehen. Setze die Lichtfarbe auf einen Blauton.
    • Wechsle im Eigenschaftenpanel auf das rote Globus-Symbol und ändere den Color-Wert der Umgebung auf einen dunklen Blauton.
    Lichtquellen setzen.

    Tiefenunschärfe-Effekt

    • Wähle im Object Mode die Kamera aus.
    • Setze den Haken bei Depth of Field in den Eigenschaften der Kamera.
    • Weise dem Feld Focus on Object den geschnitzten Kürbis zu, in dem Du ihn mit der Pipette auswählst.
    • Setze den Wert F-Stop auf einen niedrigen Wert, wie z.B. 0.4.
    Tiefenunschärfe einstellen

    Bodenmaterial hinzufügen

    • Wähle im Object Mode die Bodenfläche aus.
    • Wechsle zum Material-Tab (rote Kugel) und erzeuge ein neues Material mit dem + New-Schalter.
    • Setze den Color-Wert auf Dunkelgrün.
    • Scrolle bis zum Feld Normal und klicke auf den Default-Schalter. Wähle Vector > Bump.
    • Klicke im nun entstandenen Feld Height auf den Default-Schalter. Wähle Texture > Noise Texture aus.
    • Setze die Noise-Eigenschaften wie folgt: Scale: 24, Detail: 4.9, Distortion: 1.0.
    Bodenstruktur anpassen
  • Gezippte .blend oder .unitypackage auf dem Mac entpacken

    Gezippte .blend oder .unitypackage auf dem Mac entpacken

    Beim Entpacken einer Zip-Datei entpackt MacOS beim Doppelklicken auf das Zip nicht nur das Archiv selbst, sondern auch dessen Inhalt.

    Dateiformate wie .unitypackage oder .blend, die sich in der zip-Datei befinden, werden dabei ungewollt zerstört und lassen sich nicht mehr in Unity oder Blender öffnen.

    Zip im Terminal entpacken

    Um nur das Zip-Archiv, nicht aber dessen Inhalte zu entpacken, verwende das Terminal und eine Kommandozeile:

    1. Cmd+Leer, um Spotlight-Suche zu öffnen
    2. In Spotlight Terminal suchen und die vorgeschlagene Anwendung öffnen
    3. Mit cd pfad zum Speicherort der Zip-Datei wechseln, z.B. cd ~/Desktop (Tilde ~ mit Tastenkombination Alt+N)
    4. Entpacken mit unzip zipdateiname
    5. Terminal schließen, der Inhalt des Zips sollte nun korrekt entpackt neben der Zip-Datei liegen.
  • Spielidee patentieren und schützen

    Spielidee patentieren und schützen

    Wenn Du Dich für Spiele-Entwicklung interessierst und kreative Einfälle hast, wirst Du früher oder später an den Punkt kommen, an dem Du eine tolle Spielidee hast. Schnell kommt die Frage auf, wie sich diese Idee vor Nachahmern und Ideenklau schützen lässt.

    Die ernüchternde Antwort lautet kurz: praktisch überhaupt nicht, bzw. der Aufwand lohnt sich für Indies/kleine Teams nicht.

    Der Mythos der phänomenalen Idee

    Das Problem beginnt schon bei Frage, wie gut eine Idee denn wirklich ist. Welche Faktoren werden zur Bewertung zugrunde gelegt?

    Sich eine Sache vorzustellen ist sehr viel einfacher, als sie wirklich umzusetzen. Was sich in der Vorstellung noch einfach und glatt darstellt, lässt sich häufig sehr viel schwieriger umsetzen. Das gilt auch für andere Medien; sich an eine Melodie zu erinnern fällt leicht, doch sie auf einem Instrument zu spielen, ist eine Herausforderung.

    Was macht Deine Idee aus? Warum findest Du sie so großartig?

    Das Problem mit Ideen ist, dass sie der eigenen Gedankenwelt entspringen. Was sich in unserem Gehirn abspielt, läuft zwangsläufig auf unseren eigenen Denkbahnen, die z.B. auch mit der Gefühlswelt verbunden sind. Eine Idee kann Dich also z.B. deshalb begeistern, weil sie an Deine persönlichen Gedanken, Gefühle, Erinnerungen und Sehnsüchte anknüpft. Wird sie andere, außerhalb dieser emotionalen Binding, ebenso begeistern?

    Schließlich: Bist Du sicher, dass Deine Idee neu ist? Mag sein, dass sie für Dich neu ist, doch wenn sie so großartig ist, ist es sehr wahrscheinlich, dass sie in gleicher oder zumindest ähnlicher Form schon existiert. Und wenn sie schonmal irgendwo ausprobiert wurde, warum ist sie dann gescheitert?

    Was ist das Ziel?

    Eine zentrale Frage bei der Bewertung von Ideen ist die nach dem Ziel des ganzen Projekts. Möchtest Du ein künstlerisches Projekt um seiner selbst Willen realisieren? Prima, dann mach es einfach!

    Möchtest Du ein kommerzielles Spiel produzieren? Dann stehen viele Fragen im Raum, die die Tauglichkeit einer Idee beeinflussen. Um Geld zu verdienen, muss die Idee von der Zielgruppe angenommen werden. Wenn eine kreative Idee nur einer kleinen Gruppe von Liebhabern gefällt, kann es sein, dass diese schlicht zu klein ist, um damit genug Geld zu verdienen.

    Eine gute Idee verkauft sich nicht von selbst

    Zudem besteht ein erheblicher Aufwand in Marketingarbeit. Eine tolle Idee verkauft sich leider nicht von selbst. Eine gigantische Menge von Konkurrenzprodukten ist auf dem Markt, die es sehr schwer macht, überhaupt wahrgenommen zu werden. Es gibt viele gute Ideen, die sich aufgrund unzureichendem Marketings nicht durchsetzen konnten und viele schlechte Ideen, die durch geschickte Verkaufstaktiken Millionen umsetzen.

    Auch wenn die Idee wirklich komplett neu und noch nie dagewesen wäre, kann es passieren, dass sie keinen Erfolg hat, weil die Verbindung zum aktuellen Stand der Dinge fehlt. Fast immer ist ein Übergang vom Alten zum Neuen nötig, um eine neue Idee erfolgreich einzuführen. Es ist wie mit einer entlegenen Insel, die nur betreten werden kann, wenn ein Weg dorthin führt.

    Wovor hast Du Angst?

    Möglicherweise beschäftigt Dich die Frage nach Ideenschutz deshalb, weil Du befürchtest, jemand könnte Deine Idee aufgreifen, umsetzen und damit viel Geld verdienen. Dabei bist Du der Meinung, dass Dir das Geld zustünde, weil Du eine Idee beigesteuert hast.

    Ist das wirklich so? Die Spielidee macht nur einen winzigen Bruchteil eines fertigen Produkts aus und der eigentliche Wert liegt in der gelungenen Umsetzung. Es gibt unzählige Gründe, warum die Idee in der Umsetzung scheitern kann – technisch, konzeptuell, finanziell. Gleichzeitig ist sie schlicht wertlos, so lange sie nicht in ein reales Produkt umgesetzt wurde, das sich spielen und verkaufen lässt.

    Wenn also jemand Deine Idee klaut, was natürlich tatsächlich passieren könnte, und sie bis zu einem marktreifen Produkt weitergeführt hat, wurde erheblich mehr Leistung in die Umsetzung beigesteuert als der Funken der Grundidee ausmacht. Der Anteil der Spielidee im fertigen Produkt ist in der Regel also relativ gering.

    Siehe auch: If video game development ideas are worth nothing, why did my game’s idea implement so well (I’m not a professional game designer)?

    Welcher Schutz ist theoretisch möglich?

    Es gibt eine Reihe von juristischen Schutzmöglichkeiten, die Dir viele Anwälte und Berater gerne anbieten oder sogar anraten (denn das ist ihr Geschäft). So besteht neben dem Urheberrecht auch die Möglichkeit Muster, Marken oder Patente anzumelden.

    Der Spieleentwickler „King“ geriet in die Schlagzeilen, weil er Markenanspruch auf Begriffe wie „Candy“ oder „Saga“ erhob und Konkurrenten (teils erfolglos) verklagte. Bemerke, dass es sich bei diesen Begriffen um textuelle Marketingelemente, nicht Spielideen, handelt. Es gibt viele Klone von Kings typischen Gelegenheitsspielen, die lediglich anders benannt werden müssen.

    Schutzmaßnahmen wirken generell nur relativ:

    • Software-Patente sind überhaupt nur begrenzt möglich. Auch hier stellt sich die Frage, was überhaupt geschützt werden soll und wie sich dies sachlich festlegen lässt. Geht es um einen Algorithmus (Rechenverfahren)? Einen Ablauf im Interaktionskonzept? Ein kreativer Einfall allgemein lässt sich kaum schützen.
      Siehe auch: „Softwarepatente“ bei Wikipedia
    • Angemeldete Inhalte müssen sehr genau beschrieben werden. Bereits kleinste Abweichungen können eine andere Idee darstellen, bei der ein eventueller Schutz nicht mehr greift.
    • Anmeldungen unterscheiden sich regional und nach Rechtssystemen. Selbst wenn Du eine Idee anmelden könntest, kommen hier unterschiedliche Rechtsräume zum Einsatz. Wird beispielsweise eine Marke in Deutschland angemeldet, kann sie im Ausland dennoch Nachahmer finden. Weltweite Anmeldungen sind zwar möglich, aber kompliziert, weil sich die Rechtssprechung von Land zu Land unterscheidet.
    • Schutzanmeldungen sind mit sehr hohen Kosten verbunden. Ähnlich wie räumlich gelten sie auch zeitlich nicht unbegrenzt, so dass auch langfristige Kosten und Arbeit entstehen.

    Bist Du bereit die Konsequenzen zu tragen?

    Angenommen es wäre möglich, Deine Idee per Patent o. ä. zu schützen. Hättest Du dann überhaupt den Willen und die Mittel, um eventuelle Rechtsverstöße aktiv zu verfolgen?

    Die Eintragung stellt zwar eine rechtliche Grundlage dar, doch musst Du selbst Anwälte beschäftigen, die im Falle einer Rechtsverletzung gegen den Verstoß aktiv werden. Jahrelange Gerichtsverfahren und hohe Kosten sind die Folge. Aufgrund der vielen Unsicherheiten und Auslegungsmöglichkeiten ist ein Erfolg in Deinem Interesse dabei noch nicht einmal garantiert.

    Firmen kaufen selten Ideen

    Könnte man die Spielidee nicht einfach an eine Entwicklerfirma verkaufen, um Geld zu verdienen und dabei den ganzen Aufwand los zu werden? Du kannst es versuchen, doch die meisten Firmen kaufen keine Ideen ein.

    Wie oben bereits angedeutet, fehlt es der Welt nicht an Ideen, im Gegenteil. Jeder Entwickler, jede Firma, jeder Kreative hat selber unzählige gute Ideen von denen die meisten in der Schublade laden. Gerade im kommerziellen Umfeld spielt nicht der kreative Einfall, sondern die Markttauglichkeit eine entscheidende Rolle.

    Zudem scheuen Firmen externe Einflüsse, um sich vor Schaden zu schützen. Angenommen eine Firma würde eine Idee kaufen und umsetzen und das Spiel würde ein großer Erfolg werden. Dann könnte es passieren, dass der Ideengeber der Meinung ist, dass der Erfolg auf seiner tollen Idee beruht und anfangen, plötzlich zusätzliche Forderungen, z.B. Geld, zu stellen. Selbst wenn ein Gericht z.B. aufgrund des Vertrages, gegen den Ideengeber entscheiden würde, hätte die Firma viel Ärger und Kosten aufgrund der Angreifbarkeit, die durch den externen Ideeneinkauf entsteht. Einige Firmen lehnen daher unaufgefordert zugesandte Konzepte und Ideen sofort ab, ohne dass sie überhaupt ein Entwickler zu Gesicht bekommen hat.

    Siehe auch: If I have an idea for a video game. Can I sell my idea and get paid for it?

    Was also tun?

    Die oben angesprochenen Themen sind sicher nicht vollständig, zeigen aber schon, dass die Sache mit dem Ideenschutz ziemlich kompliziert ist. Insbesondere für kleine Entwickler oder gar Einzelpersonen lohnt es sich meines Erachtens kaum, den Aufwand und die Kosten eventueller Schutzeintragungen durchzuführen, weil sie ohnehin keinen Erfolg garantieren können.

    Statt dessen ist es besser, eine Umsetzung zu erreichen und als erster mit der Idee auf dem Markt zu sein.

    • Vereinfache die Idee soweit wie möglich, um schnell eine erste lauffähige Demo zu erreichen. Hier zeigt sich, ob die Idee in der Praxis funktioniert und es entsteht eine gute Grundlage für alles weitere.
    • Wenn Du selbst nicht über die Fähigkeiten verfügst, musst Du einen Entwickler beschäftigen.
    • Wenn es sich bei Deiner Idee um einen kreativen Einfall handelt (und weniger z.B. um ein technisches Verfahren), sorge dafür, dass bis zur Veröffentlichung möglichst wenig Informationen nach außen dringen, damit die Idee nicht gestohlen wird. Es kann jedoch immer passieren, dass jemand zufällig zeitgleich eine ähnliche Idee hat.
    • Erweitere die Idee zu einem vollständigen Projektplan, der auch Dinge wie die Vermarktung vorsieht. Auch hier solltest Du Helfer für die Dinge beschäftigen, die Du nicht selbst erledigen kannst.
    • Ist das Spiel fertig oder das Konzept zumindest sehr ausgereift, kannst Du zumindest versuchen einen Publisher zu finden, der die Veröffentlichung übernimmt. Einige investieren auch in die Produktionskosten, wie z.B. Handy Games.

    Wird das Spiel ein Erfolg, wird es auch Klone davon geben. Das ist unvermeidlich und bei jedem erfolgreichen Produkt der Fall. Es gibt keinen hundertprozentigen Schutz davor.

    Siehe auch: If I have an idea for a video game, how do I get it produced?

    Zusammenfassung

    Auch wenn es einige rechtliche Hilfsmittel wie Marken- oder Patentanmeldungen gibt, existiert kein hundertprozentiger Schutz vor Ideen-Diebstahl. Da die Idee nur einen winzigen Bruchteil eines fertigen Spiels ausmacht, ist es wahrscheinlich, dass die Idee alleine weniger Wert ist, als Du glaubst. Rechtliche Schutzmaßnahmen lohnen sich nur für große Firmen, die auch in der Lage sind, die Rechtsansprüche aktiv zu verteidigen. Für kleine Teams und Einzelpersonen ist es in der Regel sinnvoller, eine konkrete Umsetzung anzustreben. Nur ein tatsächlich realisiertes Spiel lässt sich spielen und verkaufen. Es ist unvermeidlich, dass erfolgreiche Produkte von Konkurrenten geklont werden.

  • Umstieg auf Blender 2.8 – Was ist neu?

    Umstieg auf Blender 2.8 – Was ist neu?

    Blender 2.8 bringt einige Neuerungen mit sich, teils kosmetischer Natur, teils aber auch inhaltlich. Während es zunächst so aussah, als würden sich viele Elemente grundlegend ändern, zeigt sich nun, dass ein Umstieg ganz gut möglich ist. In diesem Artikel werfe ich einen ersten Blick auf die neue Software und einige der auffälligsten Änderungen.

    Layout und Design

    • Das Design hat sich in Blender 2.8 ein wenig verändert, was sich z.B. an monochromen Icons zeigt, die nach Bedeutungsgruppe farbcodiert wurden.
    • Fensterbereiche werden wie früher durch Ziehen der Fensterecke mit der Maus getrennt oder zusammengeführt, lediglich das frühere Splitting-Gitter ist jetzt nicht mehr zu sehen.
    • Das Maximieren des Fensterbereichs unter der Maus liegt jetzt auf der Taste Strg+Leertaste.
    • Das Rendering (F12) wird nun in einem neuen Fenster geöffnet, was sich über das Hauptmenü Render → Display Mode → Image Editor zurücksetzen lässt.

    Workspaces

    • Tabs am oberen Bildschirmrand implementieren nun „Workspaces“, die die früheren „Screens“ ersetzen. Wechseln mit ⌘+Bild↑/Bild↓  (früher Strg+↑/↓).
    • Workspaces merken sich auch den Bearbeitungsmodus, so dass z.B. der Modeling-Workspace im Edit-Mode verbleiben kann, während der Layout-Workspace auf Object-Mode stehen bleibt.

    Tasten aus 2.79 weiterverwenden

    Um Blender 2.8 mit den alten Tastenkombinationen zu bedienen, lassen sich diese in den Einstellungen umschalten: Menü Edit → Preferences: Abschnitt Keymap – Blender 27X

    Neue Mausbelegung

    • Die linke Maustaste wählt jetzt Objekte aus (früher rechte Maustaste). Auswählen funktioniert nun per Klick oder direktes Ziehen des Auswahlrahmens (früher nur mit B).
    • Die rechte Maustaste öffnet ein Kontextmenü.
    • Die Eingabemarke für das Erzeugen neuer Objekte wird mit Strg+RechteMaus gesetzt (früher linke Maustaste).

    Objekte und Collections (Layer, Groups)

    • Löschen zeigt eine Rückfrage nur noch bei Verwendung der X-Taste (nicht bei Entf).
    • Sowohl Layer als auch Gruppen existieren nicht mehr. Stattdessen gibt es einen einheitlichen und intuitiveren Collections-Mechanismus, der Objekte in Ordnern organisiert. Die Taste M verschiebt Objekte folglich in Collections.

    Edit-Modus

    • Der Edit-Modus funktioniert nun für mehrere Objekte gleichzeitig.
    • Viele Befehle sind nun über Werkzeugschalter zugänglich, deren Symbol die Funktion grafisch beschreibt. Insgesamt kann mit weniger Tastenkombinationen und mehr mit der Maus gearbeitet werden.

    3D-Viewport

    • Die Werkzeuge im 3D-Viewport wurden so organisiert, dass sie aufgeräumter erscheinen und zudem mit weniger Klicks zu erreichen sind. Die Ansichtseinstellungen erscheinen nun in einem Popup (früher alles in der numerischen Seitenleiste).
    • Der neue X-Ray-Modus zeichnet alle Objekte durchscheinend, so dass Überlappungen sichtbar werden.
    • Das Random-Flat-Shading zeichnet Objekte als zufällig gefärbte Flächen, um Zusammenhänge grafisch darzustellen.
    • Das Ein- und Ausblenden von Objekten nach Typ ist nun über das Sichtbarkeitsdropdown schnell und einfach möglich.
    • Weitere Anpassungen der angezeigten Werkzeuge stehen zudem jetzt im Gizmo-Dropdown zur Verfügung.
    • Der Zugriff auf die Blickwinkelwerkzeuge hat sich stark vereinfacht. Durch Ziehen der Kamera-Schalter lässt sich nun ganz einfach Zoomen, Scrollen oder zwischen orthogonaler und perspektivischer Darstellung umschalten.
    • Das perspektivische Gizmo schaltet per Klick zwischen den Seitenansichten um und stellt den momentanen Blickwinkel leicht verständlich dar. Somit rückt das bisherige eher umständliche Umschalten per Nummernblock in den Hintergrund.

    Zeitleistenanimation

    • Der grundlegende Ablauf (Keyframe mit I erzeugen, …) bleibt gleich.
    • Keyframes können nun aber direkt in der Zeitleiste des Hauptfensters per Maus bearbeitet werden, ohne dazu in das Dopesheet wechseln zu müssen.
    • Die Tasten für 10-Schritte-Springen entfallen komplett.
    • Anfang/Ende des Zeitfensters wird nun mit Strg+Pos1/Ende festgelegt (früher S/E).
  • Zähler erhöhen solange ein Button gedrückt wird

    Zähler erhöhen solange ein Button gedrückt wird

    Um Unitys UI-Button interaktiv zu gestalten, wird im Inspector eine Methode an das Klick-Ereignis der Button-Komponente angehängt. Jedoch unterstützt dieses Vorgehen nur ein einfaches Klick-Ereignis. Für komplexere Ereignisse wie z.B. das Erhöhen eines Zählers solange der Button gedrückt gehalten wird, ist die Überwachung zusätzlicher Ereignisse nötig.

    Eine ausführliche Anleitung kannst Du Dir im Video ansehen. Das Beispiel-Projekt findest Du außerdem bei GitHub. Im Folgenden fasse ich die wesentlichen Punkte nochmal zusammen:

    Solange-gedrückt-Logik

    • Verwende einen gewöhnlichen UI-Button und erzeuge ein MonoBehaviour-Script, das als Geschwister der Button-Komponente hinzugefügt wird. Die klassische Verknüpfung mit dem OnClick-Ereignis im Inspector ist nicht nötig!
    • Importiere das EventSytem im Code:
      using UnityEngine.EventSystems;
    • Implementiere die Interfaces IPointerDownHandler und IPointerUpHandler.
    • Lege eine boolsche Variable mausIstGedrueckt an und setze sie entsprechend innerhalb OnPointerDown bzw. OnPointerUp.
    • Führe die gewünschte Logik, z.B. das Erhöhen des Zählers, innerhalb von Update aus, wenn mausIstGedrueckt wahr ist.
    using UnityEngine.EventSystems;
    
    public class ZaehlerButton : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
    {
    ...
        
        // Update is called once per frame
        void Update()
        {
            if (mausIstGedrueckt)
                 ... Zähler erhöhen ...
        }
    
        private bool mausIstGedrueckt = false;
    
        public void OnPointerDown(PointerEventData eventData)
        {
            Debug.Log("Maus gedrückt.");
            mausIstGedrueckt = true;
        }
    
        public void OnPointerUp(PointerEventData eventData)
        {
            Debug.Log("Maus losgelassen.");
            mausIstGedrueckt = false;
        }

    Geschwindigkeit steuern

    Der Zähler wird nun in jedem Frame erhöht, je nach Systemleistung also sehr schnell. Um die Aktualisierungsgeschwindigkeit zu steuern, müssen zusätzlich noch die Zeit messen.

    • Deklariere eine private float-Variable warteNoch, die angibt, wie lange noch gewartet werden muss, bevor das nächste Mal hochgezählt wird.
    • Führe das Hochzählen nur aus, wenn warteNoch<=0 ist, ansonsten ziehe die verstrichene Zeit (Time.deltaTime) von der Wartezeit ab.
    • Damit der erste Klick immer sofort auslöst, setze warteNoch auf 0, wenn die Maus nicht gedrückt ist.
        private float warteNoch=0f;
        
        // Update is called once per frame
        void Update()
        {
            if (mausIstGedrueckt)
            {
                if (warteNoch <= 0f) //Wartezeit abgelaufen
                {
                    WennButtonAngeklickt();
                    warteNoch = 0.5f; //Wartezeit bis WennButtonAngeklickt wieder ausgelöst wird
                }
                else
                {
                    warteNoch -= Time.deltaTime; //verstrichene Zeit von Wartezeit abziehen
                }
            }
            else //maus ist nicht gedrückt
            {
                warteNoch = 0f;
            }
        }
  • UI-Text aus Text-Datei befüllen

    UI-Text aus Text-Datei befüllen

    Oft ist es wünschenswert, Bildschirmtexte nicht fest in Unity zuzuweisen, sondern dynamisch aus einer Textdatei zu lesen. Typische Anwendungsfälle sind:

    • Komplexe und wiederkehrende Texte. In einem Dialogsystem werden die Fenster nur einmal definiert und die konkreten Textinhalte dann dynamisch ausgetauscht.
    • Lokalisierung und Übersetzung. Das Spiel soll nicht alle Textinhalte aller Sprachen im Speicher halten müssen, sondern flexibel in Form eines austauschbaren Wörterbuchs verwalten.

    Kostenloses Helfer-Script um Textfragmente zu lesen

    Lade zunächst die Datei Woerterbuch.cs aus meinem Github-Repository herunter und füge sie in den Assets-Ordner Deines Projekts ein. Dieses Script implementiert einige typische Vorgänge um Schlüssel-Wert-Paare aus einer Textdatei zu lesen.

    • Öffne ein neues Unity-Projekt und schalte die Szene in die 2D-Ansicht.
    • Füge über das Menü GameObject > UI > Text ein Textobjekt inklusive Canvas und EventSystem hinzu.
    • Füge zudem einen Button ein.

    Script um ein Textfragment zu lesen

    • Füge den Assets ein neues C#-Script namens WortLesen.cs hinzu.
    • Füge Felder für das Textfeld sowie das Woerterbuch hinzu.
    • Füge eine Funktion für den Button hinzu, die den Übersetzungs-Schlüssel als String-Parameter empfängt.
    • Weise dem Textfeld-text das Ergebnis der lies(schlüssel)-Funktion des Wörterbuchs zu.
    using UnityEngine;
    using UnityEngine.UI;
    
    public class WortLesen : MonoBehaviour
    {
        public Text textfeld;
        public Woerterbuch buch;
    
        public void ButtonKlick(string schluessel)
        {
            textfeld.text = buch.lies(schluessel);
        }
    
    }

    Text-Ressource anlegen

    • Erzeuge in Visual Studio eine neue Textdatei über das Menü Datei > Neu > Datei vom Typ Textdatei.
    • Füge folgendes Schlüssel-Wert-Paar in die Textdatei ein:
      ErsterText Hallo aus der Textdatei!
    • Speichere die Datei innerhalb des Assets-Ordners als Deutsch.txt.

    Wörterbuch in Szene anlegen

    • Füge ein leeres Objekt über das Menü GameObject > Create Empty hinzu und nenne es Wörterbuch.
    • Ziehe das Script Woerterbuch.cs auf das Wörterbuch-Objekt.
    • Ziehe die Datei Deutsch.txt aus dem Assets-Fenster auf das Feld textfile im Inspector des Wörterbuch-Objekts.

    Komponenten verbinden

    • Ziehe im UnityEditor WortLesen.cs auf den Button in der Hierarchy.
    • Wähle den Button aus und setze im Inspector
      • das Textfeld-Objekt auf die Eigenschaft textfeld.
      • das Wörterbuch-Objekt auf die Eigenschaft buch.
    • Füge der Button-Komponente über den +-Schalter einen OnClick-Ereignisplatz hinzu.
      • Ziehe die WortLesen-Komponente auf das Objekt-Feld des Ereignisplatzes.
      • Wähle aus dem Auswahlfeld WortLesen > ButtonKlick(string) aus.
      • Trage im Parameter-Feld den Text ErsterText ein.

    Testen

    • Wechsle in den Play-Modus im Unity-Editor.
    • Klicke auf den Button.
    • Wenn alles richtig ist, erscheint der Text Hallo aus der Textdatei! im Textfeld.
    Der Inhalt des Textfelds wird der Textdatei entnommen.
  • Zusätzliches API-Level in Unity-Android-SDK installieren

    Zusätzliches API-Level in Unity-Android-SDK installieren

    Neuerdings kann über das Unity-Hub zusätzlich zum Editor auch gleich ein Android SDK installiert werden. Während diese Integration im Prinzip sehr angenehm ist, da sie einem das manuelle Herunterladen, Installieren und Konfigurieren des Android SDKs erspart, ist zunächst nicht klar, ob und wie sich diese minimierte SDK-Version konfigurieren lässt.

    Anwendungsfall: Unterstützung älterer Android-Versionen

    In meinem konkreten Fall hatte ich ein Projekt, das auch auf Handys mit etwas älteren Android-Versionen laufen soll. Neben der Umstellung der API-Level in den Projekt-Einstellungen muss die entsprechende Version auch vom Android-SDK unterstützt werden. In der neuen eingebetteten SDK-Version ist das nicht der Fall und eine manuelle Installation ist nötig.

    Beispiel: Damit das Spiel auch auf älteren Handys läuft, kann es nötig sein, die API-Levels auf frühere Versionen einzustellen. Diese müssen dann aber auch im SDK installiert sein und fehlen in der Standard-SDK-Einbettung von Unity.

    Hinzufügen von API-Leveln zum eingebauten Android-SDK in Unity

    • Finde zunächst den Installationspfad des eingebauten SDK, z.B. über die Einstellungen:
      • Menü Edit > Preferences > External Tools
      • Entferne den Haken bei Android SDK Tools installed with Unity
      • Klicke auf Browse… wodurch der SDK-Pfad im Texteingabefeld erscheint.
      • Kopiere diesen Pfad.
      • Setze wieder den Haken bei Android SDK Tools installed with Unity
    Pfad über die Einstellungen finden (Unity 2019.1.2f1)
    • Öffne jetzt eine Konsole.
      Unter Windows 10:
      • Klicke auf Start/Windows-Symbol und tippe: cmd
      • Klicke mit der rechten Maustaste auf den Eintrag Eingabeaufforderung und wähle Als Administrator ausführen.
    Eingabeaufforderung als Admin öffnen
    • Gib in die Eingabeaufforderung ein: chdir
      und dann den kopierten Pfad. Über Rechtsklick auf die Titelleiste kannst Du den Text aus der Zwischenablage einfügen.
    • Drücke dann Enter, um in den Pfad zu wechseln.
    In den SDK-Installationsorder wechseln.
    • Wechsle in den Werkzeug-Unterordner durch Eingabe von cd tools\bin (Enter)
    • Um nun eine SDK-Version hinzuzufügen, führe einen Befehl wie diesen aus:
      sdkmanager "platforms;android-22"
      22 steht hier für das API-Level 22, wie in den Project Settings in Unity ablesbar (siehe erster Screenshot oben).
    • Typische Fehlermeldung:
      Warning: File C:\Users\username.android\repositories.cfg could not be loaded.
      Warning: Failed to read or create install properties file.

      Tritt auf, wenn die Kommandozeile nicht mit Administrator-Rechten gestartet wurde (siehe Anleitung oben).

    Gegenprüfung

    • Öffne einen Explorer, z.B. durch Eingabe von
      explorer ..\..\platforms
      im Konsolenfenster.
    • In diesem Ordner müsste jetzt ein Unterordner mit den Versionsnamen existieren.
    Prüfen, ob das neue SDK installiert wurde.

    Auch bei Gradle-Fehlern nützlich

    Mit dem oben beschriebenen Weg sind manchmal auch Gradle-Fehler zu beheben, die beim Erstellen der APK-Datei über File > Build auftauchen.

    Failed to install the following Android SDK packages as some licences have not been accepted

    Gradle-Fehler während Build-Vorgang wegen fehlender SDK-Version.

    Bei diesem Fehler fehlt ein SDK und Gradle kann es nicht selbst installieren. In diesem Fall ablesen welche Version fehlt (hier 27) und wie oben beschrieben manuell installieren: sdkmanager "platforms;android-27"

    Failed to install the following SDK components: build-tools, … SDK directory is not writeable

    Gradle-Fehler während Build-Vorgang wegen fehlenden Tools.

    Es kann auch passieren, dass Gradle Werkzeug-Komponenten vermisst und wegen fehlender Administrator-Rechte nicht selbst installieren kann. Auch dies lässt sich manuell korrigieren: sdkmanager "build-tools;28.0.2"

    Das fehlende Fragment gibt Gradle in der Fehlermeldung direkt an (build-tools;28.0.2).

    Zusammenfassung

    Auch 2019 ist die Entwicklung von Mobil-Anwendungen noch immer voller technischer Hürden. Die Integration des Android-SDK in die Unity-Editor-Installation ist zwar gut gemeint, sorgt in der Praxis aber erstmal für zusätzliche Herausforderungen, sobald die Projektanforderung von der Voreinstellung abweicht.

    Über eine Kommandozeile mit Admin-Berechtigung lassen sich SDK-Versionen und Werkzeuge manuell installieren, was sich bei einigen Gradle-Fehlern im Build-Vorgang als nützlich erweist.

  • Partikelsystem ein/ausschalten in Unity 2019

    Partikelsystem ein/ausschalten in Unity 2019

    Partikelsysteme gehören zu den Komponenten, die sich in den meisten Game-Engines oft und grundlegend ändern. Auch in Unity kommt es immer wieder zu Umstrukturierungen, die dafür sorgen, dass bestehender Code nicht mehr wie gewohnt funktioniert.

    Emission de/aktivieren

    Das einfache Ein- und Ausschalten des Partikelsystems hat sich in Unity 2019 wieder einmal geändert. Das frühere Feld enableEmission erscheint nun als veraltet. Statt dessen soll emission.enabled verwendet werden, das wiederum nicht direkt, sondern nur über einen Zeiger schreibbar ist.

    ParticleSystem.EmissionModule e = ps.emission; //Zeiger auf Emission-Komponente
    e.enabled = true; //ein/ausschalten wie gewohnt

    Das Problem ist meines Erachtens noch nicht einmal die Änderung selbst. Da Partikelsysteme aus einer riesigen Menge von Einstellungen und Funktionen bestehen, macht es Sinn, die Bestandteile in Unterkomponenten zu isolieren. Jedoch sorgt die Art und Weise der Implementierung aufgrund ihrer Inkonsistenz dafür, dass der Code schwerer zu erlernen ist. An kaum einer anderen Stelle ist es nötig, einen Zeiger auf die Emissionskomponente zu holen und dann darin ein Feld zu setzen. Ähnlich ist vielleicht noch das Setzen von Transformationseigenschaften, z.B. x/y/z der Position, die ebenfalls das Anlegen einer Zwischenvariable erfordern, die dann aber zurückgeschrieben werden muss.

    Komplettes Unity-Beispiel zum Nachvollziehen

    • Erstelle ein neues Unity-Projekt vom Typ 3D (getestet mit Unity 2019.1)
    • Füge über das Menü Game Objects > Effects > Particle System ein Partikelsystem hinzu.
    • Erstelle eine C#-Datei in den Assets namens ParticleTest.cs und füge den unten stehenden Code ein. Speichern.
    • Ziehe das neue Script auf das Partikel-System-Spielobjekt.
    • Starte das Spiel, klicke in den Game-Fensterbereich und schalte das Partikelsystem mit der Taste 1 ein und der Taste 2 aus.

    ParticleTest.cs

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class ParticleTest : MonoBehaviour
    {
        private ParticleSystem ps;
    
        // Start is called before the first frame update
        void Start()
        {
            ps = GetComponent<ParticleSystem>();
        }
    
        // Update is called once per frame
        void Update()
        {
            ps.enableEmission = true;
    
            ParticleSystem.EmissionModule e = ps.emission;
            if (Input.GetKeyUp(KeyCode.Alpha1)) e.enabled = true;
            if (Input.GetKeyUp(KeyCode.Alpha2)) e.enabled = false;
        }
    
        private Rect r = new Rect(0, 0, 500, 500);
        private GUIContent h = new GUIContent("Taste 1: PS an, Taste 2: PS aus");
        public void OnGUI()
        {
            GUI.Label(r, h);
        }
    }

  • Neu: Power-Kurs Unity – Großes Komplettpaket

    Neu: Power-Kurs Unity – Großes Komplettpaket

    Seit der Veröffentlichung meines C#-Kurses haben wir im Fragen & Antworten-Bereich über viele Details zur Technik gesprochen. Dabei wurde immer wieder klar, dass weitere Übungen zur Vertiefung der Programmierkenntnisse in Unity hilfreich wären.

    Jetzt ist mein neuer Kurs verfügbar, der diesen Wunsch erfüllt: Den neuen Power-Kurs Unity: Kartenspiele programmieren habe ich gezielt so aufgebaut, dass er als Sammlung von zusätzlichen Trainingseinheiten funktioniert. Obwohl er keine großartigen Vorkenntnisse erfordert, ist er eine ideale Gelegenheit, um das technische Verständnis von Unitys Funktionsweise und der Programmierung in C# zu vertiefen und zu trainieren.

    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.

    Wie von Teilnehmern vorgeschlagen, setzen wir 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 ist mit über 11 Stunden sehr umfangreich. Sieh Dir hier an, was genau Du alles lernen wirst!

    Neu im Aufbau

    Aus dem bisherigen Feedback abgeleitet, ist auch im Kursaufbau einiges neu:

    • Stärkerer Fokus auf Fehler und wie Du bei der Analysiere vorgehen solltest.
    • Vorschau-Videos für jede Lektion, die vorab zusammenfassen worum es geht.
    • Ein zentraler PDF-Download mit Begleitmaterial und Übungsaufgaben.
    • Mehr Sicherungspunkte mit Referenz-Code.
    • Code-Hosting bei GitHub: Vergleichscode direkt online ansehen, einzeln oder als Paket herunterladen.
    • Klassendiagramme als grafischer Überblick über die Code-Komponenten.
    • …und vieles mehr.

    Über 11 Stunden neue Inhalte

    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 und Wert 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 wechselt
    • Tarot: Kleines Kreuz
    • Paare finden
    • Minimale Patience
    • Klondike- Patience
    • Mau-Mau

    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

    Schreibe Dich jetzt ein

  • Kostenpflichtigen Content in Unity-Spiele einbauen

    Kostenpflichtigen Content in Unity-Spiele einbauen

    Im C#-Kurs kam kürzlich die Frage auf, wie sich kostenpflichtige Spielinhalte umsetzen lassen. Die Möglichkeiten der Monetarisierung hängen zunächst wesentlich von der Plattform ab. Für die meisten Plattformen existieren bereits Stores und entsprechende Anbindungsstrukturen zu deren Nutzung ich Dir dringend raten würde, zumal Kommerzialisierung zahlreiche technische, aber auch rechtliche Konsequenzen und Verpflichtungen mit sich bringt.

    Bei der Anbindung eines bestehenden Shops, also z.B. Apples App Store, Google Play oder Steam, lässt sich der Aufwand zumindest soweit reduzieren, dass Du als Entwickler nur eine Business-to-Business-Beziehung mit dem jeweiligen Shop führen musst und sich der Shop um die Kundenbeziehung kümmert, wodurch sich komplizierte Themen wie Zahlungsabwicklung, Versteuerung, technische Auslieferung/Leistungserbringung, Rückgaberechte, landesspezifische Kundenrechte, uvm. auf den Händler abwälzen lassen.

    Ebenfalls zu überlegen ist, welche Form von Freischaltung des kostenpflichtigen Contents überhaupt geeignet ist. Das beste Modell hängt vom jeweiligen Spieltyp bzw. der Projektcharakteristik ab.

    Hier einige Beispiele für Monetarisierungsmodelle:

    • Zwei Versionen, freie Demoversion + Vollversion: am einfachsten zu realisieren, weil Du kaum etwas in Deine Software integrieren musst, sondern einfach zwei Produkte in den Stores anlegen kannst. Eignet sich gut, wenn große Spielteile oder das ganze Spiel verkauft werden sollen und der gratis-Teil nur ein Vorabtest oder im Sinne einer Demo/Vorschau zum Einsatz kommt. Wenn es vom Projekt her passt, empfehle ich Dir diese Variante wegen ihrer Einfachheit!
    • DLCs (Downloadable Content): Zusatzpakete, die über einen externen Store verkauft werden, aber von der Software als optionales Modul erkannt und ggf. aktiviert werden. Wie der Name schon sagt werden auch technisch Dateimodule erst nach dem Kauf ausgeliefert. Erfordert einen gewissen Aufwand der Integration, während der Verkaufsprozess außerhalb der Software bleibt. Eignet sich gut für relativ große/umfangreiche Erweiterungs-Pakete, zumal die Anzahl von DLCs durch den Store limitiert sein kann (bei Steam derzeit 10, soweit ich weiß).
    • In App-Purchases: Integration von ‚Kaufen‘-Funktionen innerhalb der Spieloberfläche. Die komplizierteste Variante, weil der gesamte Kaufprozess in der Software wiedergegeben werden muss. Eignet sich für Micro-Transaktions, also den einzelnen Verkauf von vielen kleinen Features.

    Je nach Store/Plattform ist die Implementierung sehr unterschiedlich. Apples Umgebungen sind dabei meiner Erfahrung nach am kompliziertesten und erfordern zwingend den Einsatz von Apple-Hardware und -Software zur Produktion der Vertriebsversion. Google/Android ist mittelmäßig aufwändig, etwas umständlicher als Steam aber im Vergleich zu Apple noch relativ gut machbar. Steam erfordert ebenfalls einiges an Einlesen und Ausprobieren, ist meiner Empfindung nach aber noch am einfachsten. Bei Steam war es in der Vergangenheit so, dass die Entwicklerinformationen als vertraulich eingestuft wurden, so dass ich dazu keine detaillierten Infos dazu geben konnte. Mittlerweile lockert sich das allerdings etwas und weite Teile der Partner-Dokumentation sind inzwischen öffentlich.

    Die offiziellen Plattformen-Dokumentationen enthalten eigentlich alle Anleitungen zur Anbindung von Monetarisierungsoptionen: 

    In jedem Fall ist eine ernsthafte und rechtssichere Monetarisierung mit viel Aufwand verbunden, technisch leider nicht mit ein paar Klicks getan und das Einlesen in viele technische und rechtliche Dokumente kaum zu vermeiden. Wie oben schon erwähnt, kann ich nur empfehlen, es technisch möglichst einfach zu halten und alles was mit Verkauf zu tun hat auf Handelspartner auszulagern.