Astra kann meine Vorstellungen inzwischen sehr gut in Spielmechanik und Grafik umsetzen. Mit Astra entwickle ich in Codex das Weltraumspiel Void Explorer. Darin kannst du ferne Sterne ansteuern und bis zur Oberfläche fremder Welten hinunterfliegen.
Ein Zusammenschnitt von Spielszenen aus Void Explorer.
Das Spiel umfasst 2.048 Sternsysteme und mehr als 10.000 prozedural generierte Planeten, darunter Welten von der Größe der Erde. Jeder sichtbare Stern gehört zum Spieluniversum und lässt sich ansteuern. Du kannst dir einen Lichtpunkt in der Ferne aussuchen und dorthin fliegen.
Du kannst dich einem Planeten aus dem All nähern, in seine Atmosphäre eintreten und weiter sinken, bis du über eine Küste fliegst. Du kannst landen, aussteigen, zu Fuß die Umgebung erkunden und wieder abheben. Damit diese Reise funktioniert, musste ich die unterschiedlichen Maßstäbe, das Gelände, die Steuerung und das Rendering aufeinander abstimmen.
Einige Prompts aus der Entwicklung habe ich für diesen Beitrag gekürzt und etwas klarer formuliert. Sie zeigen, wie ich meine Vorstellungen beschrieben habe und welche technischen Schritte sich daraus ergaben.
Beim Spielerlebnis anfangen
In meiner ersten Beschreibung ging es darum, was man im Spiel tun können sollte:
Alles, was ich sehen kann, soll erreichbar sein. Behalte die realen Entfernungen bei und sorge dafür, dass man sie dank passender Maßstäbe und Geschwindigkeiten überwinden kann. Ich möchte aus dem All in die Atmosphäre eines Planeten und bis zum Boden fliegen. Die Planeten können so groß sein wie die Erde. Wir brauchen also prozedural generiertes Gelände und einen Renderer, der es in Teilstücken verarbeitet.
Damit hatte Astra konkrete Vorgaben. Ein Stern durfte nicht einfach ein auf den Hintergrund gemalter Punkt sein. Beim Anflug auf einen Planeten durfte das Spiel nicht in ein separates Level wechseln. Die Reise musste über reale Entfernungen führen. Mit zwei fiktiven Antriebsarten, Pulsflug und Hyperantrieb, sollten sich diese Strecken im Spiel bewältigen lassen.
Schon früh habe ich mit Bildgenerierung ausprobiert, wie das Spiel aussehen sollte. Die ersten Entwürfe waren zu realistisch, die nächsten zu schlicht. Eine meiner Korrekturen lautete:
Jetzt ist mir das etwas zu schlicht. Wir brauchen einen Mittelweg mit besseren Farben, Neonlicht und stärkeren Kontrasten, die an die Tiefen des Weltalls erinnern. Zeig mir, wie das bei hoher Geschwindigkeit aussieht, mit Sternen und Staub rund um das Schiff.
Als mir die Bilder gefielen, bat ich Astra, sie zu speichern und daraus visuelle Vorlagen für das Spiel zu erstellen. Wir hatten nun konkrete Vorstellungen davon, wie ein Flug im Orbit, ein Hochgeschwindigkeitsflug, der Eintritt in die Atmosphäre und die Landung aussehen sollten. Anhand dieser Bilder konnte ich die nächste Spielversion viel leichter beurteilen.

