NEU: Teste die Parsed Events Scan API
Gaming: Wie Solana das Spielfeld verändert
Blog/Forschung

Gaming: Wie Solana das Spielfeld verändert

Developer Experience Engineer0xIchigo auf X0xIchigo auf LinkedIn0xIchigo auf GitHub
28 Min. Lesezeit
Inhaltsverzeichnis

Worum geht es in diesem Artikel?

Nicht deine Schlüssel, nicht deine Kryptowährung. Dieser Grundsatz ist zentral für das Ethos von Kryptowährungen und genauso relevant für Videospiele. Blockchains in die Gaming-Landschaft zu integrieren, ist mehr als eine Innovation. Es ist ein Paradigmenwechsel, der dezentrales Eigentum an Assets und Autonomie ermöglicht. Solana steht an der Spitze dieses Wandels. Es bietet die schnellste Smart-Contract-Plattform, um die Vorteile von Web3 zu nutzen. Dank der hohen Geschwindigkeit, der niedrigen und vorhersehbaren Gebühren sowie der geringen Latenz von Solana können Entwickler einzigartige Spielerlebnisse schaffen, die anderswo nicht möglich sind.

Dieser Artikel untersucht das Potenzial von Blockchain im Gaming. Er beleuchtet die Argumente für Web3-Gaming und erklärt, warum Spieleentwickler auf Solana entwickeln sollten. Außerdem behandelt er die Installation, Konfiguration und Nutzung beliebter Frameworks und Plattformen für Spiele mit Solana-Integration.

Warum Web3-Gaming?

Für Spieler

Die Sammlerstücke keines anderen Videospiels reichen an Counter-Strike heran. Je nach Seltenheit und Float können einige der seltensten Skins in Counter Strike 2, also kosmetische Waffenobjekte im Spiel, Tausende Dollar wert sein. Neon, ein bekannter Händler in der Counter-Strike-Community, besaß ein Skin-Inventar im Wert von über 100.000 US-Dollar. Am 13. Oktober 2023 wurde er fälschlicherweise gesperrt, nachdem er AMDs Anti-Lag+-Funktion aktiviert hatte. Die Sperre erfolgte durch Valves Anti-Cheat-System (VAC). Eine VAC-Sperre macht das Inventar eines Spielers unverkäuflich. Neons Inventar im Wert von 100.000 US-Dollar war damit dauerhaft an sein Konto gebunden. Valve hat offiziell auf das Problem reagiert, und glücklicherweise konnte Neon seine Sperre aufheben lassen. Counter-Strike 2 hat weiterhin Probleme mit fälschlichen Spielsperren.

Auf einer traditionellen Gaming-Plattform wie Steam besteht immer das Risiko, den Zugriff auf gekaufte Spiele oder Sammlerstücke zu verlieren. Nichts hindert Valve daran, dir deine Assets wegzunehmen. Wegen des enormen Reputationsschadens und des möglichen Verlusts ganzer Spielergruppen erscheint das unwahrscheinlich. Valve könnte jedoch die Drop-Raten seltener Gegenstände erhöhen und dadurch ihren Wert senken. Genau das ist bei Team Fortress 2 passiert. Unabhängig vom Wert werden jedes gekaufte Spiel und jeder gesammelte Gegenstand von einer zentralisierten Instanz verwaltet. Spieler sind den Spielekonzernen ausgeliefert. Selbst Ethereum entstand wegen des World-of-Warcraft-Patches 3.10. Vitalik Buterin hat ausführlich über die „Schrecken der Zentralisierung“ gesprochen, nachdem Blizzard den Lebensentzug-Zauber seines Charakters abgeschwächt und damit Jahre seiner Spielzeit ruiniert hatte. Spieler haben es satt, zentralisierten Instanzen ausgeliefert zu sein. Web3-Gaming bietet einen Ausweg.

Web3-Gaming ist ein Paradigmenwechsel. Es nutzt Blockchain-Technologie, um das Eigentum an Assets und Entscheidungsprozesse zu dezentralisieren. Es schafft Transparenz und Sicherheit, während Spieler plattformübergreifend tatsächlich Eigentümer ihrer Assets im Spiel sind. So entstehen virtuelle Ökonomien wie der Skin-Markt von Counter-Strike, ergänzt um Transparenz, Sicherheit und Komponierbarkeit. Diese Ökonomien ermöglichen neue nutzerzentrierte Gaming-Modelle wie Play-to-Earn (P2E), bei denen Spieler für ihre Spielaktivität mit realem Gegenwert belohnt werden.

Das ist alles andere als ein Nischenkonzept. Mehrere erfolgreiche und einflussreiche Spiele zeigen, dass Web3-Gaming die Branche revolutionieren kann. Decentraland bietet beispielsweise eine virtuelle Welt, in der Spieler Immobilien als NFTs kaufen, verkaufen und entwickeln können. Tokens.com zahlte über 2 Millionen US-Dollar für Immobilien im Stadtzentrum von Decentraland. Das zeigt die Möglichkeiten virtueller Ökonomien, digitaler Erlebnisse und persönlicher Räume im Web3-Ökosystem. Auch Play-to-Earn-Spiele wie Axie Infinity und Lifestyle-Apps wie STEPN, eine Move-to-Earn-Plattform, haben international Aufmerksamkeit erregt. Sie zeigen, wie Spieler durch Spielen Einkommen erzielen können. Spiele wie Star Atlas und Aurory waren auf Solana ähnlich erfolgreich. Das sind keine Einzelfälle. Sie sind Teil eines größeren Trends, bei dem Gaming über Unterhaltung hinausgeht und mit realen Wirtschafts- und Sozialsystemen verschmilzt.

Für Entwickler

