El primer paso para construir la lógica del tablero de juego es decidir cómo representar programáticamente un cuadro del tablero.
Para diseñar cómo representar un cuadro del tablero, piensa en cómo tú y el jugador utilizan los cuadros del tablero. Un juego de mesa típicamente consiste en espacios discretos que están individualmente separados entre sí y son distintos. Esto es diferente del espacio del entorno en UEFN.
En el espacio del entorno, las coordenadas se representan mediante ubicaciones del vector3, lo que significa que pueden estar tan cerca unas de otras como lo permitan los números de punto flotante, lo que hace que las coordenadas del entorno sean más continuas que discretas. Además, hay muchas ubicaciones diferentes de vector3 que estarán en el mismo cuadro del tablero. A partir de esto, se pueden concluir algunas cosas:
Dado que los cuadros del tablero son discretos, es conveniente usar un tipo de dato discreto (los datos discretos son aquellos que toman un conjunto de valores que corresponden a números enteros o valores numéricos exactos) para representar las ubicaciones, lo que significa que se debe usar
inten lugar defloat.El tablero es bidimensional, por lo que solo necesitas almacenar una ubicación dentro de dos dimensiones. No necesitas una estructura de datos tridimensional para almacenar la ubicación del cuadro del tablero.
Definición de los tipos de datos del tablero
La clase tile_coordinate representa la ubicación de un cuadro en el tablero de juego. Para crear la clase tile_coordinate, crea un nuevo archivo de Verse denominado utilities.verse. Dentro de este archivo, crea un nuevo módulo denominado 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 construyendo una cuadrícula de tablero de 5x5. Esto significa que debes definir los límites del tablero de juego. Para hacer esto, crea una nueva clase bounds que defina un límite inferior y superior sobre cuán pequeño o grande puede ser un valor de tile_coordinateLeft o Forward.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Necesitas una estructura que contenga los límites de un solo tablero de juego en una única estructura de datos. Para hacer esto, crea una nueva clase board_bounds que defina un límite inferior y superior para cada uno de los componentes de un tile_coordinate.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Definición del tablero de juego
Ahora tienes estructuras para hacer lo siguiente:
Definir una representación de un cuadro en el espacio del tablero.
Definir los límites del espacio del tablero.
Todavía falta una pieza grande: el tablero de juego. Para definir el tablero de juego, crea un nuevo archivo de Verse llamado board.verse y añade un nuevo dispositivo de Verse llamado 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):
El tablero debe incluir lo siguiente:
¿Dónde se encuentra el tablero en el espacio del entorno?
¿Cuáles son los límites del tablero?
¿Cuál es el tamaño de un cuadro del tablero?
La primera pregunta no necesita una nueva variable; puedes utilizar la transformación integrada del propio dispositivo. Puedes obtener transform de un dispositivo del modo Creativo con la función de API GetTransform.
La segunda pregunta se puede definir con una variable board_bounds.
La tercera pregunta se puede resolver definiendo una variable vector2 para rastrear el tamaño del cuadro.
Los dos últimos se añaden como campos para el dispositivo de 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):
Conversiones del espacio del tablero al espacio del entorno
Ahora, determina dónde se encuentra un cuadro en el entorno como vector3, dada una ubicación en el tablero de juego como tile_coordinate. Nombra esta función ToVector3. Esto debe hacerse dentro de los límites del tablero de juego para saber dónde se encuentra el centro del tablero.
Existe una ambigüedad particular que deberás abordar primero. Dado un tile_coordinate, hay muchas ubicaciones diferentes del entorno vector3 en el mismo cuadro. En el lenguaje de las matemáticas, esta es una función de uno a muchos. Lo ideal sería elegir una única ubicación del entorno para indicar dónde reside el cuadro en el espacio del entorno. Una elección natural es el centro del mosaico.
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 hace lo siguiente:
Obtiene la transformación del tablero en el espacio del entorno.
Obtiene la ubicación del tablero en el espacio del entorno a partir de la transformación.
Calcula el desplazamiento del cuadro de entrada con respecto al centro del tablero.
Añade el desplazamiento al centro de la ubicación del tablero para obtener la ubicación con respecto al centro del entorno.
Conversión del espacio del entorno al espacio del tablero
Si tienes una ubicación en el espacio del entorno como vector3, tendrás que convertirla a tile_coordinate.
Construye una función llamada ToTileCoordinate. Esta función toma vector3 como argumento y devuelve tile_coordinate. Dada una ubicación en el espacio del entorno como un vector3, es un poco más complejo determinar la ubicación del 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, hay muchas ubicaciones en el espacio del entorno que no forman parte del tablero de juego. Por lo tanto, dada una ubicación en el espacio del entorno como vector3, es posible que la ubicació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 entorno del juego que no se encuentran en una coordenada de cuadro. En este caso, se produce un error al intentar convertir uno. Es importante saber cuándo esta conversión tiene éxito o falla. La función ToTileCoordinate primero decide si una ubicación se encuentra en el tablero de juego y, si lo es, devuelve esa ubicación tile_coordinate.
Otro motivo del aumento de la complejidad es que un mismo cuadro está formado por muchas ubicaciones del entorno diferentes. En matemáticas, esto hace que la función ToTileCoordinate sea una función de 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 hace lo siguiente:
Determina si el componente izquierdo de la coordenada del cuadro de entrada está entre los límites del tablero.
Determina si el componente de avance de la coordenada del cuadro de entrada está entre los límites del tablero.
La función IsTileCoordinateOnBoard tiene éxito si la coordenada del mosaico de entrada está dentro de los límites del tablero y falla en caso contrario.
La función ToTileCoordinate hace lo siguiente:
Obtiene la transformación del espacio del entorno del tablero.
Obtiene el centro de la ubicación del tablero desde el espacio del entorno.
Calcula la posición relativa de la ubicación del entorno con respecto al centro del tablero.
Convierte la ubicación relativa del entorno a una coordenada de cuadro.
Determina si la coordenada del cuadro está en el tablero.
Devuelve la coordenada del cuadro si está en el tablero.
La función ToTileCoordinate se ejecuta correctamente si, y solo si, IsTileCoordinateOnBoard también se ejecuta correctamente.
Ejemplo
La siguiente sección 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 convierte de nuevo en una tile_coordinate.
Coordenada de cuadro a Vector3
Supongamos que tienes lo siguiente:
Un tablero de juego que tiene mosaicos de 5 por 5.
Un mosaico de juego que mide 512,0 por 512,0 unidades cuadradas.
El tablero de juego está ubicado en X := 5000,0, Y:= 0,0, Z := 1000,0 en el espacio del entorno.
A continuación, se detallan los pasos para convertir el cuadro con coordenadas de cuadro Left := -1, Forward := 2.0 al espacio del entorno.
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)
Los siguientes son 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 funcionó como se esperaba.
Resumen
En resumen, esta página te llevó a través de los siguientes pasos:
Definir una representación de un cuadro en el espacio del tablero.
Definir los límites del espacio del tablero.
Definir dónde se encuentra el espacio del tablero dentro del espacio del entorno.
Convertir del espacio del tablero al espacio del entorno.
Archivos
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