Dieser generierte Entwurf gab die Farbpalette und den grafischen Stil des Spiels vor.
Astra die Architektur vorschlagen lassen
Ich gab die Anforderungen vor, Astra schlug die Umsetzung vor. Die Anwendung nutzt TypeScript und Vite, für das Rendering kommt Three.js zum Einsatz. So kann der Code Meshes, Materialien, Beleuchtung und prozedurale Geometrie direkt steuern. Damit entsteht ein Großteil der Spielgrafik.
In der ersten spielbaren Version nutzte der Renderer WebGL2. Später fragte ich Astra, ob Three.js der Grafik Grenzen setzte. Astra empfahl, die Simulation beizubehalten und den Renderer auf die WebGPU-Architektur von Three.js umzustellen. Die Systeme für das Universum, die Navigation und das Gelände blieben erhalten, während wir das Rendering umstellten.
Mit den Node-Materialien von Three.js und der Three.js Shading Language (TSL) definiert der Renderer Atmosphäre, Wasser und Lichteffekte im Code.
Das Gelände entsteht in Web Workern. So lässt sich die Geometrie unabhängig von dem Thread vorbereiten, der Eingaben verarbeitet und das Bild zeichnet. Mit Vitest prüfen wir unter anderem, ob die Generierung reproduzierbare Ergebnisse liefert, die Koordinatenberechnungen stimmen und das Geländesystem seine Schnittstellenzusagen einhält. Playwright testet das Spiel im Browser. So konnte Astra die zugrunde liegenden Systeme prüfen, während ich weiterhin beurteilte, wie sich das Spiel anfühlte.
Die visuellen Vorlagen blieben während der gesamten Entwicklung maßgeblich. Die Atmosphäre eines Planeten, das Leuchten seiner Ringe, das farbige Licht der Sterne und der Effekt Neon Phosphor prägen das Bild. Der Filter gibt ihm die Textur eines Retro-Displays, während die Navigationsanzeige gut lesbar bleibt.