Web3-Gaming eröffnet Spieleentwicklern neue Möglichkeiten, die weit über die Grenzen des aktuellen Gaming-Paradigmas hinausgehen:

  • Tiefere Märkte und Vertrauensgarantien: Web3-Gaming schafft tiefere, robustere Märkte. Spieleentwickler können ein globales Publikum erreichen, dessen Teilnehmer mit größerem Vertrauen interagieren. Sämtliche Eigentumsverhältnisse und Transaktionen im Spiel sind überprüfbar und unveränderlich. Das ermöglichen die inhärente Transparenz und Sicherheit von Blockchains.
  • Bestehende On-Chain-Programme nutzen: Entwickler können bestehende Programme und die zugehörigen Assets einfach in ihr Spiel integrieren. Das verkürzt die Markteinführungszeit und lässt Spieleentwicklern durch die Zusammenarbeit im Ökosystem mehr Raum für Kreativität und Innovation.
  • Innovationen bei Ökonomie und Gameplay: Spieleentwickler können komplexe Spiel- und Wirtschaftskreisläufe entwerfen, die andere On-Chain-Anwendungen oder -Erlebnisse nutzen. Diese Vernetzung ermöglicht vielfältige, dynamische Spielwelten, in denen Aktionen in einem Spiel Auswirkungen auf ein anderes haben können.
  • Modding fördern: Die Offenheit der Blockchain gibt Spieleentwicklern die Möglichkeit, Spiele gezielt moddingfreundlich zu gestalten. Das kann Innovationen aus der Community fördern, bei denen Spieler zur Weiterentwicklung des Spiels beitragen. So wechselt die Entwicklung von einer geschlossenen Umgebung zu einem kollaborativen, Community-zentrierten Modell.

Blockchains bieten mehr als nur eine Plattform für die Entwicklung von Spielen. Sie ermöglichen völlig neue Formen interaktiver digitaler Erlebnisse. Blockchains ebnen den Weg für ein dynamischeres, partizipativeres Gaming-Ökosystem.

Warum auf Solana entwickeln?

Niedrige und vorhersehbare Transaktionsgebühren sind für Web3-Gaming entscheidend. Spieler wollen keine überhöhten Gebühren zahlen, um ein Spiel zu spielen. Solana bietet niedrige Transaktionsgebühren, die oft unter 0,001 US-Dollar liegen. Die durchschnittliche Gebühr für Transaktionen ohne Abstimmung bewegt sich zwischen 0,000005 und 0,00007 SOL. Dank lokaler Gebührenmärkte sind diese Gebühren zudem vorhersehbar. Sie isolieren Überlastungen, sodass nur Transaktionen mit höheren Gebühren belastet werden, die auf stark nachgefragte Zustandsbereiche zugreifen. Das unterscheidet Solana von Gas-basierten Netzwerken wie Ethereum. Dort sind Transaktionsgebühren unvorhersehbar und können bei hoher Auslastung selbst für eine einfache Transaktion über hundert Dollar betragen.

Die Architektur von Solana bietet beispiellose Komponierbarkeit. Für Spieler bedeutet das eine optimierte Benutzererfahrung mit einer einzigen Wallet. Sie müssen sich nicht mit dem komplexen Bridging zwischen verschiedenen Plattformen befassen. Im Solana-Ökosystem ist alles zugänglich und miteinander verbunden. Spieleentwicklern eröffnet die Komponierbarkeit zahlreiche Möglichkeiten. Sie können bestehende On-Chain-Programme mühelos integrieren und nutzen, etwa bei der Partnerschaft zwischen The Remnants und Magic Eden. Dadurch wird die Liquidität von Spiel-Assets nicht auf verschiedene L2s oder Shards verteilt. Solana fördert ein komponierbares Ökosystem, in dem Spiele, Communities und andere Anwendungen im Netzwerk nahtlos zusammenarbeiten können.

Hohe Geschwindigkeit und geringe Latenz sind für Gaming unverzichtbar. Langsame Transaktionen können Aktualisierungen des Spielzustands behindern, unerträgliche Verzögerungen und lange Wartezeiten verursachen. Das würde eine schlechtere Benutzererfahrung als bei traditionellen Spielen schaffen. Solana ist auf hohen Transaktionsdurchsatz ausgelegt. Das Netzwerk verarbeitet durchschnittlich 400 nutzergenerierte Transaktionen pro Sekunde (TPS) und erreicht bei hoher Nachfrage mehr als 2.000 TPS. Mit Innovationen wie Firedancer hat Solana das Potenzial, jede traditionelle Anwendung für Endnutzer zu skalieren. Solana strebt außerdem eine Slot-Zeit von 400 Millisekunden an. Das ist die Zeit, die jedes Ledger benötigt, um Transaktionen aufzunehmen und einen Block zu erzeugen. Je nach Netzwerkauslastung kann sie zwischen 500 und 600 Millisekunden liegen. Damit ist Solana die schnellste verfügbare Blockchain. Das macht sie zu einer perfekten Echtzeitdatenbank für Genres wie Strategiespiele, rundenbasierte Spiele, Städtebauspiele und Idle-Games.

Forever Games sind vollständig On-Chain ausgeführte Spiele. Sie stellen den extremsten Fall einer Blockchain-Integration dar: Zustand und Logik eines Spiels laufen vollständig auf der Blockchain. So entsteht ein dauerhaft verfügbares Spiel, das mit einem umfangreichen System aus Protokollen, dApps und Programmen verbunden ist und eine niedrige Einstiegshürde bietet. Beispiele auf Solana sind:

Als Spieler klingt eine Reaktionszeit von 400 Millisekunden für Echtzeit-Rennspiele oder Shooter furchtbar. Es muss jedoch nicht alles direkt On-Chain gespeichert werden. Kleinere Integrationen lassen sich schnell umsetzen. Dazu gehören NFTs für Gegenstände im Spiel, Token für In-App-Käufe oder die Wallet eines Spielers zur Authentifizierung. Dir stehen zahlreiche Tools zur Verfügung, mit denen du noch heute Solana integrieren kannst.

Tools für die Entwicklung von Solana-Spielen

Dieser Artikel betrachtet mehrere beliebte Frameworks und Plattformen für die Entwicklung von Spielen mit Solana-Integration. Aus Platzgründen behandeln wir einige Tools nicht, haben sie aber unten im Abschnitt mit zusätzlichen Ressourcen verlinkt. Dazu gehören der Godot Solana SDK und das Phaser 3 TypeScript Starter Template. In diesem Artikel zeigen wir, wie du folgende Tools installierst, konfigurierst und verwendest:

Anchor

Frameworks wie Anchor erleichtern die On-Chain-Entwicklung eines Spiels erheblich. Anchor ist ein robustes Framework, mit dem sich sichere Programme schnell entwickeln lassen. Es vereinfacht den Entwicklungsprozess, indem es Boilerplate reduziert, verschiedene Sicherheitsprüfungen übernimmt, die Generierung von Clientbibliotheken automatisiert und eine umfassende Testumgebung bietet. Am einfachsten entwickelst du ein vollständig On-Chain ausgeführtes Spiel, indem du seine Logik und seinen Zustand in einem Anchor-Programm speicherst. Anchor abstrahiert die Komplexität des Low-Level-Programmiermodells von Solana. So können sich Entwickler stärker auf die Spieleentwicklung konzentrieren, statt mit der SVM zu kämpfen.

