A primeira etapa na construção da lógica por trás do tabuleiro é decidir como representar programaticamente um ladrilho do tabuleiro.
Para designar como representar um ladrilho de tabuleiro, pense em como você e o jogador usam ladrilhos de tabuleiro. Um jogo de tabuleiro normalmente consiste em espaços discretos que são individualmente separados uns dos outros e distintos. Isso é diferente do espaço do mundo do UEFN.
No espaço do mundo, as coordenadas são representadas por posições de vector3, o que significa que as coordenadas podem estar tão próximas quanto os números de ponto flutuante podem estar, o que torna as coordenadas do mundo mais contínuas do que discretas. Além disso, há muitas posições de vector3 diferentes que estarão todos no mesmo ladrilho de tabuleiro. A partir disso, você pode concluir algumas coisas:
Como os ladrilhos do tabuleiro são discretos, você pode querer usar um tipo de dados discreto (dados discretos são dados que assumem uma faixa de valores que estão em correspondência com valores inteiros ou de número inteiro) para representar nossas posições, o que significa que se deve usar
intem vez defloat.typeComo o tabuleiro é bidimensional, você só precisa armazenar a posição dentro de duas dimensões. Você não precisa de uma estrutura de dados tridimensional para armazenar a posição dos ladrilhos do tabuleiro.
Definir tipos de dados do tabuleiro
A classe tile_coordinate representa onde um ladrilho está localizado no tabuleiro do jogo. Para criar a classe tile_coordinate, crie um novo arquivo Verse denominado utilities.verse. Dentro desse arquivo, crie um novo módulo denominado DataTypes.
DataTypes<public> := module:
Adicione a esse módulo a nova classe TileCoordinate e defina os componentes da classe.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Na Batalha de Coordenadas, você está criando uma grade de tabuleiro de 5 x 5. Isso significa que você precisa definir as delimitações do tabuleiro do jogo. Para fazer isso, crie uma nova delimitação de classe que defina uma delimitação alta e baixa de quão pequeno ou grande um valor de tile_coordinateLeft ou Forward pode ser.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Você deseja uma estrutura que mantenha as delimitações de um único tabuleiro de jogo em uma estrutura de dados. Para fazer isso, crie uma nova classe board_bounds que define uma delimitação baixa e alta para cada um dos componentes de um tile_coordinate.
using { /Verse.org/Simulation }
DataTypes<public> := module:
tile_coordinate<public> := class<concrete>:
@editable
Left<public>:int = 0
@editable
Forward<public>:int = 0
Definir tabuleiro de jogo
Agora você tem estruturas para:
Definir uma representação de um ladrilho no espaço do tabuleiro.
Definir as delimitações do espaço do tabuleiro.
Ainda está faltando uma peça grande: o tabuleiro propriamente dito. Para definir o tabuleiro do jogo, crie um novo arquivo do Verse denominado board.verse e adicione um novo dispositivo Verse denominado tabuleiro.
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):
O tabuleiro deve incluir algumas coisas:
Onde está o tabuleiro localizado no espaço do mundo?
Quais são as delimitações do tabuleiro?
Qual é o tamanho de um ladrilho de tabuleiro?
A primeira pergunta não precisa de uma nova variável; você pode usar a transformação integrada do próprio dispositivo. Você pode obter a transformação de um dispositivo do Modo Criativo com a função da API GetTransform.
A segunda pergunta pode ser definida com uma variável board_bounds.
A terceira questão pode ser resolvida definindo uma variável vector2 para rastrear o tamanho dos ladrilhos.
As duas últimas são adicionadas como campos para o seu dispositivo tabuleiro.
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):
Converter de espaço do tabuleiro para espaço do mundo
Em seguida, determine onde um ladrilho está localizado no mundo como um vector3, dada uma posição no tabuleiro do jogo como um tile_coordinate. Chame essa função de ToVector3. Isso deverá ser feito dentro das delimitações de um tabuleiro para saber onde está localizado o centro do tabuleiro.
Há uma ambiguidade específica que você precisará abordar primeiro. Dado um tile_coordinate, existem muitas posições de mundo vector3 diferentes no mesmo ladrilho. Na linguagem da matemática, esta é uma função de um para muitos. O ideal é que você escolhesse uma única posição no mundo para informar onde o ladrilho está no espaço do mundo. Uma escolha natural é o centro do ladrilho.
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 função executa o seguinte:
Obtém a transformação do tabuleiro no espaço do mundo.
Obtém a posição do tabuleiro no espaço do mundo a partir da transformação.
Calcula o deslocamento do ladrilho de entrada em relação ao centro do tabuleiro.
Adiciona o deslocamento ao centro da posição do tabuleiro para obter a posição em relação ao centro do mundo.
Converter o espaço do mundo em espaço do tabuleiro
Se você tiver uma posição no espaço do mundo como um vector3, precisará convertê-la em um tile_coordinate.
Crie uma função denominada ToTileCoordinate. Essa função recebe um vector3 como seu argumento e retorna um tile_coordinate. Dada uma posição no espaço do mundo como um vector3, é um pouco mais complexo determinar a localização no tabuleiro do jogo como um tile_coordinate.
O principal motivo disso ser mais complexo é que, como o tabuleiro é uma grade discreta, há muitas posições no espaço do mundo que não fazem parte do tabuleiro do jogo. Portanto, dada uma posição no espaço do mundo como um vector3, é possível que o local não esteja no tabuleiro do jogo. Isso torna ToTileCoordinate um candidato ideal para ter o especificador de efeito da função <decides>. A razão de ser um candidato perfeito é porque há muitas posições no mundo do jogo que não estão em uma coordenada de ladrilho. Nesse caso, a tentativa de converter um falhará. É importante saber quando essa conversão tem sucesso ou falha. A função ToTileCoordinate primeiro decide se uma posição está no tabuleiro de jogo e, se estiver, retorna essa posição como tile_coordinate.
Outro motivo para o aumento da complexidade é que um único ladrilho é composto de várias posições do mundo diferentes. Em matemática, isso torna a função ToTileCoordinate uma função de muitos para um.
Para deixar as coisas mais limpas, separe a parte de falha de ToTileCoordinate, defina uma função IsTileCoordinateOnBoard separadamente e chame-a em 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):
A função IsTileCoordinateOnBoard executa o seguinte:
Determina se o componente esquerdo das coordenadas do ladrilho de entrada está entre as delimitações do tabuleiro
Determina se o componente para a frente da coordenada do ladrilho de entrada está entre as delimitações do tabuleiro
A função IsTileCoordinateOnBoard será bem-sucedida se a coordenada de ladrilho de entrada estiver dentro das limitações do tabuleiro e falhará em caso contrário.
A função ToTileCoordinate executa o seguinte:
Obtém a transformação do espaço do mundo do tabuleiro.
Obtém o centro da posição do tabuleiro a partir do espaço do mundo.
Calcula a posição relativa da localização do mundo em relação ao centro do tabuleiro.
Converte a posição relativa do mundo em coordenadas de ladrilhos.
Determina se a coordenada de ladrilho está no tabuleiro.
Retorna as coordenadas do ladrilho se estiver no tabuleiro.
A função ToTileCoordinate será bem-sucedida se e somente se IsTileCoordinateOnBoard for bem-sucedida.
Exemplo
A seção abaixo funciona com um exemplo de como pegar um tile_coordinate e converter em um vector3, em seguida, pegar esse mesmo vector3 e convertê-lo de volta em um tile_coordinate.
Coordenadas de ladrilhos em Vector3
Suponha que você tenha o seguinte:
Um tabuleiro de jogo que tem 5 por 5 ladrilhos.
Um ladrilho de jogo que tem 512,0 por 512,0 unidades quadradas.
O tabuleiro está localizado em x := 5000,0, Y:= 0,0, Z := 1000,0 no espaço do mundo.
Abaixo estão as etapas para converter o ladrilho com as coordenadas de ladrilho Esquerda := -1, Para a frente := 2.0 no espaço do mundo.
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 seguir estão as etapas para converter de volta usando a função 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}
Este último tile_coordinate é exatamente igual ao valor inicial, o que significa que tudo funcionou conforme o esperado.
Resumo
Em suma, esta página guia você pelas seguintes etapas:
Definir uma representação de um ladrilho no espaço do tabuleiro.
Definir as delimitações do espaço do tabuleiro.
Definir onde o espaço do tabuleiro está localizado no espaço do mundo.
Converter entre o espaço do tabuleiro e o espaço do mundo.
Arquivos
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