Screenshot aus dem Spiel mit aktiviertem Effekt Neon Phosphor.
Astra das Spiel untersuchen und selbst spielen lassen
Ich spielte weiterhin selbst, aber Astra sollte Probleme auch anhand von mehr als nur meiner Beschreibung untersuchen können. Über eine kleine JavaScript-Schnittstelle, window.__VOID_EXPLORER__, können Browsertests den aktuellen Spielzustand abfragen. Sie erfahren, welchem Himmelskörper ich mich nähere, in welchem Flugmodus ich bin, ob das Gelände bereitsteht und welche Kamera aktiv ist. Die Schnittstelle liefert auch Kennzahlen zu Rendering und Streaming, darunter Draw Calls, die Anzahl der Dreiecke, anstehende Aufträge zur Geländegenerierung und gepufferte Geländedaten.
Im Spiel gibt es benannte Testszenen für den Flug im Orbit, den Pulsflug, den Sinkflug durch die Atmosphäre und die Landung an einer Küste. Damit kann Astra zu einem geeigneten Ausgangspunkt zurückkehren, ohne jedes Mal quer durchs Universum fliegen zu müssen. Playwright kann eine Szene laden, warten, bis das Gelände bereitsteht, einen Screenshot aufnehmen und den zugehörigen Spielzustand prüfen. Separate Tests für den Reiseverlauf nutzen die tatsächliche Spielsteuerung und zeichnen während des Spiels Positionen und Zustandsänderungen auf. So prüfen wir neben der vorbereiteten Landungsszene auch die Landung selbst.
Die Tests decken Landen, Aussteigen, Gehen, Speichern und erneutes Laden, Einsteigen und Abheben ab. Sie können Probleme aufdecken, die auf einem Screenshot verborgen bleiben. Beispielsweise ist eine Kollisionsfläche noch nicht bereit oder das Schiff springt bei einem Übergang von einer Position zur anderen.
Ich konnte Astra auch bitten, den Browser-Tab zu untersuchen, in dem ich gerade spielte. Als ich fragte, ob Aurelias Wolken noch sichtbar waren, nahm Astra meine aktuelle Ansicht auf und las die Fluginformationen auf dem Bildschirm ab. Das waren gezielte Prüfungen zu einzelnen Zeitpunkten. Astra beobachtete nicht fortlaufend jedes Bild meines Flugs.
Unser Ablauf war immer ähnlich. Wir reproduzierten das Problem, untersuchten Screenshots und Spielzustand, verfolgten die Ursache im Code, nahmen eine Änderung vor und wiederholten die Prüfung. Bei einem weiteren Spiel würde ich solche Werkzeuge früh entwickeln. Dazu gehören einige reproduzierbare Szenen, aussagekräftige Zustands- und Leistungsdaten sowie Browsertests für die wichtigsten Interaktionen. Damit kann Astra Probleme selbstständig untersuchen und Änderungen testen, während ich weiterhin die Grafik beurteile und die Steuerung ausprobiere.
Das Universum in mehreren Maßstäben darstellen
Für Tausende Planeten müssen wir nicht Tausende detaillierte Meshes laden. Ein Planet besteht zunächst nur aus einer Beschreibung mit Radius, Umlaufbahn, Atmosphäre und Seed. Dank des Seeds lässt sich das Gelände reproduzieren. Das Spiel generiert die Geometrie in dem Gebiet, dem ich mich nähere. Wenn ich zurückkehre, kann es dieselbe Landschaft erneut erzeugen.
Ähnliche Sorgfalt erfordern die Koordinaten. Entfernungen von Lichtjahren und eine Person, die neben einem Schiff steht, liegen in völlig unterschiedlichen Größenordnungen. Würden wir die entsprechend großen Positionswerte direkt an die GPU übergeben, ginge die Präzision verloren, die wir in Bodennähe brauchen.
Astra trennte die physische Position im Universum von den Koordinaten für die Darstellung. Das Universum ist in große Zellen mit ganzzahligen Koordinaten unterteilt. Innerhalb jeder Zelle genügen kleine lokale Versatzwerte. Vor dem Rendern zieht das Spiel die Position des Beobachtungspunkts ab. Dadurch bleibt die Kamera im Koordinatenursprung, und nahe Objekte haben kleine Koordinatenwerte. Die angezeigten Entfernungen und die Größenverhältnisse bleiben konsistent.
Auch zeitlich müssen alle beweglichen Elemente zusammenpassen. Sterne, Planeten und Monde folgen analytisch berechneten Umlaufbahnen. Der Renderer berechnet ihre Positionen für denselben Simulationszeitpunkt wie die des Beobachtungspunkts. Ein gelandetes Schiff dreht sich mit dem Planeten. Die Positionen und Farben der Sterne bestimmen die Beleuchtung. Wenn ich auf einem Planeten zwei Sonnen untergehen sehe, sind das dieselben Sterne, die ich schon aus dem Orbit gesehen habe.
Ohne Unterbrechung bis zum Boden fliegen
Flug aus dem All zur Oberfläche eines Mondes in Void Explorer.
Bis der Übergang vom All zum Boden funktionierte, waren viele Anläufe nötig. Einer meiner Prompts entstand nach einem besonders flachen Anflug auf einen Planeten:
Wenn ich fast parallel zur Planetenoberfläche anfliege, kann ich immer noch zu schnell sein. Während das Gelände lädt, verschwindet der Planet fast vollständig. Wir müssen die Geschwindigkeitskurve und das Gelände-Streaming gemeinsam korrigieren. Könnte die Atmosphäre den Übergang von der niedrigen Detailstufe in der Ferne zum detaillierten Gelände weicher machen? Der Planet sollte beim Anflug nie verschwinden.
Die Flugsteuerung begrenzt die Geschwindigkeit bei flachen Anflügen jetzt gesondert. Die Obergrenze hängt von der Flughöhe und einer Schätzung der Umlaufgeschwindigkeit ab, die sich aus Radius und Schwerkraft des Planeten ergibt. In Bodennähe tastet die Steuerung zusätzlich das vorausliegende Gelände ab, um die Bremswirkung anzupassen.
Das Spiel nutzt mehrere Detailstufen, sogenannte LODs. Aus der Ferne erscheint ein Planet als facettierte Kugel, deren Darstellung wenig Rechenleistung erfordert. Sie dient als Platzhalter, auch Proxy genannt. Je mehr Platz der Planet auf dem Bildschirm einnimmt, desto mehr Details ergänzt der Renderer. Beim Anflug auf die Oberfläche aktiviert das Spiel das Gelände. Es entsteht aus sechs Würfelflächen, die auf eine Kugel projiziert werden. Jede Fläche lässt sich in vier kleinere Quadrate unterteilen, die sich wiederum genauso unterteilen lassen. So entsteht ein Quadtree.
Damit kann das Spiel das Gelände im sichtbaren Bereich und in Flugrichtung verfeinern, ohne eine erdgroße Oberfläche in der Auflösung zu generieren, die man zu Fuß braucht. In Bodennähe liefern lokale Geländestücke die feinere Geometrie rund um das Schiff und die Spielfigur.
Alle diese Darstellungen greifen auf dieselben Planetendaten zu. Eine gemeinsame Funktion kombiniert Kontinente, Gebirgskämme, Krater und kleinere Geländeformen. Sie liefert Höhen-, Gewässer- und Biomdaten sowie weitere Informationen für die Landschaft. Grobe und feine Meshes bilden diese Daten mit unterschiedlichen Auflösungen ab. Einheitliche Regeln für die Farbgebung sorgen dafür, dass der Planet auf jeder Detailstufe farblich stimmig aussieht.
Der Wechsel zwischen den Detailstufen ist genauso wichtig wie die Generierung. Die Fernansicht des Planeten bleibt sichtbar, bis alle sechs groben Geländeflächen bereitstehen. Eine Geländekachel bleibt so lange erhalten, bis alle vier Unterkacheln bereit sind. Während des Übergangs weisen komplementäre Pixelmasken jedes Pixel entweder der alten oder der neuen Oberfläche zu. So muss der Renderer den Planeten nicht als Ganzes durchsichtig machen, während die neue Oberfläche lädt.
Das Aussehen der Atmosphäre ändert sich mit der tatsächlichen Flughöhe, und die Wolken ziehen über die Landschaft des Planeten. Beides verbindet den Blick aus dem Orbit mit der Ansicht in Bodennähe. Der Renderer entfernt grobe Flächen nur dort, wo das feinere Gelände schon bereitsteht. Die Silhouetten von Bergen können sich allerdings noch verändern, wenn feinere Geometrie hinzukommt.
Für die Landung gelten strengere Anforderungen. Im Kontaktbereich müssen der sichtbare Boden, die Kollisionsdreiecke und die Gefahrenzonen durch Flüssigkeiten aus demselben Generierungslauf stammen und gleichzeitig bereitstehen. Für die Bewegung zu Fuß nutzt das Spiel Rapier in einer kleinen lokalen Physiksimulation. Die Landelogik des Schiffs prüft separat, wie seine Landefüße aufsetzen, wie steil das Gelände ist und ob die Bodenfreiheit ausreicht.
Hier gibt es eine bewusste Einschränkung. Die Planeten verwenden Höhenfelder mit genau einem Höhenwert pro Richtung vom Mittelpunkt zur Oberfläche. Das eignet sich für große Landschaften, ermöglicht aber keine Höhlen, Überhänge oder zerstörbaren Tunnel.
Messen, warum ein Frame so lange dauert
Manchmal sprach ich Grafik und Leistung gemeinsam an, weil mir beides beim selben Flug auffiel:
Kannst du dir ansehen, wie wir einen Planeten laden und rendern, während ich aus dem All Richtung Boden fliege? Die Kugel in der Ferne und das detaillierte Gelände passen optisch nicht zusammen. Der Übergang wirkt abrupt, besonders wenn sich die Farben ändern. Ich möchte verstehen, was diese sichtbaren Sprünge verursacht und wo wir beim Nachladen von Details Rechenaufwand sparen können. Der Sinkflug soll besser aussehen und flüssig laufen.
Astra las die Zähler des Three.js-Renderers aus, um Draw Calls, Dreiecke, Geometrien und Texturen zu untersuchen. Ein Playwright-Test erfasste 90 Zeitabstände zwischen Frames und gab neben den Zählerständen den Mittelwert und die Perzentile dieser Zeiten aus. Bei Grafikfehlern konnten Tests auch die gerenderten Pixel bei ein- und ausgeschaltetem Effekt vergleichen. Ein Beispiel war die Darstellung des Geländes mit und ohne die Maske, die überlappende Bodenflächen ausblendet. Damit ließ sich die Ursache für das Verschwinden des Bodens eingrenzen, ohne sich allein auf einen Screenshot der fehlerhaften Szene verlassen zu müssen.
Wie hilfreich diese Messungen waren, zeigte schon eine frühere Version des Schiffs. Als wir das prozedural erzeugte Schiff durch das erste in Blender erstellte AURORA-Modell ersetzten, stieg die Zahl der Dreiecke in der Szene, die Zahl der Draw Calls sank jedoch. Astra führte vor und nach der Änderung denselben Orbittest mit 90 Frames auf dem WebGPU-Backend aus:
| Messgröße | Vorher | Nachher |
|---|---|---|
| Draw Calls in der gesamten Szene | 119 | 77 |
| Dreiecke in der gesamten Szene | 48.809 | 61.092 |
| Mittlerer Zeitabstand zwischen Frames | 251,48 ms | 199,26 ms |
Für diesen Vergleich lief Chromium im Headless-Modus mit Software-Rendering über SwiftShader. Das weiter unten gezeigte vierflügelige Schiff entstand erst später. Die Messung erfasst die Veränderung in dieser Testumgebung. Die Bildrate auf meiner GPU lässt sich daraus nicht ablesen. Die Werkzeuge lieferten Astra Zeitmessungen aus dem Browser, gerenderte Bilder und Angaben zur Anzahl der Ressourcen. Einzelne GPU-Befehle und Shader-Laufzeiten erfassten sie nicht.
Astra untersuchte, was beim Laden und im Sinkflug passierte. Wie viel Geometrie entstand? Welche Datenmengen wurden zwischen den Workern und dem Renderer übertragen? Und wie oft wurden Geländeaufträge verworfen, bevor ihre Ergebnisse zum Einsatz kamen?
Eine Änderung bestand darin, die Detailstufe ferner Planeten nach ihrer Größe auf dem Bildschirm zu wählen. Ein Planet, der das ganze Bild ausfüllt, braucht sofort eine klare Silhouette. Für einen Planeten, der kleiner als ein Pixel erscheint, ist dieselbe Geometrie unnötig. In einem kontrollierten Vergleich der Startszene genügten mit der neuen Regel 7.040 statt 51.200 Proxy-Dreiecke. In beiden Fällen erzeugte derselbe Code die Geometrie. So ließ sich die Auswirkung der Ladeentscheidung isoliert betrachten.
Bei einer weiteren Verbesserung blieb die Zahl der Geländedreiecke exakt gleich. Indizierte Meshes verwenden gemeinsame Eckpunkte benachbarter Dreiecke mehrfach. Dadurch müssen Position, Farbe und Normale dieser Eckpunkte nur einmal gespeichert werden. Im Test mit hoher Geländequalität sank das übertragene Puffervolumen für die sechs Bodenschichten von etwa 35 MB auf 15 MB, bei unverändert 241.952 Dreiecken. Außerdem teilten wir die Generierung von Boden und Umgebungselementen in separate Aufträge auf. So konnte die Bodengeometrie bereitstehen, bevor die dekorativen Elemente fertig waren.
Auch bei der Auswahl der Geländestücke fiel unnötige Arbeit an. Der Auswahlalgorithmus konnte Teilstücke anfordern, seine Entscheidung ändern, die Teilstücke verwerfen und Ersatz anfordern. Astra sorgte dafür, dass die Entscheidungen zur Verfeinerung stabiler blieben. Eine Kachel wurde nur noch unterteilt, wenn das Budget für alle vier Unterkacheln reichte. In einer kontrollierten Simulation mit fester Worker-Latenz folgten auf sechs Sekunden Sinkflug drei Sekunden Stillstand, in denen sich der Zustand stabilisieren konnte. Dabei wurden 13 statt 6.074 Aufträge verworfen.