Installation

Für Anchor benötigst du Rust. Du kannst es hier oder mit dem folgenden Befehl installieren:

Code
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Anchor empfiehlt Rust-Einsteigern außerdem, die ersten neun Kapitel des Rust-Buchs zu lesen. Sie behandeln die Grundlagen, da du für Anchor-Programme meist keine fortgeschrittenen Rust-Kenntnisse brauchst.

Anchor benötigt außerdem die Solana Tool Suite:

Code
# macOS and Linux
sh -c "$(curl -sSfL https://release.solana.com/v1.17.7/install)"

# Windows
cmd /c "curl https://release.solana.com/v1.17.7/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"

Führe den Befehl solana --version aus, um zu prüfen, ob deine gewünschte Version von solana installiert ist.

Du benötigst außerdem Yarn. Installiere es mit dem npm-Paketmanager: npm install --global yarn.

Wir empfehlen, Anchor mit dem Anchor Version Manager (avm) zu installieren. Installiere ihn mit cargo: cargo install --git <https://github.com/coral-xyz/anchor> avm --locked --force. Anschließend können wir die neueste Version installieren und verwenden:

Code
avm install latest
avm use latest

# Verify the installation
avm --version

Die Anchor-Dokumentation bietet außerdem eine ausführliche Installationsanleitung.

Verwendung und Beispiele

SolanaCiv wurde mit Anchor vollständig On-Chain entwickelt. Ressourcen verwalten, Einheiten rekrutieren, neue Technologien erforschen, Barbaren bekämpfen und handeln: All das geschieht On-Chain. Außerdem ist das Spiel Open Source. Du kannst es daher als Referenz verwenden, um Logik und Zustand eines Spiels aufzuschlüsseln und zu sehen, wie alles On-Chain gespeichert wird.

Clockwork ist eine Open-Source-Automatisierungs-Engine für Solana. Sie ist besonders für die Spieleentwicklung nützlich, da sie die Planung von Transaktionen und die Entwicklung automatisierter, ereignisgesteuerter Programme ermöglicht. Installiere sie mit dem Befehl cargo install -f --locked clockwork-cli. Sie lässt sich gut mit Anchor integrieren. Eine Liste mit Anwendungsbeispielen für Clockwork findest du hier.

Solana Playground ist eine browserbasierte Entwicklungsumgebung zum Testen und Bereitstellen von Programmen. Die integrierte Entwicklungsumgebung (IDE) eignet sich ideal für Entwickler, die neu bei Anchor sind und die Entwicklung von Solana-Spielen lernen möchten. Sie bietet mehrere Anchor-Tutorials für On-Chain-Gaming. Tiny Adventure ist beispielsweise ein einsteigerfreundliches Tutorial für ein On-Chain-Spiel. Es zeigt dir, wie du mit Anchor eine Spielfigur nach links und rechts bewegst und mit einer Program Derived Address (PDA) Spieldaten speicherst. Außerdem lernst du, wie du mit dem Solana Wallet Adapter ein Frontend in Next.js einrichtest. Den fertigen Code findest du hier.

Wenn du schnell ein Anchor-Programm mit einem TypeScript-Client erstellen möchtest, verwende den Befehl npx create-solana-game gefolgt vom Namen deines Spiels. Dieser Befehl optimiert die Entwicklung mit Anchor und TypeScript und strukturiert ein komplett neues Projekt. Das Tool wurde von Jonas Hahn und Beeman entwickelt. Du findest es im GitHub-Repository solana-developers.

Turbo

Turbo ist eine 2D-Spiele-Engine und ein Marktplatz der nächsten Generation für Indie-Entwickler. Turbo bietet mehrere innovative Funktionen:

  • Spiele werden bei Änderungen an Code, Shadern oder Sprites automatisch neu geladen
  • Spiele laufen ohne Benutzeroberfläche, damit du den Spielzustand auf Remote-Servern überprüfen kannst
  • Die Engine basiert auf WebAssembly und WebGPU und läuft dadurch auf jeder Plattform
  • Die integrierten APIs der Engine sind einsteigerfreundlich

Jozanza entwickelt Turbo in Rust. Deshalb können Entwickler Anchor-Strukturen problemlos in ihren Programmen wiederverwenden, ohne SDKs oder Plugins zu benötigen. Das Projekt befindet sich noch in einer frühen Entwicklungsphase. Die Website enthält jedoch mehrere direkt im Browser ausführbare Beispiele, die die Leistungsfähigkeit und intuitive Entwicklererfahrung von Turbo zeigen. Eine Anleitung für „Hallo, Welt!“ findest du außerdem hier.

Installation

Um Turbo zu verwenden, müssen wir zunächst alle relevanten Rust-Abhängigkeiten installieren:

Code
# Download and run the rust installer
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add wasm targets
rustup target add wasm32-unknown-unknown wasm32-wasi

# Install cargo-watch
cargo install cargo-watch

Danach laden wir das Installationsprogramm für die Turbo-Befehlszeilenschnittstelle (CLI) herunter und führen es aus:

Code
sh -c "$(curl -sSfL https://turbo.computer/install.sh)"

Nach Abschluss der Installation prüfen wir mit dem Befehl turbo-cli -h, ob die Turbo CLI korrekt installiert ist. Der Befehl sollte die Nutzungshinweise für Turbo anzeigen:

Code
Run Turbo games natively on desktop

Usage: turbo-cli

Commands:
  init  Initializes a new Turbo project in Rust
  run   Runs a Rust Turbo project
  help  Print this message or the help of the given subcommand(s)

Options:
  -v, --version  Print version
  -h, --help     Print help
  -V, --version  Print version

Entwicklungsprozess

Turbo bietet mehrere Makros, die den Entwicklungsprozess vereinfachen. Rust-Makros sind leistungsfähige Metaprogrammierungswerkzeuge zur Codegenerierung, also Code, der anderen Code schreibt. Sie helfen dabei, Boilerplate zu reduzieren und ausdrucksstärkere Codemuster zu ermöglichen.

Das Makro println ist eine benutzerdefinierte Implementierung des Standardmakros println. Es formatiert einen String und übergibt ihn anschließend an das Protokollierungssystem der Spiele-Engine:

