El primer paso para crear la lógica detrás del tablero de juego es decidir cómo representar mediante programación una casilla del tablero de juego.
Para diseñar cómo representar una casilla del tablero, piensa en cómo tú y el jugador utilizáis las casillas del tablero. Un tablero de juego suele estar compuesto por espacios discretos que están separados entre sí y son distintos. Esto es diferente del espacio global de UEFN.
En el espacio global, las coordenadas se representan mediante posiciones de vector3, lo que significa que las coordenadas pueden estar tan próximas entre sí como los números de punto de coma flotante, lo que hace que las coordenadas del mundo sean más continuas que discretas. Además, hay muchas ubicaciones diferentes de vector3 que estarán todas en la misma casilla del tablero. A partir de esto, se pueden sacar varias conclusiones:
Como las casillas de tablero son discretas, quizá quieras utilizar un tipo de datos discretos (los datos discretos son datos que adoptan un rango de valores que se corresponde con valores enteros o números enteros) para representar nuestras ubicaciones, lo que significa que se debe utilizar
inten vez defloat.El tablero es bidimensional, por lo que solo tienes que almacenar una posición dentro de dos dimensiones. No necesitas una estructura de datos tridimensional para almacenar la ubicación de las casillas del tablero.
Cómo definir tipos de datos de tablero
La clase tile_coordinate representa dónde se encuentra una casilla en el tablero. Para crear la clase tile_coordinate, crea un nuevo archivo de Verse con el nombre utilities.verse. Dentro de este archivo, crea un nuevo módulo con e nombre DataTypes.
DataTypes<public> := module:
Añade a este módulo la nueva clase TileCoordinate y define los componentes de la clase.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
En Batalla por coordenadas, estás creando una cuadrícula de tablero de 5 x 5. Esto significa que tienes que definir los límites del tablero de juego. Para ello, crea una nueva clase de límites (bounds) que defina un límite inferior y superior sobre lo pequeño o grande que puede ser un valor Left o Forward de tile_coordinate.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Se busca tener una estructura que contenga los límites de un solo tablero de juego en una estructura de datos. Para ello, crea una nueva clase board_bounds que defina un límite inferior y superior para cada uno de los componentes de 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
Cómo definir el tablero de juego
Ahora dispones de estructuras para:
Definir una representación de una casilla en el espacio de tablero.
Definir los límites del espacio de tablero.
Todavía falta una pieza importante: el propio tablero de juego. Para definir el tablero de juego, crea un nuevo archivo de Verse con el nombre board.verse y añade un nuevo dispositivo de Verse con el nombre board (tablero).
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):
El tablero debe incluir algunas cosas:
¿Dónde está situado el tablero en el espacio global?
¿Cuáles son los límites del tablero?
¿Cuál es el tamaño de una casilla del tablero?
La primera pregunta no necesita una nueva variable; puedes utilizar la transformación integrada del propio dispositivo. Puedes obtener la transformación de un dispositivo del modo Creativo con la función de la API GetTransform.
La segunda pregunta puede definirse con una variable board_bounds.
La tercera pregunta se puede resolver definiendo una variable vector2 para rastrear el tamaño de las casillas.
Estos dos últimos se añaden como campos para tu 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):
Cómo convertir del espacio de tablero al espacio global
A continuación, determina dónde se encuentra una casilla en el mundo como un vector3, dada una ubicación en el tablero de juego como una tile_coordinate. Asigna a esta función el nombre ToVector3. Esto se debe hacer dentro de los límites del tablero de juego para saber dónde se encuentra el centro del tablero.
Existe una ambigüedad concreta que tendrás que abordar primero. Dada una tile_coordinate, hay muchas ubicaciones vector3 diferentes en el mundo en la misma casilla. En lenguaje matemático, se trata de una función uno a muchos. Lo ideal sería elegir una única ubicación en el mundo para indicar dónde se encuentra la casilla en el espacio global. Una elección natural es el centro de la casilla.
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):
Esta función realiza lo siguiente:
Obtiene la transformación del tablero en el espacio global.
Obtiene la posición del tablero en el espacio global a partir de la transformación.
Calcula el desfase de la casilla de entrada con respecto al centro del tablero.
Añade el desfase al centro de la posición del tablero para obtener la posición con respecto al centro del mundo.
Cómo convertir del espacio global al espacio de tablero
Si tienes una ubicación en el espacio global como un vector3, tendrás que convertirla en tile_coordinate.
Construye una función con el nombre ToTileCoordinate. Esta función toma un vector3 como argumento y devuelve una tile_coordinate. Dada una ubicación en el espacio global como un vector3, es un poco más complejo determinar la ubicación en el tablero de juego como una tile_coordinate.
La razón principal por la que esto es más complejo es que, dado que el tablero es una cuadrícula discreta, existen muchas ubicaciones en el espacio global que no forman parte del tablero de juego. Por tanto, dada una posición en el espacio global como un vector3, es posible que la posición no esté en absoluto en el tablero de juego. Esto convierte a ToTileCoordinate en un candidato ideal para tener el especificador de efecto de función <decides>. La razón por la que es un candidato perfecto es porque hay muchas ubicaciones en el mundo del juego que no se encuentran en coordenadas de casilla. En este caso, cuando se intenta convertir una, se produce un error. Por ello, es importante saber cuándo esta conversión se realiza correctamente o falla. La función ToTileCoordinate primero decide si una ubicación se encuentra en el tablero de juego y, si es así, devuelve esa ubicación tile_coordinate.
Otra razón para el aumento de la complejidad es que una sola casilla está compuesta por muchas ubicaciones diferentes del mundo. En matemáticas, esto hace que la función ToTileCoordinate sea una función muchos a uno.
Para simplificar las cosas, separa la parte de fallo de ToTileCoordinate, define una función IsTileCoordinateOnBoard por separado y llámala dentro de 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 función IsTileCoordinateOnBoard realiza lo siguiente:
Determina si el componente Left de la coordenada de la casilla de entrada se encuentra dentro de los límites del tablero.
Determina si el componente Forward de la coordenada de la casilla de entrada se encuentra dentro de los límites del tablero.
La función IsTileCoordinateOnBoard tiene éxito si la coordenada de la casilla de entrada está dentro de los límites del tablero y falla en caso contrario.
La función ToTileCoordinate realiza lo siguiente:
Obtiene la transformación del espacio global del tablero.
Obtiene el centro de la ubicación del tablero desde el espacio global.
Calcula la posición relativa de la ubicación del mundo con respecto al centro del tablero.
Convierte la posición relativa del mundo en coordenadas de casilla.
Determina si las coordenadas de la casilla se encuentra en el tablero.
Devuelve la coordenada de la casilla si está en el tablero.
La función ToTileCoordinate tiene éxito si y solo si IsTileCoordinateOnBoard tiene éxito.
Ejemplo
La sección siguiente muestra un ejemplo en el que se toma una tile_coordinate y se convierte en un vector3, y luego se toma ese mismo vector3 y se vuelve a convertir en una tile_coordinate.
Coordenadas de casilla a Vector3
Supongamos que tienes lo siguiente:
Un tablero de juego de 5 x 5 casillas.
Una casilla de juego que mide 512.0 por 512.0 unidades cuadradas.
El tablero se encuentra en X:= 5000.0, Y:= 0.0, Z := 1000.0 en el espacio global.
A continuación se detallan los pasos para convertir la casilla con coordenadas de casilla Left := -1, Forward := 2.0 a espacio global.
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)
A continuación se indican los pasos para volver a convertir mediante la función 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}
Esta última tile_coordinate es exactamente igual que el valor inicial, lo que significa que todo ha funcionado como se esperaba.
Resumen
En resumen, esta página te ha guiado por los siguientes pasos:
Definir una representación de una casilla en el espacio de tablero.
Definir los límites del espacio de tablero.
Definir dónde se encuentra el espacio de tablero dentro del espacio global.
Convertir entre el espacio de tablero y el espacio global.
.udatasmith
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):
tipo