In einer kontrollierten Simulation mit zwei Workern und einer simulierten Worker-Latenz von 100 ms sank die Zahl der eingeplanten und wieder verworfenen Aufträge von 6.074 auf 13. Gemessen wurde die Auftragsplanung für das Gelände. Die Bildrate wurde dabei nicht erfasst.
Worker allein verhindern nicht jeden Ruckler. Auch die Ersatzroutine für das Gelände auf dem Haupt-Thread musste zwischendurch Rechenzeit abgeben. Astra zerlegte die Generierung in Schritte, die sich unterbrechen und fortsetzen lassen, mit einem Zeitbudget von rund 4 ms pro Frame. So musste ein großer Geländeauftrag nicht mehr in einem Zug fertig werden. Der Renderer begrenzt außerdem die Auflösung der Spielwelt unabhängig von der Auflösung der Benutzeroberfläche. Dadurch bleibt der Text der Navigationsanzeige auch bei reduzierter Grafikqualität scharf.
Die Geländemessungen zeigen, dass weniger Geometrie erzeugt, weniger Daten übertragen und weniger Aufträge verworfen werden. Sie liefern keine Benchmarks für die Bildrate auf echter Grafikhardware. Spieltests im Browser bleiben wichtig, um die Shader-Kompilierung, die Datenübertragung zur GPU, die Bewegung im Spiel und das tatsächliche Aussehen des Übergangs zu beurteilen.
Mein Beitrag war die Rückmeldung aus dem Spiel. Was fühlte sich langsam an? Was sah falsch aus? Was wollte ich verbessern? Astra ging den Ursachen im Code nach, schrieb Skripte für reproduzierbare Geländetests und zeichnete die Messwerte auf. Sobald ich mit dem Ansatz einverstanden war, setzte Astra die Änderungen um und wiederholte dieselben Tests, um die Ergebnisse zu vergleichen. Ich musste weder bei der Untersuchung noch bei der Umsetzung jeden Schritt vorgeben und konnte mich weiter darauf konzentrieren, wie das Spiel aussah und sich anfühlte.
Von der Konzeptgrafik zum Spielmodell
Der größte Teil des Universums entsteht im Code, darunter Planeten, Gelände, Wolken, Ringe und Sterne. Das Schiff, das man selbst steuert, ist das wichtigste eigens modellierte 3D-Objekt. Dafür wählte ich einen anderen Ansatz.
Bevor das Schiff ins Spiel kam, beurteilte ich es anhand generierter Entwürfe und gerenderter Ansichten aus Blender. Als die Flügel nicht meinen Vorstellungen entsprachen, bat ich um aussagekräftigere Vorlagen:
Erstelle übersichtliche Ansichten dieses Schiffs aus mehreren Blickwinkeln. Achte besonders auf die vorderen und hinteren Flügel. Anhand dieser Bilder wollen wir das 3D-Modell neu erstellen. Die miteinander verbundenen, abgerundeten Flügel am aktuellen Modell gefallen mir nicht.
Ich wählte den symmetrischen Entwurf mit vier separaten Flügeln und rosa Lichtern an den Flügelspitzen. Dann bat ich Astra, danach ein neues Modell in Blender zu erstellen, den grafischen Stil des Spiels beizubehalten und das Modell ins Spiel zu integrieren.
Dazu mussten wir die Vorlage in Geometrie umsetzen, Silhouette und Materialien prüfen und das Modell für den Einsatz im laufenden Spiel aufbereiten. Die Blender-Quelldatei enthält 193 bearbeitbare Meshes. Das exportierte Schiff hat 14.968 Dreiecke, zusammengefasst in acht Batches für undurchsichtige Materialien. So konnte ich mir mehr Details für das Modell wünschen, während Astra den Rendering-Aufwand für die exportierte Version im Blick behielt.