Code
macro_rules! println {
    ($fmt:expr $(, $($arg:tt)*)?) => {
        $crate::sys::log(&format!($fmt, $($($arg)*)?))
    };
}

Das Makro cfg wird zur Konfiguration verwendet. Es stellt die Funktion config bereit. Diese gibt eine 64-Bit-Ganzzahl zurück, die einen Zeiger auf einen Konfigurations-String mit dessen Länge kombiniert. Das ist nützlich, um Konfigurationsdaten von Rust an eine andere Umgebung wie WebAssembly zu übergeben:

Code
macro_rules! cfg {
    ($toml:expr) => {
        #[no_mangle]
        pub unsafe extern "C" fn config() -> u64 {
            let ptr = $toml.as_ptr() as u64;
            let len = $toml.len() as u64;
            (len << 32 | ptr)
        }
    };
}

Das Makro init ist für die Verwaltung des Spielzustands nützlich. Es definiert eine Struktur und stellt Methoden zum Laden und Speichern ihres Zustands bereit. Mithilfe von Borsh implementiert es für die Struktur die Methoden load und save, um den Zustand dauerhaft zu speichern:

Code
macro_rules! init {
    (struct $StructName:ident { $($fields:tt)* } = $default:expr) => {
        ...
    };
}

Das Makro go definiert die Hauptlogik eines Spiels. Es umschließt einen Codeblock mit einer Funktion, die sich aus einer externen Umgebung wie WebAssembly aufrufen lässt. Außerdem definiert es einen Einstiegspunkt für die Spiellogik sowie eine Funktion run_snapshot, die das Spiel mit einer Momentaufnahme seines Zustands ausführt:

Code
macro_rules! go {
    ($($body:tt)*) => {
        use $crate::prelude::*;

        #[no_mangle]
        #[allow(overflowing_literals, non_upper_case_globals)]
        pub unsafe extern "C" fn run() {
            use std::f32::consts::PI;
            $($body)*
        }
        pub fn run_snapshot(snapshot_data: &[u8]) -> Vec {
            $crate::run_snapshot(snapshot_data, || unsafe { run() })
        }
    };
}

Turbo verwendet außerdem das Makro strike aus dem struckstruck-Crate, um die Möglichkeiten zur Definition von Rust-Strukturen zu erweitern. Normalerweise musst du verschachtelte Strukturen separat definieren. Mit dem Makro strike kannst du eine Struktur samt verschachtelter Strukturen inline definieren. Diese Funktion vereinfacht den Code und macht komplexe Datenstrukturen lesbarer und kompakter. Außerdem wendet sie automatisch die Borsch-Serialisierung auf die gesamte Struktur an. Das Derive-Makro der obersten Struktur wird zudem auf alle verschachtelten Strukturen übertragen.

Der gesamte Entwickler-Workflow für ein Turbo-Projekt sieht somit wie folgt aus:

