Der erste Schritt beim Aufbau der Logik hinter dem Spielbrett ist die Entscheidung, wie eine Spielbrett-Kachel programmatisch dargestellt werden soll.
Um zu entwerfen, wie du eine Brettkachel darstellen kannst, solltest du darüber nachdenken, wie du und der Spieler die Brettkacheln verwenden. Ein Brettspiel besteht normalerweise aus diskreten Räumen, die einzeln voneinander getrennt und unterschiedlich sind. Dies unterscheidet sich vom UEFN-Welt-Bereich.
Im Welt-Bereich werden Koordinaten durch vector3-Positionen dargestellt, was bedeutet, dass Koordinaten so nahe beieinander liegen können wie Fließkommazahlen, wodurch Weltkoordinaten eher kontinuierlich als diskret sind. Außerdem gibt es viele verschiedene vector3-Positionen, die sich alle auf derselben Brettkachel befinden. Daraus kannst du einige Dinge schließen:
Da die Spielbrettkacheln diskret sind, empfiehlt es sich, einen diskreten Datentyp (Diskrete Daten sind Daten, die einen Wertebereich annehmen, der der ganzen Zahlen entspricht) zur Darstellung unserer Positionen zu verwenden, d. h. wir sollten
intanstelle vonfloatverwenden.Das Brett ist zweidimensional, sodass du nur einen Ort innerhalb von zwei Dimensionen speichern musst. Du brauchst keine dreidimensionale Datenstruktur, um die Brett-Kachel-Positionen zu speichern.
Board-Datentypen definieren
Die Klasse tile_coordinate gibt an, wo sich eine Kachel auf dem Spielbrett befindet. Um die Klasse tile_coordinate zu erstellen, lege eine neue Verse-Datei mit dem Namen utilities.verse an. Erstelle in dieser Datei ein neues Modul mit dem Namen DataTypes.
DataTypes<public> := module:
Füge diesem Modul die neue TileCoordinate-Klasse hinzu und definiere die Komponenten der Klasse.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Für „Koordinaten-Schlacht“ erstellst du ein Brettraster mit 5 x 5. Das bedeutet, dass du die Grenzen des Spielbretts definieren musst. Dazu erstellst du eine neue Klasse Bounds, die eine untere und obere Grenze dafür festlegt, wie klein oder groß ein tile_coordinateLeft oder Forward-Wert sein darf.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Du möchtest eine Datenstruktur, die die Grenzen für ein einzelnes Spielbrett in einer Datenstruktur enthält. Erstelle dazu eine neue Klasse board_bounds, die eine untere und obere Grenze für jede der Komponenten einer tile_coordinate definiert.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Spielbrett definieren
Mit den vorhandenen Strukturen kannst du nun:
Eine Darstellung einer Kachel im Brettraum definieren.
Die Grenzen des Brettraums definieren.
Ein wichtiges Stück fehlt noch – das Spielbrett selbst. Um das Spielbrett zu definieren, erstelle eine neue Verse-Datei mit dem Namen board.verse und füge als Spielbrett ein neues Verse-Gerät mit dem Namen board hinzu.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Assets }
using { DataTypes }
using { UtilityFunctions }
board<public> := class(creative_device):
Das Brett sollte ein paar Dinge beinhalten:
Wo befindet sich das Brett im Welt-Bereich?
Was sind die Grenzen des Bretts?
Wie groß ist eine Brettkachel?
Die erste Frage benötigt keine neue Variable; du kannst die eingebaute „transform“-Klasse des Geräts selbst verwenden. Du kannst die Klasse transform eines Kreativmodus-Geräts mit der Funktion GetTransform abrufen.
Die zweite Frage kann mit einer Variablen board_bounds definiert werden.
Die dritte Frage kann gelöst werden, indem eine Variable vector2 definiert wird, um die Kachelgröße zu verfolgen.
Die letzten beiden werden als Felder für dein board-Gerät hinzugefügt.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Assets }
using { DataTypes }
using { UtilityFunctions }
board<public> := class(creative_device):
Vom Brettraum in den Welt-Bereich konvertieren
Als Nächstes musst du bestimmen, wo sich eine Kachel in der Welt als vector3 befindet, wenn du eine Position auf dem Spielbrett als tile_coordinate hast. Nenne diese Funktion ToVector3. Dies muss innerhalb der Grenzen eines Spielbretts geschehen, um zu wissen, wo sich das Zentrum des Spielbretts befindet.
Es gibt eine Mehrdeutigkeit, die du zuerst beheben musst. Bei einer tile_coordinate gibt es viele verschiedene vector3-Weltpositionen auf derselben Kachel. In der Sprache der Mathematik ist dies eine Eins-zu-Viele-Funktion. Idealerweise würdest du einen einzelnen Welt-Standort wählen, um zu sagen, wo sich die Kachel im Welt-Bereich befindet. Eine natürliche Wahl ist das Zentrum der Kachel.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Assets }
using { DataTypes }
using { UtilityFunctions }
board<public> := class(creative_device):
Diese Funktion führt Folgendes aus:
Sie ruft das Transform des Bretts im Welt-Bereich ab.
Es erhält die Position des Bretts im Welt-Bereich aus der „transform“-Klasse.
Es berechnet den Versatz der Input-Kachel in Bezug auf das Zentrum des Bretts.
Es fügt den Versatz zur Mitte des Bretts hinzu, um die Position in Bezug auf das Zentrum der Welt zu erhalten.
Von Welt-Bereich zu Brettraum konvertieren
Wenn du eine Position im Welt-Bereich als vector3 hast, musst du sie in eine tile_coordinate umwandeln.
Konstruiere eine Funktion namens ToTileCoordinate. Diese Funktion nimmt einen vector3 als Argument und gibt eine tile_coordinate zurück. Bei einer Position im Welt-Bereich als vector3 ist es etwas komplexer, die Position auf dem Spielbrett als tile_coordinate zu bestimmen.
Dies ist vor allem deshalb komplexer, weil das Spielbrett ein diskretes Raster ist und es viele Positionen im Welt-Bereich gibt, die nicht Teil des Spielbretts sind. Wenn du eine Position im Welt-Bereich als vector3 hast, ist es möglich, dass sich die Position überhaupt nicht auf dem Spielbrett befindet. Dies macht ToTileCoordinate zu einem idealen Kandidaten für den Funktionseffekt-Bezeichner <decides>. Dieser ist nützlich, weil es viele Positionen in der Spielwelt gibt, die nicht auf einer Kachelkoordinate sitzen. In diesem Fall schlägt der Versuch, zu konvertieren, fehl. Es ist wichtig zu wissen, wann diese Konvertierung erfolgreich ist oder nicht. Die Funktion ToTileCoordinate entscheidet zunächst, ob die Position ein Teil des Spielbretts ist, und gibt diese tile_coordinate-Position zurück, wenn dies der Fall ist.
Ein weiterer Grund für die erhöhte Komplexität ist, dass eine einzelne Kachel aus vielen verschiedenen Welt-Standorten besteht. In der Mathematik macht dies die Funktion ToTileCoordinate zu einer Viele-zu-Eins-Funktion.
Um die Dinge übersichtlicher zu gestalten, erstelle den Fehlerteil von ToTileCoordinate separat, definiere separat eine Funktion IsTileCoordinateOnBoard und rufe sie innerhalb von ToTileCoordinate auf.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Assets }
using { DataTypes }
using { UtilityFunctions }
board<public> := class(creative_device):
Die Funktion IsTileCoordinateOnBoard führt Folgendes aus:
Bestimmt, ob die linke Komponente der eingegebenen Kachelkoordinate innerhalb der Brettgrenzen liegt
Bestimmt, ob die Vorwärts-Komponente der eingegebenen Kachelkoordinate innerhalb der Brettgrenzen liegt.
Die Funktion IsTileCoordinateOnBoard ist erfolgreich, wenn die eingegebene Kachelkoordinate innerhalb der Brettgrenzen liegt, und schlägt andernfalls fehl.
Die Funktion ToTileCoordinate führt Folgendes aus:
Sie ruft die Welt-Bereich-Transform des Bretts ab.
Sie ruft den Mittelpunkt der Brettposition aus dem Welt-Bereich ab.
Sie berechnet die relative Position des Welt-Standorts in Bezug auf das Zentrum des Bretts.
Sie konvertiert den relativen Welt-Standort in eine Kachelkoordinate.
Sie bestimmt, ob sich die Kachelkoordinate auf dem Brett befindet.
Sie gibt die Kachelkoordinate zurück, falls sie sich auf dem Brett befindet.
Die Funktion ToTileCoordinate ist genau dann erfolgreich, wenn IsTileCoordinateOnBoard erfolgreich ist.
Beispiel
Im folgenden Abschnitt wird ein Beispiel für die Konvertierung einer tile_coordinate in einen vector3 und anschließend für die Konvertierung desselben vector3 zurück in eine tile_coordinate erläutert.
Kachelkoordinate zu Vector3
Angenommen, du hast Folgendes:
Ein Spielbrett mit 5 mal 5 Kacheln.
Eine Spielkachel, die 512,0 mal 512,0 Quadrateinheiten groß ist.
Das Spielbrett befindet sich bei x := 5000.0, Y:= 0.0, Z := 1000.0 im Welt-Bereich.
Nachfolgend findest du die Schritte zum Konvertieren der Kachel mit den Kachelkoordinaten Left := -1, Forward := 2.0 in den Welt-Bereich.
ToVector3(tile_coordinate{Left := -1, Forward := 2.0})
BoardTransform:transform = GetTransform()
# BoardTransform := transform{Translation := vector3{X := 5000.0, Y := 0.0, Z := 1000.0}, ...}
CenterOfBoard:vector3 = BoardTransform.Translation
# CenterOfBoard := vector3{X := 5000.0, Y := 0.0, Z := 1000.0}
TileOffsetFromCenter:vector3 = vector3:
X := (TileLocation.Forward * TileSize.X)
Als nächstes folgen die Schritte zur Rückkonvertierung mit der Funktion ToTileCoordinate.
ToTileCoordinate(vector3{X := 6024.0, Y := 512.0, Z := 1000.0}):
BoardTransform:transform = GetTransform()
# BoardTransform := transform{Translation := vector3{X := 5000.0, Y := 0.0, Z := 1000.0}, ...}
CenterOfBoard:vector3 = BoardTransform.Translation
# CenterOfBoard := vector3{X := 5000.0, Y := 0.0, Z := 1000.0}
ShiftedWorldLocation:vector3 = WorldLocation - CenterOfBoard
# ShiftedWorldLocation := vector3{X := 6024.0, Y := 512.0, Z := 1000.0} - vector3{X := 5000.0, Y := 0.0, Z := 1000.0}
Diese letzte tile_coordinate entspricht genau dem anfänglichen Wert, was bedeutet, dass alles wie erwartet funktioniert hat.
Überblick
Auf dieser Seite haben wir dich durch die folgenden Schritte geführt:
Eine Darstellung einer Kachel im Brettraum definieren.
Die Grenzen des Brettraums definieren.
Definieren, wo sich der Brettraum innerhalb des Welt-Bereichs befindet.
Zwischen Brettraum und Welt-Bereich konvertieren.
Dateien
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
Left<public>:int = 0
Forward<public>:int = 0
bounds<public> := class<concrete>:
@editable
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Assets }
using { DataTypes }
using { UtilityFunctions }
board<public> := class(creative_device):
type