Für diesen generierten Schiffsentwurf habe ich mich entschieden.

Eine in Blender gerenderte Ansicht des Modells, das im Spiel zum Einsatz kommt.
Mit prozedural generiertem Wasser experimentieren
Auch in Sunwake habe ich viel mit Wasser experimentiert. In diesem Spiel steuerst du ein kleines Boot über einen prozedural generierten Ozean. Ich wollte facettierte Wellen, fließende Bewegungen und die Farben von Buntglas. Astra entwickelte dafür in Three.js einen eigenen Wasser-Renderer. Dasselbe Wellenmodell bestimmt, wie das Meer aussieht und welchen Auftrieb das Boot erfährt. Der Rumpf hebt sich, stampft und rollt mit den Wellen. Eine lokale Simulation lässt kleine Wellen und Schaum über das Wasser wandern. Das Boot zieht eine Heckwelle hinter sich her und wirbelt Gischt auf. Später bat ich Astra, in Blender ein detaillierteres Boot zu modellieren und es ins Spiel zu integrieren. Der Ansatz ist derselbe wie bei Void Explorer. Die Simulation verbindet eine prozedural generierte Umgebung mit einem eigens modellierten Fahrzeug.

Sunwake verbindet einen prozedural generierten Ozean mit einem eigens in Blender modellierten Boot.
In Hollowflux ging ich in eine andere Richtung. Dieses kleine 2D-Action-Rollenspiel spielt an einem leuchtenden unterirdischen Fluss. Höhlen, Figuren und Ausrüstung zeichnet der Code ohne importierte Sprite-Sheets. Ich bat Astra wiederholt, das Wasser beim Gehen, bei schnellen Vorstößen und bei Angriffen glaubwürdiger reagieren zu lassen. Ein Raster erfasst für jede Zelle Wasserstand, Strömung, Schaum und elektrische Ladung. Schritte hinterlassen kleine Wellen, Speerstöße ziehen schmale Furchen durchs Wasser, und Hammerschläge lösen ringförmige Wellen aus. Die Strömung verwirbelt an den Ufern und trägt den Schaum flussabwärts. Dieselbe Strömung erfasst auch die Spielfigur und ihre Gegner. Das Wasser beeinflusst sogar den Kampf. Der Stromstoß eines Aals breitet sich über zusammenhängende Wasserflächen aus. Wer auf einen trockenen Stein tritt, ist vor diesem Stromstoß geschützt.