Code
// Defne the game configuration using the turbo::cfg! macro
turbo::cfg! {r#"
    name = "Grand Theft Auto VI"
    version = "1.0.0"
    author = "Ichigo"
    description = "Vice City but pixelated"
    [settings]
    resolution = [256, 144]
    tile_size = [32, 32]
"#}

// Define the game state initialization using the turbo::init! macro
turbo::init! {
	...
}

// Implement the game loop using the turbo::go! macro
turbo::go! {
	// Load the game state
	let mut state = GameState::load();
	...
}

Solana-Unterstützung

Turbo unterscheidet sich von anderen Rust-basierten Engines für die Spieleentwicklung, da es Solana vollständig unterstützen wird. Beispielsweise kann es Kontodaten von einem RPC abrufen und mit nur zwei Codezeilen decodieren. Außerdem abonniert es über WebSockets automatisch Kontoaktualisierungen, sodass deine Daten immer aktuell bleiben:

Code
// Get the Solana account data
let response = solana::get_account("pubkey");

// Decode the account data
let decoded = response.decode_anchor::();

// And now we can work with on-chain data!
if let Ok(data) = decoded {
	...
}

Magicblock

Magicblock ist ein vielseitiges Open-Source-Framework für die Entwicklung von On-Chain-Spielen. Damit kann jeder Spiele auf Solana oder der SVM entwickeln und spielen. Das umfangreiche Toolset ermöglicht Entwicklern, vollständig On-Chain ausgeführte Spiele zu entwickeln oder Solana in bestehende Spiele zu integrieren. Es umfasst folgende Funktionen:

Mit all diesen Funktionen will Magicblock die Komplexität abstrahieren, damit sich Entwickler auf die bestmögliche Benutzererfahrung konzentrieren können. Das MIT-lizenzierte Framework wird von Magicblock Labs gepflegt, also von Andrea und Peak.

Solana Unity SDK

Das Solana Unity SDK ist ein Open-Source-Paket mit Tools, mit denen Spieleentwickler Solana-basierte NFTs, Token und On-Chain-Programme in ihre Unity-Spiele integrieren können. Das SDK nutzt Solana Unity Core, ein mit .NET Standard 2.0 kompatibles Framework, das Solana in das .NET-Ökosystem integriert. Es bietet zahlreiche Funktionen, darunter die vollständige Abdeckung der JSON RPC API, die Dekompilierung von Anweisungen, Unterstützung für Solana Mobile Stack und native DEX-Operationen.

Eine Liste mit Beispielspielen, die in Unity mit dem Solana Unity SDK entwickelt wurden, findest du hier.

Installation, Konfiguration und Verwendung

Um mit Unity zu entwickeln, lade hier den Unity Hub herunter. Der Unity Hub verwaltet mehrere Installationen des Unity Editors. So kannst du versionsübergreifend an Projekten arbeiten und neue Projekte erstellen. Bevor du fortfährst, prüfe, ob dein System folgende Anforderungen erfüllt:

  • Betriebssystem: Windows 7 SP1+, 8 oder 10, nur 64-Bit-Versionen; Mac OS X 10.13+; Ubuntu 16.04 oder 18.04 sowie CentOS 7
  • GPU: Eine Grafikkarte mit DX10-Unterstützung (Shader Model 4.0)

Nachdem Unity installiert ist, können wir ein neues Projekt erstellen und öffnen.

Öffne in deinem neuen Projekt das Package-Manager-Fenster. Du erreichst es über das obere Unity-Menü unter Window > Package Manager.

Klicke im geöffneten Fenster auf die Schaltfläche zum Hinzufügen (+) in der Statusleiste. Daraufhin erscheinen die Optionen zum Hinzufügen von Paketen. Wähle im Menü „Add package from git URL“ aus.

Gib die Git-URL https://github.com/magicblock-labs/Solana.Unity-SDK.git in das Textfeld ein und klicke auf „Add“. Um eine bestimmte Paketversion zu installieren, gib https://github.com/magicblock-labs/Solana.Unity-SDK.git#X.Y.Z ein und ersetze X.Y.Z durch die gewünschte Version. Alle verfügbaren Releases findest du hier.

Nachdem du das Solana Unity SDK installiert hast, importiere über den Package-Manager-Inspektor die Samples. Sie enthalten eine Beispielszene, die du als Referenz verwenden oder für die Integration in dein Unity-Projekt anpassen kannst. Die Szene befindet sich im Ordner Scenes und zeigt beispielhaft die Wallet-Authentifizierung sowie den Token-Tausch über Orca. Der Ordner Scripts enthält verschiedene Skriptbeispiele, darunter das Skript für Orca-Swaps. Du kannst das Skript Web3.cs an jedes Objekt in deinem Projekt anhängen. Dieses Skript ist der zentrale Einstiegspunkt für das Solana Unity SDK. Es ist ein Singleton, das die Verbindung zu Solana verwaltet und Wallet-Anmeldungen, das Signieren von Transaktionen und weitere Funktionen ermöglicht. Der Ordner Prefabs enthält Vorlagen, in denen Objektkonfigurationen gespeichert sind. Damit kannst du Instanzen desselben Assets erstellen und im gesamten Projekt wiederverwenden.

Der YouTube-Kanal von Magicblock bietet Tutorials zum Verbinden von Solana-Wallets mit Unity, zum Abrufen des öffentlichen Schlüssels und Guthabens einer Wallet, zum Durchführen von Tests mit Wallets im Spiel und zum Entwickeln einer On-Chain-Schach-Engine.

Das GitHub-Repository des Solana Unity SDK enthält außerdem mehrere Beispielskripte, die von der Dekodierung von Anweisungen bis zum Erstellen von Transaktionen reichen.

Beispielimplementierung mit Jupiter

Neben Orca wird Jupiter nativ im Solana Unity SDK unterstützt. Das SDK bietet Hilfsmethoden, um Swap-Angebote abzurufen sowie Swap-Transaktionen zu erstellen und zu senden.

Für einen Swap müssen wir zunächst eine Instanz von IDexAggregator erstellen und ein Standardkonto angeben. Mit dieser Instanz interagieren wir mit Jupiter:

Code
IDexAggregator dex = new JupiterDexAg(Web3.Account);

Anschließend definieren wir die Token, die wir tauschen möchten. In diesem Beispiel tauschen wir SOL gegen BONK:

Code
TokenData tokenA = await dex.GetTokenBySymbol("SOL");
TokenData tokenB = await dex.GetTokenBySymbol("BONK");

Als Nächstes holen wir ein Angebot für den Swap ein. So würde das Angebot für den Tausch von 1 SOL aussehen:

Code
SwapQuoteAg swapQuote = await dex.GetSwapQuote(
    tokenA.MintAddress,
    tokenB.MintAddress,
    DecimalUtil.ToUlong(1, tokenA.Decimals)
);

var quote = DecimalUtil.FromBigInteger(swapQuote.OutputAmount, tokenB.Decimals);

// Logs the expected amount of BONK
Debug.Log(quote);

Für mehr Transparenz können wir auch den Routenpfad des Swaps anzeigen:

Code
Debug.Log(string.Join(" -> ", swapQuote.RoutePlan.Select(p => p.SwapInfo.Label)));

Jetzt können wir die Swap-Transaktion erzeugen, mit unserer Wallet signieren und senden:

Code
Transaction tx = await dex.Swap(swapQuote);
await Web3.Wallet.SignAndSendTransaction(tx);

Ein Programm auf Unity portieren

Entwickler können mit dem Solana Unity Anchor-Paket Anchor-Programme in Unity integrieren. Dieses Paket enthält einen IDL-zu-C#-Konverter. Der Konverter vereinfacht die Umwandlung von Anchor-IDLs, also JSON-Darstellungen von Solana-Programmen, in C#-Code für Unity-Projekte. Die Integration umfasst zwei zentrale Schritte:

  • Installation: Mit dem Befehl dotnet tool install -g Solana.Unity.Anchor.Tool installierst du das Solana Unity Anchor Tool. Das Flag -g installiert das Paket global, sodass du das Tool nicht für jedes neue Projekt erneut installieren musst.
  • Codegenerierung: Mit dem Befehl dotnet anchorgen -i idl/file.json -o src/ProgramCode.cs erzeugst du die C#-Darstellung des Programms. Der Befehl konvertiert die angegebene IDL in eine C#-Datei, die direkt in Unity verwendet werden kann.

Mit diesen Schritten können Entwickler Solana-Programme effizient in ihre Unity-Umgebung portieren. Eine Schritt-für-Schritt-Videoanleitung von Jonas Hahn findest du hier.

SOAR

Solana On-Chain Achievement and Ranking (SOAR) ist ein Programm, das eine nahtlose Lösung für die Verwaltung von Bestenlisten, Erfolgen und Spielerprofilen sowie die automatische Verteilung von Belohnungen auf Solana bietet. Es unterstützt unter anderem folgende Funktionen:

  • Erstellen von Bestenlisten
  • Verwalten von Erfolgen
  • Unterstützung für TypeScript-Clients
  • Interaktion mit dem SOAR-Programm über Cross-Program-Invocation-Aufrufe (CPI)

Die Unterstützung für das Solana Unity SDK befindet sich derzeit in Entwicklung und soll bald verfügbar sein.

SOAR lässt sich mit wenigen Codezeilen einfach in ein Projekt integrieren. Zum Beispiel:

Code
import { SoarProgram, GameType, Genre } from "@magicblock-labs/soar-sdk";

const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);

const client = SoarProgram.get(provider);

let game = Keypair.generate();
let title = "Game1";
let description = "Description";
let genre = Genre.Action;
let gameType = GameType.Web;
let nftMeta = Keypair.generate().publicKey;
let _auths = auths.map((keypair) => keypair.publicKey);

// Retrieve the bundled transaction.
let { newGame, transaction } = await client.initializeNewGame(game.publicKey, title, description, genre, gameType, nftMeta, _auths);

// Send and confirm the transaction with the game keypair as signer.
await client.sendAndConfirmTransaction(transaction, [game]);

