/// <summary>
/// Actualiza todos los objetos que estan activos actualmente en escena
/// </summary>
private void UpdateActive(bool playableLevel)
{
activeEnemies.Clear();
activeWalls.Clear();
activeTerminals.Clear();
activeDoors.Clear();
if (playableLevel)
{
// Guardamos los enemigos
activeEnemies.AddRange(activeBoard.GetBoardEnemies());
// Guardamos los muros
activeWalls.AddRange(activeBoard.GetBoardWalls());
// Guardamos las terminales
activeTerminals.AddRange(activeBoard.GetBoardTerminals());
// Guardamos las puertas
activeDoors.AddRange(activeBoard.GetBoardDoors());
}
// Guardamos el jugador
activePlayer = activeBoard.GetPlayer();
// Guardamos la camara
activeCamera = activeBoard.GetCamera();
}
/// <summary>
/// Funcion encargada de hacer el Setup del Board iniciando todas sus estructuras logicas
/// </summary>
/// <param name="manager">Manager del cubo</param>
/// <param name="playableLevel">Indica si el nivel es de paso o de juego</param>
public void SetupBoard(BGameManager manager, bool playableLevel)
{
// GUardamos el manager
gameManager = manager;
// Primero observamos el sistema de coordenadas que vamos a utilizar
// El sistema elegido dependera de las coordenadas que provengan del boardInfo
if (boardInfo.x && boardInfo.y)
{
coordSys = ECord.XY;
}
else if (boardInfo.x && boardInfo.z)
{
coordSys = ECord.XZ;
}
else if (boardInfo.y && boardInfo.z)
{
coordSys = ECord.YZ;
}
else
{
Debug.LogError("Por favor indique en la informacion del tablero dos coordenadas para el systema de coordenadas");
}
// Obtenemos el tamaño de la casilla base y lo guardamos para usarlo mas tarde
Vector3 tileSize = Tile.GetComponent <Renderer>().bounds.size;
tileSize1 = (int)tileSize.x;
tileSize2 = (int)tileSize.z;
tileSize3 = tileSize.y;
// Obtenemos todas las casillas de la escena activas
Object[] boardTiles = GetComponentsInChildren <BTile>();
// Obtenemos la coordenada de la superficie para poder spawnear particulas mas tarde en esta
BTile aux = (BTile)boardTiles[0];
switch (coordSys)
{
case ECord.XY:
surfaceCoord = aux.gameObject.transform.position.z + aux.transform.up.z * tileSize3 / 2;
break;
case ECord.XZ:
surfaceCoord = aux.gameObject.transform.position.y + aux.transform.up.y * tileSize3 / 2;
break;
case ECord.YZ:
surfaceCoord = aux.gameObject.transform.position.x + aux.transform.up.x * tileSize3 / 2;
break;
default:
break;
}
// A partir de todas estas casillas obtenemos sus posiciones en el sistema
List <float> firstPositions = new List <float>();
List <float> secondPositions = new List <float>();
foreach (BTile item in boardTiles)
{
// Dependiendo del sistema de coordenadas guardamos unos valores diferentes
switch (coordSys)
{
case ECord.XY:
firstPositions.Add(item.gameObject.transform.position.x);
secondPositions.Add(item.gameObject.transform.position.y);
break;
case ECord.XZ:
firstPositions.Add(item.gameObject.transform.position.x);
secondPositions.Add(item.gameObject.transform.position.z);
break;
case ECord.YZ:
firstPositions.Add(item.gameObject.transform.position.y);
secondPositions.Add(item.gameObject.transform.position.z);
break;
default:
break;
}
}
// Guardamos la posicion minima para usarla mas tarde
min1 = firstPositions.Min();
min2 = secondPositions.Min();
max1 = firstPositions.Max();
max2 = secondPositions.Max();
// Calculamos el tamaño del tablero a partir de las posiciones y de los tamaños
size1 = Mathf.RoundToInt((max1 - min1) / tileSize1) + 1;
size2 = Mathf.RoundToInt((max2 - min2) / tileSize2) + 1;
// Spawneamos el plano de collision para detectar los clicks
SpawnCollisionPlane();
// Premaramos el diccionario con las diferentes direcciones
indexDirections.Add("Up", size1);
indexDirections.Add("Down", -size1);
indexDirections.Add("Left", -1);
indexDirections.Add("Right", 1);
//Para cada casilla almacenamos su posicion y como referente guardamos su indice en el array
foreach (BTile item in boardTiles)
{
//Calculamos el nuevo indice para guardar en el diccionario de localizaciones
Vector3 position = item.gameObject.transform.position;
int firstIndex = 0;
int secondIndex = 0;
switch (coordSys)
{
case ECord.XY:
// Calculamos los indices respecto a las posiciones
firstIndex = Mathf.RoundToInt((position.x - min1) / tileSize1);
secondIndex = Mathf.RoundToInt((position.y - min2) / tileSize2) * size1;
// Guardamos en el diccionario el index con su respectiva posicion
locations.Add((firstIndex + secondIndex), new Vector2(position.x, position.y));
tiles.Add((firstIndex + secondIndex), item);
break;
case ECord.XZ:
// Calculamos los indices respecto a las posiciones
firstIndex = Mathf.RoundToInt((position.x - min1) / tileSize1);
secondIndex = Mathf.RoundToInt((position.z - min2) / tileSize2) * size1;
// Guardamos en el diccionario el index con su respectiva posicion
locations.Add((firstIndex + secondIndex), new Vector2(position.x, position.z));
tiles.Add((firstIndex + secondIndex), item);
break;
case ECord.YZ:
// Calculamos los indices respecto a las posiciones
firstIndex = Mathf.RoundToInt((position.y - min1) / tileSize1);
secondIndex = Mathf.RoundToInt((position.z - min2) / tileSize2) * size1;
// Guardamos en el diccionario el index con su respectiva posicion
locations.Add((firstIndex + secondIndex), new Vector2(position.y, position.z));
tiles.Add((firstIndex + secondIndex), item);
break;
default:
break;
}
//Guardamos el indice de la casilla inicial y final
if (item.currentState == BTile.ETileState.Start)
{
startIndex = firstIndex + secondIndex;
}
else if (item.currentState == BTile.ETileState.End)
{
endIndex.Add(firstIndex + secondIndex);
}
}
// Para cada casilla almacenamos sus bordes usando como referente su indice en el array
foreach (int index in locations.Keys)
{
// Llamamos a la funcion CreateLocalEdges que nos devuelve los bordes del indice
edges.Add(index, CreateLocalEdges(index));
}
// Añadimos los bordes de las paredes
AddWallsEdges();
// Ponemos a 0 los bordes del tablero
SetBorderEdges();
// Obtenemos la posicion y rotacion para instanciar al jugador
Vector3 playerPos = GetPlayerSpawnPos(boardInfo.player.GetComponent <Renderer>().bounds.size.y);
Quaternion playerRot = GetPlayerSpawnRot();
// Instanciamos al jugador
GameObject playerGO = Instantiate(boardInfo.player, playerPos, playerRot);
// Obtenemos el script del jugador y lo guardamos
player = playerGO.GetComponent <BPlayer>();
player.transform.parent = this.transform;
// Hacemos el setup del jugador
player.SetupPlayer(manager, playerInfo, endIndex);
// Obtenemos la roatacion de los elementos del tablero para cuando spawneemos particulas
spawnRotation = player.transform.rotation;
if (playableLevel)
{
// Obtenemos todos los enemigos y los guardamos en la lista
foreach (BEnemy enemy in GetComponentsInChildren <BEnemy>())
{
enemy.SetupEnemy(manager);
enemiesPos.Add(enemy.GetEnemyIndex());
}
// Iniciamos las puertas del nivel
foreach (BPuerta puerta in GetComponentsInChildren <BPuerta>())
{
puerta.SetupDoor(manager);
}
foreach (BTerminal terminal in GetComponentsInChildren <BTerminal>())
{
terminal.SetupTerminal(manager);
}
foreach (BBaliza baliza in GetComponentsInChildren <BBaliza>())
{
baliza.SetupBaliza(manager);
}
}
else
{
// Obtenemos todos los enemigos y los desactivamos
foreach (BEnemy enemy in GetComponentsInChildren <BEnemy>())
{
enemy.EndEnemy();
}
}
// Spawneamos el target de la camara y lo colocamos en el centro
GameObject target = new GameObject("Camera Target");
target.transform.position = Vector3.zero;
target.transform.rotation = Quaternion.identity;
target.transform.parent = this.transform;
// Instanciamos la camara
GameObject cameraGO = Instantiate(boardInfo.camera, cameraInfo.position, Quaternion.Euler(cameraInfo.rotation));
cameraGO.transform.parent = target.transform;
// Guardamos el script de la camara
camera = cameraGO.GetComponent <BCameraController>();
// Ejecutamos el Setup
camera.SetupCamera(manager, cameraInfo);
}
