Erfahre mehr über optimalen Vorgehensweisen bei verschiedenen Aspekten der Käufe auf Inseln und erhalte Tipps zum Testen und Debuggen deines Shops.
Verwenden des „Käufe auf Inseln“-Verse-Geräts
Das „Käufe auf Inseln“-Verse-Gerät enthält eine Vorlage für Käufe auf Inseln. Es verfügt über alle Implementierungen von wichtigen Aspekten des Marketplace-Moduls in der Verse-API. Dazu gehören Gegenstände, Angebote, Paketangebote und die Abwicklung von Käufen durch die Nutzung der Standard-Shop-Benutzeroberfläche. Wenn du diesen Code verwendest, kann dir das dabei helfen, schnell deinen eigenen Shop zu erstellen.
So greifst du auf das Gerät zu:
Gehe zum Verse-Explorer.
Klicke mit der rechten Maustaste auf deinen Projektnamen.
Wähle Neue Verse-Datei zum Projekt hinzufügen aus.
Wähle „Käufe auf Inseln“-Gerät aus.
Um den Code direkt so zu übernehmen, gehe in den Verse-Code und bearbeite Folgendes in der Datei:
Gegenstandsnamen
Beschreibungen
Symbole
Ersetze die Standardnamen im Code durch Namen, die zu deinen Berechtigungen und Angeboten passen.
Optimale Vorgehensweisen beim Kodieren
Du kannst deinen Verse-Code anpassen, um die Skalierbarkeit deines Codes und die Performance deiner Insel zu verbessern.
Organisieren deines Workflows
Eine übliche Vorgehensweise in der Programmierung ist das Aufteilen von Aspekten. Dateien und Funktionen sollten auf die Ausführung einer bestimmten Aufgabe ausgerichtet sein, damit sie leichter zu warten sind, wenn dein Projekt immer größer wird.
Dadurch entstehen kleinere und ordentlicher organisierte Code-Dateien, die einfacher zu lesen und zu verstehen sind, was das Debugging vereinfachen sollte.
Bezogen auf Käufe auf Inseln kannst du das Obige folgendermaßen umsetzen:
Lege Gegenstandsdefinitionen in einer separaten Datei ab.
Lege Angebote und Paketangebote in einer separaten Datei ab.
Erstelle ein Gerät, das sich um alle statischen, vordefinierten Angebote kümmert.
Erstelle ein Gerät, das sich nur um dynamische Angebote kümmert.
Erstelle ein Gerät, das sich nur um Käufe kümmert.
Organisieren mit Modulen
Module sind atomare Code-Einheiten, die zur Nutzung in mehreren Dateien wiederverwendet werden können. Module können im Laufe der Zeit verändert werden, ohne dabei Abhängigkeiten in den Dateien, in denen sie bereits benutzt werden, zu zerstören. Du kannst längere oder repetitive Code-Einheiten, wie Berechtigungsdefinitionen, in eine andere Datei auslagern und sie dann mit der Anweisung using importieren.
Ein großer Vorteil bei der Verwendung von Modulen ist, dass du eine Variable eines Mitglieds des Moduls nur einmalig an einem Ort definieren musst. Wenn du dann das Modul importierst und die Variablen referenzierst, kannst du mit verschiedenen Verse-Code-Dateien auf dieselben Daten zugreifen. Wenn Fehler im Zusammenhang mit Daten aus dem Modul auftreten, reduziert sich die Anzahl der zu überprüfenden Fehlerquellen auf das Modul selbst; du musst nicht alle Dateien überprüfen, in denen du die Inhalte des Moduls verwendet hast.
Das nachfolgende Snippet zeigt, wie du die Berechtigungsinformationen von CornSeedPacket in einem Modul definieren kannst.
EntitlementInfo<public> := module:
CornSeedPacket<public> := module:
Name<public><localizes> : message = "Corn seed pack"
Description<public><localizes> : message = "A pack of corn seeds. Opening a pack yields 10 corn seeds for planting."
ShortDescription<public><localizes> : message = "Contains 10 corn seeds for planting."Sowohl EntitlementInfo als auch CornSeedPacket sind als Module definiert, damit du alle Berechtigungsinformationen importieren und direkt auf die Mitgliedsvariablen von CornSeedPacket zugreifen kannst, wie etwa die Variable Name.
Dieses Snippet zeigt, wie du das Modul EntitlementInfo importieren kannst, um die Berechtigung corn_seed_pack zu definieren.
Beachte, dass das erneute Eintippen von Variablen wie Name nicht notwendig ist, da du die Variable direkt über das Modul CornSeedPacket referenzieren kannst. Dadurch verringert sich auch das Risiko von Rechtschreibfehlern.
Entitlements<public> := module:
using { EntitlementInfo }
# Using custom entitlement class to distinguish your entitlements.
my_island_entitlement<public> := class<abstract><castable>(entitlement){}
corn_seed_pack<public> := class<concrete>(my_island_entitlement):
var Name<override> : message = CornSeedPacket.Name
var Description<override> : message = CornSeedPacket.Description
var ShortDescription<override> : message = CornSeedPacket.ShortDescription
Die Anweisung using benötigt einen Dateipfad zu dem Modul, das du importieren möchtest. In diesem Fall benötigst du keinen Dateipfad, da davon ausgegangen wird, dass sich das Modul im selben Ordner befindet.
Verbessern der Insel-Performance
Du kannst die Reaktionszeit deines Erlebnisses verbessern, indem du deine Methoden zum Kaufen und Gewähren von Gegenständen definierst. Nutze hierzu den Effekt <suspends> und rufe sie mit spawn auf.
Dadurch kann TryBuyOffer asynchron abgeschlossen werden, während andere Aspekte deiner Spiellogik weiterhin ausgeführt werden. Außerdem wird so verhindert, dass dein Spiel pausiert wird, bis ein Kauf abgeschlossen wurde.
TryBuyOffer(Player:player, Offer:offer)<suspends>:void=
Result := BuyOffer(Player, Offer)
OnButtonInteraction(Agent:agent):void=
if (Player := player[Agent]):
spawn{TryBuyOffer(Player, OfferType)}
Optimale Vorgehensweisen für Symbole
Spieltexturen haben spezielle Anforderungen, damit sie im Spiel ordnungsgemäß gerendert werden können. Beim Erstellen von Texturen in UEFN mit importierten Bildern musst du darauf achten, dass die Quellbilddatei eine Zweierpotenz für Höhe und Breite verwendet. Das erhöht die Kompatibilität und Stabilität deiner Insel auf allen Plattformen.
Die Zweierpotenz wird auch beim Textur-Streaming genutzt, um die Texturauflösung auf Plattformen mit weniger Speicher zu reduzieren.
Das Textur-Streaming hilft bei folgenden Punkten:
Änderung der Auflösung einer Textur
Bestimmung, wie schnell ein Spiel geladen wird
Steigerung der visuellen Qualität des Spiels
Einsparung von GPU-Speicher
Weitere Informationen zur Zweierpotenz-Regel und zum Ändern der Größe von Texturen findest du unter Ändern der Größe von Texturen.
Weitere Informationen zum Importieren von benutzerdefinierten Assets in UEFN findest du unter Importieren von Assets. Weitere Informationen zur Freigabe von Assets (wie Texturen) in Verse findest du unter Freigabe von Assets.
Testen und Debuggen deiner Berechtigungen
Sowohl die Live-Bearbeitung als auch private Spieltest-Sitzungen sind Debugging-Sitzungen. Debugging-Sitzungen haben den folgenden Effekt auf das Verhalten von Käufen, Berechtigungen und Angeboten:
Bei Käufen werden keine V-Bucks von Konten abgezogen.
Am Ende der Debugging-Sitzung werden gewährte und gekaufte Berechtigungen entfernt.
Debugging-Sitzungen haben Zugriff auf das Menü Debug-Befehle.
Deine Angebote müssen auf einer privaten und einer Spieltest-Version der Insel verfügbar und für alle Mitspieler zugänglich sein, damit sie in der Testphase verwendet werden können. Die angebotenen Gegenstände gelten nicht als live. Angebote sind erst live, wenn die Insel veröffentlicht und öffentlich zugänglich ist.
Zugriff auf das Menü „Debug-Befehle“
Du kannst auf das Menü „Debug-Befehle“ zugreifen, indem du die Esc-Taste auf PC oder die Start-/Options-Taste auf Controllern drückst und dann im Menü die Option „Debug-Befehle“ auswählst.
Shop-Debugging-Befehle
Du findest die Debugging-Befehle deines Shops unter „Shop-Debugging-Befehle“, von wo aus du Zugriff auf die folgenden Befehle hast:
Befehlsname | Beschreibung |
Schaufenster öffnen | Zeigt eine dynamische Shop-Benutzeroberfläche mit Angeboten für alle verfügbaren Berechtigungen an, sodass Spieler sie individuell kaufen können. So kannst du die Berechtigung, die du testen willst, direkt auswählen. |
Alle Berechtigungen gewähren | Füllt das Inventar dieses Spielers, sodass er die maximale Anzahl aller verfügbaren Berechtigungen besitzt. Du kannst außerdem das Verhalten im Spiel testen, um zu überprüfen, ob Spieler in einem Bereich, in dem sie das eigentlich nicht sollten, Zugriff auf einen Gegenstand haben. |
Eine Berechtigung gewähren | Gewährt dem Spieler eine Einheit jeder Berechtigung. So kann eine große Anzahl an Berechtigungen gewährt werden, während der Spieler noch Platz in seinem Inventar hat, um Käufe von nicht dauerhaften Berechtigungen zu testen, ohne dass er dabei die maximale Anzahl überschreitet. Wenn die Gewährung der Berechtigung im Konflikt zu Du kannst außerdem das Verhalten im Spiel testen, um zu überprüfen, ob Spieler in einem Bereich, in dem sie das eigentlich nicht sollten, Zugriff auf einen bestimmten Gegenstand haben. |
Entfernung von Berechtigungen erzwingen | Dadurch werden alle im Besitz befindlichen Berechtigungen aus dem Inventar des Spielers entfernt. So kannst du das Inventar eines Spielers zurücksetzen, um den Kauf von Angeboten weiter zu testen. Dieser Befehl kann nützlich sein, um Dieser Befehl kann auch nützlich sein, um die Iteration beim Testen zu erhöhen, indem das Inventar schnell zurückgesetzt wird. |
Besessene Berechtigungen ausgeben | Gibt alle besessenen Berechtigungen im Output-Log aus. |
Käufe schlagen immer fehl | Dies ist standardmäßig deaktiviert. Ist dies auf „Aus“ gestellt, funktionieren Käufe wie vorgesehen. Ist dies auf „An“ gestellt, schlagen Käufe immer fehl, auch dann, wenn alle Bedingungen für einen erfolgreichen Kauf erfüllt sind. „Käufe schlagen immer fehl“ ist hilfreich, um Fälle zu testen, in denen bei |