Der obige Code stammt direkt aus der Magicblocks-Dokumentation zu SOAR. Das Snippet importiert zunächst die erforderlichen Module aus @magicblock-labs/soar-sdk, darunter SoarProgram, GameType und Genre.

Die Klasse SoarProgram gibt dem Client Zugriff auf jede Anweisung im On-Chain-SOAR-Programm. Sie bietet außerdem Funktionen zum Ableiten von PDAs und Abrufen mehrerer Accounts.

Anschließend initialisiert der Code einen Anchor-Provider (anchor.AnchorProvider.env()) und legt ihn als Standard-Provider für nachfolgende Vorgänge fest (anchor.setProvider(provider)). Danach wird mit dem zuvor festgelegten Provider ein SoarProgram-Client erstellt.

Das Snippet beginnt mit der Initialisierung eines neuen Spiels. Es generiert ein neues Schlüsselpaar für das Spiel und definiert wichtige Spieldaten wie Titel, Beschreibung, Genre (z. B. Genre.Action) und Spieltyp (z. B. GameType.Web). Außerdem wird ein Schlüsselpaar für die NFT-Metadaten des Spiels generiert. Anschließend wird eine Liste mit Autorisierungen (_auths) vorbereitet, um die Zugriffskontrolle innerhalb des Spiels festzulegen.

Die Methode initializeNewGame wird auf dem SOAR-Client aufgerufen. Dabei werden der öffentliche Schlüssel, der Titel, die Beschreibung, das Genre, der Spieltyp, die NFT-Metadaten und die Autorisierungen des Spiels übergeben. Diese Methode gibt ein newGame-Objekt zurück und bereitet die Transaktion für das neue Spiel zum Senden vor. Die Transaktion wird mit der auf dem SOAR-Client verfügbaren Methode sendAndConfirmTransaction gesendet und bestätigt. Das Schlüsselpaar des Spiels dient als Signierer der Transaktion. So wird sichergestellt, dass der Ersteller des Spiels die Transaktion autorisiert.

Mit SOAR lassen sich ein Client und ein neues On-Chain-Spiel einfach einrichten. Jetzt können wir GameClient verwenden, um unser Spiel zu registrieren, eine Bestenliste zu erstellen und auf den Zustand unseres Spiels zuzugreifen. Die Möglichkeiten sind grenzenlos.

Die Programm-Adresse von SOAR lautet SoarNNzwQHMwcfdkdLc6kvbkoMSxcHy89gTHrjhJYkk. Die TypeScript-Dokumentation findest du hier.

Solana Unreal SDK

Das Solana Unreal SDK ist ein Plugin und Toolkit, mit dem Entwickler Blockchain-Spiele auf Solana mit der Unreal Engine 5 entwickeln können. Das Toolkit enthält Startvorlagen für Solana-integrierte Massive-Multiplayer-Online-Spiele (MMO), darunter eine Vorlage für den Gameserver. Es bietet außerdem folgende Funktionen:

  • Vollständiger Funktionsumfang von Solnet in C++ und Blueprint Visual Scripting
  • Ein Wallet-System im Spiel mit Datenschutz und Verschlüsselung
  • Minting von Metaplex-NFTs
  • Zahlungsabwicklung

Das Plugin nutzt Solnet und die Leistung der .NET-Laufzeitumgebung. Dadurch können Entwickler direkt mit Solana kommunizieren, ohne eine vollständige C++-Bibliothek von Grund auf zu erstellen. LinkStream kann Transaktionsnachrichten über TCP-Server und Client-Protokolle von Spielen an Wallets wie Tranquility senden. Das Star-Atlas-Team entwickelte das SDK ursprünglich. Bifrost hat den Code vor Kurzem geforkt und aktualisiert. Für den folgenden Abschnitt zur Installation beziehen wir uns auf den Build des Star-Atlas-Teams. Der Ablauf ist bei Bifrost identisch.

Installation

Um die Unreal Engine zu nutzen, müssen wir zuerst den Epic Games Launcher installieren. Danach erstellen wir ein Epic-Games-Konto und melden uns an. Navigiere nach der Anmeldung zum Tab Unreal Engine und klicke auf Installieren, um die neueste Version herunterzuladen. Eine ausführliche Anleitung für diesen Vorgang findest du hier. Beachte die empfohlenen Systemanforderungen für Unreal Engine 5:

  • Windows 10 (64 Bit), Quad-Core-Prozessor von Intel oder AMD, 2,5 GHz oder schneller, 8 GB RAM
  • macOS Big Sur, Quad-Core-Prozessor von Intel, 2,5 GHz oder schneller, 8 GB RAM
  • Linux Ubuntu 18.04, Quad-Core-Prozessor von Intel oder AMD, 2,5 GHz oder schneller, 32 GB RAM

Öffne den Epic Games Launcher und starte deine installierte Unreal-Version:

Erstelle ein neues Projekt und wähle C++ als Projektvorlage aus:

Schließe jetzt den Editor und öffne den Ordner Project Location, den du beim Erstellen des Projekts festgelegt hast. Erstelle dann im Stammverzeichnis einen neuen Ordner namens Plugins:

Kopiere das Plugin in das Verzeichnis Plugins. Klicke mit der rechten Maustaste auf die Datei .uproject im Stammverzeichnis und wähle Visual-Studio-Projektdateien generieren aus. Doppelklicke auf die Datei .sln und öffne das Projekt in deiner C++-IDE. Öffne dann die Datei unter Source/<ProjectName>/<ProjectName>.build.cs. Füge den Namen des Plugins zu PublicDependencyModuleNames hinzu. In unserem Fall geben wir Foundation ein:

Füge den Namen des Plugins zu unserer Datei .uproject hinzu:

Schließe deine IDE und generiere die Projektdateien erneut. Öffne anschließend deine Projektmappe, also die Datei .sln. Damit ist die Installation abgeschlossen.

Verwendung

Alle Inhalte zum Plugin findest du im Inhaltsbrowser unter Plugins > Solana SDK. Ein LinkStream-Blueprint befindet sich unter Plugins > Solana SDK Content > Blueprints. Mit diesem Blueprint können Entwickler mit Solnet kommunizieren. Die Sandbox-Karte im Ordner Maps dient als Referenz für die korrekte Einrichtung des Solana SDK. Eine Übersicht über die allgemeine Verwendung, die Anpassung deines LinkStream-Wrappers und die Anbindung an die REST API zur Serverauthentifizierung findest du auf der GitHub-Seite des Solana Unreal SDK. Eine ausführlichere Erklärung zur Interaktion mit Solana über das Unreal SDK findest du hier.