In Hollowflux zeichnet der Code die Spielgrafik. Das Wasser reagiert auf Bewegungen und Angriffe.
Spiele entwickeln und teilen
Was mir an der Arbeit mit Astra gefällt: Ich kann mit dem gewünschten Spielerlebnis anfangen, meine Vorstellungen von der Grafik mit Bildern konkretisieren und beim Spielen Rückmeldung geben. Wenn ich melde, dass ein Planet verschwindet, kann das zu Änderungen am Streaming, an der Geometrie und an der Bewegung führen. Aus dem Wunsch nach glaubwürdigerem Wasser kann eine Simulation entstehen, auf die Grafik und Spielmechanik gemeinsam zugreifen. Ob sich das Ergebnis richtig anfühlt, muss ich weiterhin selbst entscheiden. Astra kann diese Entscheidungen dann im Code, in den Spielressourcen und in den Tests umsetzen.
Ein Browserspiel lässt sich auch unkompliziert teilen. Mit dem Sites-Plugin kannst du Astra darum bitten:
Veröffentliche das Spiel mit öffentlichem Zugriff. Dann können alle direkt im Browser spielen.
Du kannst Void Explorer, Sunwake und Hollowflux in deinem Browser spielen.
Wenn dir schon länger eine Spielidee im Kopf herumgeht, entwickle mit Astra eine kleine spielbare Version. Such dir zuerst eine Sache aus, die sich beim Spielen richtig anfühlen soll. Gib Astra ein paar visuelle Vorlagen und probiere das Ergebnis aus. Ein Boot, ein Raum oder eine einzelne Interaktion reicht für den Anfang. Spiel selbst, beschreibe genau, was du ändern möchtest, und entwickle das Spiel von dort aus weiter.