Il primo passo per costruire la logica alla base del tabellone di gioco è decidere come rappresentare un tile del tabellone a livello di codice.
Per progettare un tile del tabellone, pensa a come lo userebbe un giocatore. Di solito, un gioco da tavolo consiste in spazi discreti ben distinti separati uno dall'altro. Tuttavia, lo spazio mondo di UEFN si comporta in modo diverso.
Nello spazio mondo, le coordinate sono rappresentate da posizioni vector3, il che significa che possono essere vicine tra loro quanto possono esserlo i numeri in virgola mobile; caratteristica che rende le coordinate del mondo più continue che discrete. Inoltre, sono presenti molte posizioni diverse di vector3 che si troveranno tutte sullo stesso tile del tabellone. Alla luce di quanto appena detto, si possono trarre le seguenti conclusioni:
Poiché i tile del tabellone sono discreti, potresti utilizzare dati discreti (i dati discreti sono dati che assumono un intervallo di valori in corrispondenza di valori interi o numeri interi) per rappresentare le nostre posizioni; il che significa che è necessario utilizzare
intinvece difloat.typeIl tabellone è bidimensionale, quindi bisogna memorizzare solo una posizione all'interno di due dimensioni. Non è necessaria una struttura dati tridimensionale per memorizzare la posizione dei tile nel tabellone.
Definire i tipi di dati del tabellone
La classe tile_coordinate rappresenta la posizione di un tile sul tabellone di gioco. Per creare la classe tile_coordinate, crea un nuovo file Verse denominato utilities.verse. All'interno di questo file, crea un nuovo modulo denominato DataTypes.
DataTypes<public> := module:
Aggiungi a questo modulo la nuova classe TileCoordinate e definisci i componenti della classe.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
In Battaglia di coordinate, costruirai una griglia del tabellone 5x5. Ciò significa che è necessario definire i limiti del tabellone di gioco. A tale scopo, crea una nuova classe bounds che definisca un limite inferiore e superiore su quanto può essere piccolo o grande un valore tile_coordinate Left o Forward.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Stai creando una struttura che contenga i limiti di un singolo tabellone di gioco in un'unica struttura dati. A tale scopo, crea una nuova classe board_bounds che definisca un limite inferiore e superiore per ciascuno dei componenti di una tile_coordinate.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Definire il tabellone di gioco
Hai le strutture per eseguire le seguenti azioni:
Definisci una rappresentazione di un tile nello spazio del tabellone.
Definisci i limiti dello spazio sul tabellone.
Manca ancora un elemento importantre: il tabellone di gioco stesso. Per definire il tabellone di gioco, crea un nuovo file Verse denominato board.verse e aggiungi un nuovo dispositivo Verse chiamato board.
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):
Il tabellone deve presentare alcune caratteristiche:
Dove si trova il tabellone nello spazio mondo?
Quali sono i limiti del tabellone?
Qual è la dimensione di un tile nel tabellone?
La prima domanda non richiede una nuova variabile; puoi utilizzare il transform integrato del dispositivo stesso. Puoi ottenere il transform di un dispositivo in modalità Creativa di Fortnite con la funzione API GetTransform.
Puoi trovare risposta alla seconda domanda grazie a una variabile board_bounds.
La terza domanda può essere risolta definendo una variabile vector2 per tenere traccia delle dimensioni del tile.
Gli ultimi due vengono aggiunti come campi per il tuo dispositivo board.
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):
Eseguire conversioni da spazio del tabellone a spazio mondo
Successivamente, determina dove si trova il tile nel mondo come vector3 data una posizione sul tabellone di gioco come tile_coordinate. Denomina questa funzione ToVector3. Questi passaggi devono essere eseguiti entro i confini di un tabellone di gioco per sapere dove si trova il centro del tabellone.
Tuttavia, dovrai affrontare prima una particolare ambiguità. Data una tile_coordinate, esistono molte posizioni del mondo vector3 diverse sullo stesso tile. Nel linguaggio matematico, si tratta di una funzione uno-a-molti. Idealmente, dovresti scegliere una singola posizione del mondo per determinare dov'è situato il tile nello spazio mondo. La scelta potrebbe ricadere naturalmente sul centro del tile.
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):
Questa funzione esegue le seguenti operazioni:
Ottiene il transform del tabellone nello spazio mondo.
Ottiene la posizione del tabellone nello spazio mondo dal transform.
Calcola l'offset del tile di input rispetto al centro del tabellone.
Aggiunge l'offset al centro della posizione del tabellone per ottenere la posizione rispetto al centro del mondo.
Eseguire conversioni da spazio mondo a spazio del tabellone
Se hai una posizione nello spazio mondo come vector3, dovrai convertirla in tile_coordinate.
Costruisci una funzione denominata ToTileCoordinate. La funzione accetta un vector3 come argomento e restituisce una tile_coordinate. Data una posizione nello spazio mondo come vector3, è leggermente più complesso determinare la posizione sul tabellone come tile_coordinate.
Questa complessità è dovuta all'alto numero di posizioni nello spazio mondo che non fanno parte del tabellone di gioco, tenendo a mente che il tabellone viene individuato in una griglia discreta. Pertanto, considerando una posizione nello spazio mondo come vector3, è possibile che la stessa posizione non sia affatto sul tabellone di gioco. Ciò rende ToTileCoordinate un candidato ideale per disporre dello specificatore di effetto della funzione <decides>. Si presta a questo ruolo perché ci sono molte posizioni nel mondo di gioco che non risiedono su una coordinata di un tile. In questo caso, il tentativo di convertirne una non riesce. È importante sapere quando la conversione ha esito positivo o negativo. La funzione ToTileCoordinate decide innanzitutto se una posizione è presente sul tabellone di gioco e, in caso affermativo, restituisce quella posizione tile_coordinate.
Un altro motivo che ne determina la maggiore complessità risiede nel fatto che un singolo tile è composto da varie posizioni nel mondo. In matematica, questa caratteristica rende la funzione ToTileCoordinate una funzione molti-a-uno.
Per una migliore esperienza di gioco, separa la parte di errore di ToTileCoordinate, definisci separatamente una funzione IsTileCoordinateOnBoard e chiamala all'interno di ToTileCoordinate.
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):
La funzione IsTileCoordinateOnBoard esegue le seguenti operazioni:
Determina se il componente Sinistra della coordinata tile di input si trova tra i limiti del tabellone
Determina se il componente Avanti della coordinata tile di input si trova tra i limiti del tabellone
La funzione IsTileCoordinateOnBoard viene eseguita correttamente se le coordinate tile di input si trovano entro i limiti del tabellone, altrimenti non riesce.
La funzione ToTileCoordinate esegue le seguenti operazioni:
Ottiene il transform dello spazio mondo del tabellone.
Ottiene il centro della posizione sul tabellone dallo spazio mondo.
Calcola la posizione relativa della posizione nel mondo rispetto al centro del tabellone.
Converte la posizione del mondo relativo in una coordinata tile.
Determina se le coordinate tile sono presenti sul tabellone.
Restituisce la coordinata tile se si trova sul tabellone.
La funzione ToTileCoordinate avrà esito positivo se e solo se anche IsTileCoordinateOnBoard non fallisce.
Esempio
La sezione seguente illustra come prendere una tile_coordinate e convertirla in un vector3, quindi mostra come prendere lo stesso vector3 e riconvertirlo in una tile_coordinate.
Da coordinata tile a Vector3
Supponi di ritrovarti di fronte alla seguente situazione:
Un tabellone di gioco formato da 5x5 tile.
Un tile di gioco quadrato che misura 512.0 per 512.0 unità.
Il tabellone di gioco si trova in X := 5000.0, Y:= 0.0, Z := 1000.0 nello spazio mondo.
Di seguito sono riportati i passaggi per convertire il tile con le coordinate tile Left := -1, Forward := 2.0 nello spazio mondo.
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)
I passaggi successivi servono alla riconversione utilizzando la funzione 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}
Quest'ultima tile_coordinate corrisponde esattamente al valore iniziale, il che significa che tutto ha funzionato come previsto.
Riepilogo
In sintesi, questa pagina ti ha guidato attraverso i seguenti passaggi:
Definisci una rappresentazione di un tile nello spazio del tabellone.
Definisci i limiti dello spazio sul tabellone.
Definisci dove si trova lo spazio del tabellone all'interno dello spazio mondo.
Esegui conversioni tra spazio del tabellone e spazio mondo.
File
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