Unreal konzentriert sich auf Optimierungen und Nachbearbeitungseffekte in 3D. Dadurch lassen sich im Vergleich zu anderen Editoren wie Unity fotorealistische Spiele erstellen. Ein bekanntes Beispiel für diesen Hyperrealismus ist Star Atlas. Star Atlas ist ein immersives Strategiespiel, das dich in die Tiefen des Weltraums führt. Es steckt voller Möglichkeiten, territorialer Eroberungen und politischer Intrigen. Auch andere Spiele wie Yaku Corp nutzen den Fotorealismus der Unreal Engine, um immersive MMORPGs zu entwickeln.

Honeycomb

Honeycomb ist ein von Tumi Labs entwickeltes Protokoll, das die Entwicklung von Web3-Spielen vereinfacht. Honeycomb umfasst mehrere On-Chain-Programme und Tools zur Zustandskomprimierung, die wichtige Funktionen im Lebenszyklus eines Spiels abdecken. Alle Programme sind interoperabel und modular aufgebaut. Entwickler können sie außerdem an ihre individuellen Anforderungen anpassen. Das Toolkit für die Infrastrukturentwicklung konzentriert sich auf folgende Kernfunktionen:

  • Belohnungen für inaktive Spieler (Staking)
  • Quests (Missionen)
  • Lootboxen oder RNG-Preise (Verlosungen)
  • Gilden / Gruppen
  • Spiel-Token (verwahrt und selbstverwahrt)
  • Veränderbare digitale Assets
  • Erstellen und Verwalten digitaler Assets
  • Spielerprofile
  • Gebührenstrukturen

Die Tools lassen sich in folgende Kategorien unterteilen:

  • Hive Control: das zentrale Programm, das alle Berechtigungen und Delegierungen von Programmautoritäten in Honeycomb verwaltet
  • Asset Hub: eine Sammlung von Tools zum Erstellen und Verwalten von Assets im Spiel
  • Nectar Utility: eine Sammlung von Hilfstools, mit denen NFTs einzigartige Spielfunktionen bereitstellen können, etwa Token-Belohnungen für Inaktivität (Staking), Quests und Lootboxen
  • Buzz Kit: eine Sammlung von Tools für Gilden im Spiel. Tumi Labs plant außerdem, im Rahmen dieses Toolsets Programme für Matchmaking und die Verwaltung des Spielzustands zu entwickeln

Installation

Entwickler können mit Honeycomb über dessen JavaScript SDK und @solana/web3.js interagieren:

Code
# Using npm
npm install @solana/web3.js @honeycomb-protocol/hive-control

# Using yarn
yarn add @solana/web3.js @honeycomb-protocol/hive-control

Anwendungsbeispiel

Nach der Installation können Entwickler ein Honeycomb-Objekt mit einem Solana-Connection-Objekt initialisieren:

Code
import * as web3 from "@solana/web3.js";
import { Honeycomb } from "@honeycomb-protocol/hive-control";

const honeycomb = new Honeycomb(
  new web3.Connection("https://api.mainnet-beta.solana.com")
);

Von hier aus sind die Möglichkeiten grenzenlos. Entwickler können beispielsweise mit dem IdentityClient interagieren, um Benutzeridentitäten und Profile zu verwalten. guestIdentity ist die Standardidentität und dient als Platzhalter, bis ein Schlüsselpaar oder eine Wallet bei der Honeycomb-Instanz registriert wird. Mit dem folgenden Befehl lässt sich ein Schlüsselpaar als Identität verknüpfen: honeycomb.use(keypairIdentity(<keypair>);. Ebenso lässt sich ein Wallet-Objekt (Solana Wallet Adapter) über die in der Honeycomb-Instanz verfügbare Funktion walletIdentity als Identität registrieren. Identitäten können zur Authentifizierung verwendet werden, etwa zum Signieren von Nachrichten oder Transaktionen.

Ein weiteres interessantes Beispiel ist der HttpClient. Dieses Modul ermöglicht HTTP-Anfragen mit Axios oder Fetch und stellt HTTP-bezogene Funktionen bereit. Es ermöglicht die Anpassung von Anfrage-Headern und bietet Methoden für GET-, POST-, PUT- und DELETE-Anfragen:

Code
// Make a GET request
honeycomb
  .http()
  .get("/users", { authToken: "myAuthToken" })
  .then((response) => {
    console.log("GET Response:", response);
  })
  .catch((error) => {
    console.error("GET Error:", error);
  });

// Make a POST request
const userData = { name: "John Doe", email: "john@example.com" };
honeycomb
  .http()
  .post("/users", { data: userData })
  .then((response) => {
    console.log("POST Response:", response);
  })
  .catch((error) => {
    console.error("POST Error:", error);
  });

Das ist besonders interessant, weil Entwickler auf APIs von Drittanbietern zugreifen können, etwa auf die Digital Asset Standard (DAS) API, um andere digitale On-Chain-Assets außerhalb des Spiels abzufragen.

Diese Code-Snippets wurden aus der Dokumentation des Honeycomb Protocol übernommen und angepasst. Die Dokumentation des SDK findest du hier.

GameShift

GameShift ist eine von Solana Labs gestartete Plattform, mit der Spieleentwickler Web3-Elemente einfach über eine einzige API integrieren können. Sie soll die Entwicklung benutzerfreundlicher Web2-Erlebnisse erleichtern und zugleich die Vorteile von Spielen auf Solana nutzen. GameShift bietet eine klare Benutzererfahrung im Web3-Ökosystem und übernimmt dafür alle Gasgebühren, Blockchain-Interaktionen und Wallets. Die GameShift API deckt vier Bereiche ab:

  • Asset-Erstellung: Minting von Spiel-Assets mit strukturierten Metadaten
  • Asset-Handel: Assets auf markenspezifischen Marktplätzen in USD kaufen und verkaufen; der Start dieser Marktplätze ist in Kürze geplant
  • Zahlungen: Kreditkartenzahlungen und Integrationen zur Zahlungsabwicklung in mehr als 170 Ländern, mit 100 % Rückbuchungsschutz
  • Selbstverwahrung von Wallet-Assets: Spieler können ihre Assets in selbstverwahrten Wallets halten und handeln, also ohne Passwörter oder Seed-Phrasen

Um mit GameShift zu starten, erstellen Entwickler ein Konto in der GameShift-Konsole, richten eine Organisation ein, fügen Entwickler zu ihrer Organisation hinzu, legen ein Spiel an und verwalten ihren API-Schlüssel für Entwickler. Der gesamte Ablauf wird hier beschrieben.

Für Fiat-Transaktionen ist ein Händlerkonto erforderlich. Es lässt sich in zwei Schritten einrichten:

  • Know Your Business (KYB): Entwickler müssen Informationen zu ihrem Unternehmen angeben, um die Vorschriften für Geldtransfers einzuhalten. Derzeit unterstützt GameShift die Abrechnung in Fiatwährungen nur auf Bankkonten mit Sitz in den USA
  • Einrichten eines Kontos für die Fiat-Abrechnung: Sobald Entwickler Fiatzahlungen in der Produktion aktivieren möchten, müssen sie GameShift kontaktieren, um einen Link zum Onboarding-Formular für Händler zu erhalten. Über dieses Formular werden die KYB-Informationen erfasst. Die Validierung kann wenige Minuten dauern, in einigen Fällen ist jedoch eine manuelle Prüfung erforderlich

Alle GameShift-Aktivitäten sind in Organisationen strukturiert:

Benutzer-Onboarding

Sobald alles eingerichtet ist, können Entwickler mit der REST API interagieren. Sie können Benutzer registrieren und ihnen damit Zugriff auf Marktplatzfunktionen, On-Chain-Assets und Zahlungsabläufe geben. Dazu senden sie eine POST-HTTP-Anfrage an https://api.gameshift.dev/users. Der Anfrage-Body enthält ihren API-Schlüssel, die E-Mail-Adresse des Benutzers und einen referenceId, also einen eindeutigen Wert wie eine UUID:

Code
curl --request POST \
     --url https://api.gameshift.dev/users \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'x-api-key: ' \
     --data '
{
  "referenceId": "exampleReferenceId",
  "email": "user@example.com"
}

Nach der Registrierung lassen sich die Informationen und Assets eines Benutzers jederzeit abrufen. Sende dazu eine GET-HTTP-Anfrage an https://api.gameshift.dev/users/{the-user-id-you-used-to-register}/assets:

Code
curl --request GET \
     --url https://api.gameshift.dev/users/exampleReferenceId/assets \
     --header 'accept: application/json' \
     --header 'x-api-key:

Bei Erfolg wird eine paginierte Liste der Assets des Benutzers zurückgegeben:

Code
{
  "data": [
    {
      "id": "dcde5bc8-b30b-46b6-b4da-0763953b2484",
      "collectionId": "36c97125-04a5-4dc3-b92a-029d74a42287",
      "attributes": [],
      "name": "Example Asset",
      "description": "Example Description",
      "imageUrl": "https://solana.com/src/img/branding/solanaLogoMark.png",
      "status": "Committed",
      "owner": {
        "address": "",
        "referenceId": "exampleReferenceId"
      }
    }
  ],
  "meta": {
    "page": 1,
    "perPage": 50,
    "totalPages": 1
  }
}

Alle Code-Snippets für das Onboarding findest du hier.

Ein Asset erstellen

Entwickler können beispielsweise On-Chain-Spiel-Assets programmgesteuert erstellen, indem sie eine POST-HTTP-Anfrage an https://api.gameshift.dev/assets senden:

Code
curl --request POST \
     --url https://api.gameshift.dev/assets \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'x-api-key: ' \
     --data '
{
  "details": {
    "description": "Example description",
    "imageUrl": "https://solana.com/src/img/branding/solanaLogoMark.png",
    "name": "Example Asset",
    "attributes": [
      {
        "displayType": "Formatted Attribute Name",
        "traitType": "attribute-name",
        "value": "attribute-value"
      }
    ]
  },
  "destinationUserReferenceId": "exampleUserId"
}
'

Assets benötigen folgende Angaben:

  • description – eine Zeichenfolge mit 64 Zeichen, die Informationen zum Asset enthält
  • name – eine Zeichenfolge mit 32 Zeichen zur Identifizierung des Assets
  • imageUrl – ein direkter Link zu dem Bild, das das Asset darstellt
  • displayType – ein optionaler formatierter Titel
  • traitType – ein optionaler Name für das Merkmal
  • value – ein optionales Feld, das den Wert des Attributs darstellt

Die POST-HTTP-Anfrage erfordert außerdem den referenceId eines Benutzers, der über das Feld destinationUserReferenceId angegeben wird. Eine ausführlichere Beschreibung zur Arbeit mit Spiel-Assets findest du hier.

Fazit

Die Integration der Blockchain-Technologie in Spiele, insbesondere über Solana, verändert grundlegend, wie wir digitale Welten wahrnehmen und mit ihnen interagieren. Tools wie Anchor, Turbo und Magicblock sowie die Solana Unity und Unreal SDKs ermöglichen Entwicklern völlig neue Spielerlebnisse. Für Spieler ist es heute einfacher denn je, virtuelle Ökonomien aufzubauen und auf bisher ungekannte Weise in sozialen Strukturen zu interagieren – vollständig transparent und zugänglich. Plattformen wie Honeycomb und GameShift zeigen das Potenzial von Web3-Spielen zusätzlich, indem sie die Entwicklung vereinfachen und die Spielerbindung stärken.

Solana steht an der Spitze dieser Gaming-Revolution. Die Gaming-Community von Solana wächst stetig. Eigene Hackathons finden statt und neue Spiele entstehen. Solana Labs und die Solana Foundation treiben Initiativen voran und entwickeln Tutorials, Tools und Plattformen, um diese junge Community zu fördern. Wenn du auf der schnellsten verfügbaren Blockchain entwickelst, sind den Möglichkeiten für die Zukunft des Gamings keine Grenzen gesetzt.

Wenn du bis hierher gelesen hast, Anon: Danke! Trage unten unbedingt deine E-Mail-Adresse ein, damit du keine Neuigkeiten zu Solana verpasst. Möchtest du tiefer einsteigen? Tritt unserem Discord bei und entwickle noch heute die Zukunft des Gamings auf der leistungsfähigsten Blockchain.

Zusätzliche Ressourcen / Weiterführende Literatur

Ähnliche Artikel

Helius abonnieren

Bleib bei der Solana-Entwicklung auf dem Laufenden und erhalte Updates, wenn wir neue Beiträge veröffentlichen

Vergrößertes Bild