static bool Calcular(int[,] tabla, Celda[] l, int n, int[,] r) {
if(l.Length == n) {
return true;
} else {
bool aux; int k;
foreach(int v in l[n].libres) {
//***************************************************
// Prueba del candidato
//***************************************************
aux = true;
for(k = n - 1; k >= 0 && aux; k--) {
if((l[k].i == l[n].i || l[k].j == l[n].j || Zona(l[k]) == Zona(l[n])) &&
r[l[k].i, l[k].j] == v) {
aux = false;
}
}
//***************************************************
// Prueba de los candidatos
//***************************************************
if(aux) {
// Meter número
r[l[n].i, l[n].j] = v;
// Siguiente casilla
if(Calcular(tabla, l, n + 1, r)) {
return true;
}
}
}
return false;
}
}
/**
* Este constructor nos permite crear un tablero idéntico a otro ya existente.
*/
public Tablero(Tablero tablero)
{
tamaño = tablero.getTamaño();
celdas = new Celda[tamaño, tamaño];
for (int a = 0; a < getTamaño(); a++)
for (int b = 0; b < getTamaño(); b++)
getTablero()[a, b] = new Celda(a, b, tablero.getCelda(a,b).getFicha());
}
public bool get_Cambiar_Mapa(MapaTeleportCeldas direccion, Celda celda)
{
if (cuenta.esta_ocupado)
{
return(false);
}
if (!get_Puede_Cambiar_Mapa(direccion, celda))
{
return(false);
}
return(get_Mover_Para_Cambiar_mapa(celda));
}
public bool get_Cambiar_Mapa(MapaTeleportCeldas direccion, Celda celda)
{
if (cuenta.esta_ocupado() || personaje.inventario.porcentaje_pods >= 100)
{
return(false);
}
if (!get_Puede_Cambiar_Mapa(direccion, celda))
{
return(false);
}
return(get_Mover_Para_Cambiar_mapa(celda));
}
public List <Celda> get_Celdas_Adyecentes(Celda nodo, bool utilizar_diagonales)
{
List <Celda> celdas_adyecentes = new List <Celda>();
Celda celda_derecha = celdas.FirstOrDefault(nodec => nodec.x == nodo.x + 1 && nodec.y == nodo.y);
Celda celda_izquierda = celdas.FirstOrDefault(nodec => nodec.x == nodo.x - 1 && nodec.y == nodo.y);
Celda celda_inferior = celdas.FirstOrDefault(nodec => nodec.x == nodo.x && nodec.y == nodo.y + 1);
Celda celda_superior = celdas.FirstOrDefault(nodec => nodec.x == nodo.x && nodec.y == nodo.y - 1);
if (celda_derecha != null)
{
celdas_adyecentes.Add(celda_derecha);
}
if (celda_izquierda != null)
{
celdas_adyecentes.Add(celda_izquierda);
}
if (celda_inferior != null)
{
celdas_adyecentes.Add(celda_inferior);
}
if (celda_superior != null)
{
celdas_adyecentes.Add(celda_superior);
}
Celda superior_izquierda = celdas.FirstOrDefault(nodec => nodec.x == nodo.x - 1 && nodec.y == nodo.y - 1);
Celda inferior_derecha = celdas.FirstOrDefault(nodec => nodec.x == nodo.x + 1 && nodec.y == nodo.y + 1);
Celda inferior_izquierda = celdas.FirstOrDefault(nodec => nodec.x == nodo.x - 1 && nodec.y == nodo.y + 1);
Celda superior_derecha = celdas.FirstOrDefault(nodec => nodec.x == nodo.x + 1 && nodec.y == nodo.y - 1);
if (superior_izquierda != null)
{
celdas_adyecentes.Add(superior_izquierda);
}
if (superior_derecha != null)
{
celdas_adyecentes.Add(superior_derecha);
}
if (inferior_derecha != null)
{
celdas_adyecentes.Add(inferior_derecha);
}
if (inferior_izquierda != null)
{
celdas_adyecentes.Add(inferior_izquierda);
}
return(celdas_adyecentes);
}
/*
* Funcion: renderCelda()
*
* Si <celda> ya ha sido rendered, y <celda> esta vacia (saturacion = 0), ejecuta la operacion de unrender para <celda>.
* Si <celda> no esta vacia (saturacion > 0), ejecuta la operacion de actualizacion de render para <celda>.
*/
public void renderCelda(Celda celda, int act_index)
{
if (celda.rendered)
{
if (celda.estaVacia())
{
unrenderCelda(celda, act_index);
}
else
{
actualizarCelda(celda);
}
}
}
// Token: 0x060001CC RID: 460 RVA: 0x000083C8 File Offset: 0x000067C8
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(short hechizo_id, Celda celda_actual, Celda celda_objetivo, Mapa mapa)
{
Hechizo hechizo = this.cuenta.juego.personaje.get_Hechizo(hechizo_id);
bool flag = hechizo == null;
FallosLanzandoHechizo result;
if (flag)
{
result = FallosLanzandoHechizo.DESONOCIDO;
}
else
{
HechizoStats stats = hechizo.get_Stats();
bool flag2 = stats.lanzamientos_por_objetivo > 0 && this.total_hechizos_lanzados_en_celda.ContainsKey((int)hechizo_id) && this.total_hechizos_lanzados_en_celda[(int)hechizo_id].ContainsKey((int)celda_objetivo.id) && this.total_hechizos_lanzados_en_celda[(int)hechizo_id][(int)celda_objetivo.id] >= (int)stats.lanzamientos_por_objetivo;
if (flag2)
{
result = FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS_POR_OBJETIVO;
}
else
{
bool flag3 = stats.es_celda_vacia && !this.es_Celda_Libre(celda_objetivo);
if (flag3)
{
result = FallosLanzandoHechizo.NECESITA_CELDA_LIBRE;
}
else
{
bool flag4 = stats.es_lanzado_linea && !this.jugador_luchador.celda.get_Esta_En_Linea(celda_objetivo);
if (flag4)
{
result = FallosLanzandoHechizo.NO_ESTA_EN_LINEA;
}
else
{
bool flag5 = !this.get_Rango_hechizo(celda_actual, stats, mapa).Contains(celda_objetivo.id);
if (flag5)
{
result = FallosLanzandoHechizo.NO_ESTA_EN_RANGO;
}
else
{
result = FallosLanzandoHechizo.NINGUNO;
}
}
}
}
}
return(result);
}
void Awake()
{
celda = GetComponent <Celda>();
spawnNumeroCelda = GetComponent <SpawnNumeroCelda>();
spawnAux = GetComponent <SpawnNumeroAux>();
keys[0] = KeyCode.Alpha1;
keys[1] = KeyCode.Alpha2;
keys[2] = KeyCode.Alpha3;
keys[3] = KeyCode.Alpha4;
keys[4] = KeyCode.Alpha5;
keys[5] = KeyCode.Alpha6;
keys[6] = KeyCode.Alpha7;
keys[7] = KeyCode.Alpha8;
keys[8] = KeyCode.Alpha9;
}
private bool get_Mover_Para_Cambiar_mapa(Celda celda)
{
ResultadoMovimientos resultado = get_Mover_A_Celda(celda, mapa.celdas_ocupadas());
switch (resultado)
{
case ResultadoMovimientos.EXITO:
cuenta.logger.log_informacion("MOVIMIENTO", $"Map Actuel: {mapa.id} changement de map via la cellule {celda.id} ");
return(true);
default:
cuenta.logger.log_Error("MOVIMIENTO", $"Chemin vers {celda.id} résultat échoué ou bloqué : {resultado}");
return(false);
}
}
/// <summary>
/// Identificar las denominaciones solicitadas.
/// </summary>
private void identificarDenominaciones(DocumentoExcel documento, Celda celda_a, Celda celda_b)
{
for (int columna = celda_a.Columna; columna <= celda_b.Columna; columna++)
{
Celda celda_denominacion = documento.seleccionarCelda(celda_a.Fila, columna);
decimal valor = decimal.Parse(celda_denominacion.Valor);
Monedas moneda = celda_denominacion.Texto.StartsWith("$") ?
Monedas.Dolares : Monedas.Colones;
Denominacion denominacion = new Denominacion(valor: valor, moneda: moneda);
_mantenimiento.verificarDenominacion(ref denominacion);
_denominaciones.Add(columna, denominacion);
}
}
private bool get_Mover_Para_Cambiar_mapa(Celda celda)
{
ResultadoMovimientos resultado = get_Mover_A_Celda(celda, mapa.celdas_ocupadas().Where(c => c.tipo != TipoCelda.CELDA_TELEPORT).ToList());
switch (resultado)
{
case ResultadoMovimientos.EXITO:
cuenta.logger.log_informacion("MOUVEMENT", $"{mapa.coordenadas} changement de map via la cellule {celda.id} ");
return(true);
default:
cuenta.logger.log_Error("MOUVEMENT", $"Chemin vers {celda.id} résultat échoué ou bloqué : {resultado}");
return(false);
}
}
private List <Celda> DevolverSolucion(Celda inicio, Celda final)
{
List <Celda> camino = new List <Celda>();
Celda celdaActual = final;
while (celdaActual != inicio)
{
camino.Add(celdaActual);
celdaActual = celdaActual.m_QuienMeAgrego;
}
camino.Reverse();
return(camino);
}
private bool get_Mover_Para_Cambiar_mapa(Celda celda)
{
ResultadoMovimientos resultado = get_Mover_A_Celda(celda, mapa.celdas_ocupadas());
switch (resultado)
{
case ResultadoMovimientos.EXITO:
cuenta.logger.log_informacion("MOVIMIENTOS", $"Mapa actual: {mapa.id} desplazando para cambiar el mapa a la casilla: {celda.id}");
return(true);
default:
cuenta.logger.log_Error("MOVIMIENTOS", $"camino hacia {celda.id} fallado o bloqueado resultado: {resultado}");
return(false);
}
}
// Token: 0x060003FD RID: 1021 RVA: 0x0000EB54 File Offset: 0x0000CF54
public static IEnumerable <Celda> Get_Lista_Celdas_Rango_Hechizo(Celda celda, HechizoStats spellLevel, Mapa mapa, int rango_adicional = 0)
{
int radio_maximo = (int)spellLevel.alcanze_maximo + (spellLevel.es_alcanze_modificable ? rango_adicional : 0);
bool es_lanzado_linea = spellLevel.es_lanzado_linea;
IEnumerable <Celda> result;
if (es_lanzado_linea)
{
result = Shaper.Cruz(celda.x, celda.y, (int)spellLevel.alcanze_minimo, radio_maximo, mapa);
}
else
{
result = Shaper.Anillo(celda.x, celda.y, (int)spellLevel.alcanze_minimo, radio_maximo, mapa);
}
return(result);
}
/*
* Funcion: inicializarGrid()
*
* Inicializa <grid>, la estructura de datos que contiene todas las celdas del entorno.
*
* <grid> es una lista, donde cada entrada contiene una matriz bidimensional de celdas. Cada entrada de la lista representa
* un plano de celdas con el mismo <indice_y>. Estos son almacenados como matrices bidimensionales de celdas, donde las
* dimensiones representan el <indice_x> y el <indice_z> de cada celda.
*
* Ejemplo: grid[1][2,3] contiene la celda con <indice_y> = 1, <indice_x> = 2, <indice_z> = 3.
*/
void inicializarGrid()
{
grid = new List <Celda[, ]>();
for (int y = 0; y < tamano_y; ++y)
{
grid.Add(new Celda[tamano_x, tamano_z]);
for (int x = 0; x < tamano_x; ++x)
{
for (int z = 0; z < tamano_z; ++z)
{
grid[y][x, z] = new Celda(x, y, z);
}
}
}
}
private List <short> get_Camino_Retroceso(Celda nodo_inicial, Celda nodo_final)
{
Celda nodo_actual = nodo_final;
List <short> celdas_camino = new List <short>();
while (nodo_actual != nodo_inicial)
{
celdas_camino.Add(nodo_actual.id);
nodo_actual = nodo_actual.nodo_padre;
}
celdas_camino.Add(nodo_inicial.id);
celdas_camino.Reverse();
return(celdas_camino);
}
private NodoRango get_Nodo_Rango(Celda celda, MovimientoNodo node, PeleaHechizos hechizo_pelea, HechizoStats hechizo_stats)
{
Dictionary <short, byte> enemigos_golpeados = new Dictionary <short, byte>();
List <short> rango = pelea.get_Rango_Hechizo(celda, hechizo_stats, mapa);
for (int i = 0; i < rango.Count; i++)
{
byte tec = get_Total_Enemigos_Atacados(celda, mapa.get_Celda_Id(rango[i]), hechizo_pelea, hechizo_stats);
if (tec > 0)
{
enemigos_golpeados.Add(rango[i], tec);
}
}
return(new NodoRango(celda, enemigos_golpeados, node));
}
public void MoverTorreta(Celda celda)
{
GameObject torreta = torretas.Dequeue(); //desencolo primer elementeo
TorretaSimple torretaActual = torreta.GetComponent <TorretaSimple>();
torretaActual.m_CeldaActual.m_EsAliada = true;//tildo la celda de la torreta como aliada
torreta.transform.position = celda.transform.position; //cambio posicion de la torreta a la nueva posicion
torretaActual.m_CeldaActual = celda;
torretas.Enqueue(torreta); //encolo nueva torreta
celda.m_EsAliada = false;
}
private static char get_Direccion_Dos_Celdas(short celda_1, short celda_2, bool es_pelea, Mapa mapa)
{
if (celda_1 == celda_2 || mapa == null)
{
return((char)0);
}
Celda celda1 = mapa.celdas[celda_1], celda2 = mapa.celdas[celda_2];
if (!es_pelea)
{
byte mapa_anchura = mapa.anchura;
int[] _loc6_ = { 1, mapa_anchura, (mapa_anchura * 2) - 1, mapa_anchura - 1, -1, -mapa_anchura, (-mapa_anchura * 2) + 1, -(mapa_anchura - 1) };
int _loc7_ = celda_2 - celda_1;
for (int i = 7; i >= 0; i += -1)
{
if (_loc6_[i] == _loc7_)
{
return((char)(i + 'a'));
}
}
}
int resultado_x = celda2.x - celda1.x;
int resultado_y = celda2.y - celda1.y;
if (resultado_x == 0)
{
if (resultado_y > 0)
{
return((char)(3 + 'a'));
}
else
{
return((char)(7 + 'a'));
}
}
else if (resultado_x > 0)
{
return((char)(1 + 'a'));
}
else
{
return((char)(5 + 'a'));
}
}
public static int get_Tiempo_Desplazamiento_Mapa(Celda casilla_actual, List <short> celdas_camino, Mapa _mapa)
{
int tiempo_desplazamiento = 20;
DuracionAnimacion tipo_animacion = celdas_camino.Count < 6 ? tiempo_tipo_animacion[TipoAnimacion.CAMINANDO] : tiempo_tipo_animacion[TipoAnimacion.CORRIENDO];
Celda siguiente_celda;
for (int i = 0; i < celdas_camino.Count - 1; i++)
{
siguiente_celda = _mapa.celdas[celdas_camino[i + 1]];
if (casilla_actual.y == siguiente_celda.y)
{
tiempo_desplazamiento += tipo_animacion.horizontal;
}
else if (casilla_actual.x == siguiente_celda.y)
{
tiempo_desplazamiento += tipo_animacion.vertical;
}
else
{
tiempo_desplazamiento += tipo_animacion.lineal;
}
if (casilla_actual.layer_ground_nivel < siguiente_celda.layer_ground_nivel)
{
tiempo_desplazamiento += 100;
}
else if (siguiente_celda.layer_ground_nivel > casilla_actual.layer_ground_nivel)
{
tiempo_desplazamiento -= 100;
}
else if (casilla_actual.layer_ground_slope != siguiente_celda.layer_ground_slope)
{
if (casilla_actual.layer_ground_slope == 1)
{
tiempo_desplazamiento += 100;
}
else if (siguiente_celda.layer_ground_slope == 1)
{
tiempo_desplazamiento -= 100;
}
}
casilla_actual = siguiente_celda;
}
return(tiempo_desplazamiento);
}
/*
* Funcion: spawnAtRandom()
*
* Simula la introduccion de liquido en celdas aleatorias del entorno.
*/
public void spawnAtRandom()
{
if (testDelay > 0)
{
testDelay = 0;
float min_height = 0.7f;
Vector3 indexes = new Vector3(UnityEngine.Random.Range(0, tamano_x), UnityEngine.Random.Range(tamano_y * min_height, tamano_y), UnityEngine.Random.Range(0, tamano_z));
Celda cell = getCelda((int)indexes.x, (int)indexes.y, (int)indexes.z);
if (cell.estaVacia() && !cell.esCeldaSolida())
{
cell.setSaturacion(1f);
}
}
testDelay++;
}
// Token: 0x06000454 RID: 1108 RVA: 0x0000FC6C File Offset: 0x0000E06C
public bool get_Cambiar_Mapa(MapaTeleportCeldas direccion, Celda celda)
{
bool flag = this.cuenta.esta_ocupado() || this.personaje.inventario.porcentaje_pods >= 100;
bool result;
if (flag)
{
result = false;
}
else
{
bool flag2 = this.get_Puede_Cambiar_Mapa(direccion, celda);
bool flag3 = !flag2;
result = (!flag3 && this.get_Mover_Para_Cambiar_mapa(celda));
}
return(result);
}
/// <summary>
/// Leer los montos del archivo y generar las cargas.
/// </summary>
private void generarSucursales()
{
DocumentoExcel archivo = null;
try
{
_filas_incorrectas.Clear();
_sucursales.Clear();
_denominaciones.Clear();
archivo = new DocumentoExcel(_archivo, false);
archivo.seleccionarHoja(1);
Celda celda_sucursal = archivo.seleccionarCelda(mtbSucursalCelda.Text);
Celda celda_provincia = archivo.seleccionarCelda(mtbProvinciaCelda.Text);
Celda celda_ciudad = archivo.seleccionarCelda(mtbCiudadCelda.Text);
Celda celda_tipo = archivo.seleccionarCelda(mtbceldaTipSucursal.Text);
Celda celda_transportadora = archivo.seleccionarCelda(mtbTransportadoraCelda.Text);
Celda celda_entidad = archivo.seleccionarCelda(mtbEntidad.Text);
this.generarSucursalesDatos(archivo, celda_sucursal, celda_provincia, celda_ciudad, celda_tipo, celda_transportadora, celda_entidad);
dgvCargas.DataSource = _sucursales;
archivo.mostrar();
archivo.cerrar();
// Dar formato a las cargas
foreach (DataGridViewRow fila in dgvCargas.Rows)
{
this.validarCarga(fila);
}
}
catch (Exception ex)
{
archivo.mostrar();
archivo.cerrar();
throw ex;
}
}
/// <summary>
/// Lee el archivo a importar y genera las cargas
/// </summary>
private void generarPlanillas()
{
DocumentoExcel archivo = null;
try
{
_planillas.Clear();
archivo = new DocumentoExcel(_archivo, false);
archivo.seleccionarHoja(1);
Celda celda_Fecha = archivo.seleccionarCelda(mtbCeldaFecha.Text);
Celda celda_Manifiesto = archivo.seleccionarCelda(mtbManifiestoCelda.Text);
Celda celda_Transportadora = archivo.seleccionarCelda(mtbTransportadoraPlanillaCelda.Text);
Celda celda_Tula = archivo.seleccionarCelda(mtbTulaCelda.Text);
Celda celda_Monto_Tula = archivo.seleccionarCelda(mtbMonto_tula.Text);
Celda celda_Monto_Planilla = archivo.seleccionarCelda(mtbMonto_Planilla.Text);
Celda celda_ID_Punto_Venta = archivo.seleccionarCelda(mtbID_PDV.Text);
Celda celda_Punto_Venta = archivo.seleccionarCelda(mtbPDV.Text);
Celda celda_Tarifa = archivo.seleccionarCelda(mtbCeldaTarifa.Text);
Celda celda_Recargo = archivo.seleccionarCelda(mtbCeldaRecargo.Text);
Celda celda_Total = archivo.seleccionarCelda(mtbCeldaTotal.Text);
this.generarPlanillasDatos(archivo, celda_Fecha, celda_Manifiesto, celda_Transportadora, celda_Tula, celda_Monto_Tula, celda_Monto_Planilla, celda_ID_Punto_Venta, celda_Punto_Venta, celda_Tarifa, celda_Recargo, celda_Total);
dgvPlanillas.DataSource = _planillas;
dgvPlanillasProcesadas.DataSource = _planillaprocesados;
//archivo.mostrar();
archivo.cerrar();
// Dar formato a las cargas
//foreach (DataGridViewRow fila in dgvPlanillas.Rows)
// this.validarCarga(fila);
}
catch (Exception ex)
{
archivo.mostrar();
archivo.cerrar();
throw ex;
}
}
/// <summary>
/// Generar las cargas para una moneda específica.
/// </summary>
private void generarCargasCompass(DocumentoExcel archivo, Celda celda_codigo, Celda celda_cuenta, Celda celda_monto, Celda celda_referencia, Celda celda_puntoventa,
Celda celda_identificacion, Celda celda_deposito, Celda celda_manifiesto, Celda celda_cliente, int variable)
{
// Leer las denominaciones
while (!celda_codigo.Valor.Equals(string.Empty))
{
string codigo = celda_codigo.Valor;
string cuenta = celda_cuenta.Valor;
Decimal monto = Convert.ToDecimal(celda_monto.Valor);
string referencia = celda_referencia.Valor;
string puntoventa = celda_puntoventa.Valor;
string identificacion = celda_identificacion.Valor;
string deposito = celda_deposito.Valor;
string manifiesto = celda_manifiesto.Valor;
string cliente = celda_cliente.Valor;
DepositoAcreditacion carga = new DepositoAcreditacion(codigo: codigo, cuenta: cuenta, referencia: referencia, puntoventa: puntoventa,
identificacion: identificacion, deposito: deposito, manifiesto: manifiesto, cliente: cliente, monto: monto);
celda_codigo = archivo.seleccionarCelda(celda_codigo.Fila + 1, celda_codigo.Columna);
celda_cuenta = archivo.seleccionarCelda(celda_cuenta.Fila + 1, celda_cuenta.Columna);
celda_monto = archivo.seleccionarCelda(celda_monto.Fila + 1, celda_monto.Columna);
celda_referencia = archivo.seleccionarCelda(celda_referencia.Fila + 1, celda_referencia.Columna);
celda_puntoventa = archivo.seleccionarCelda(celda_puntoventa.Fila + 1, celda_puntoventa.Columna);
celda_identificacion = archivo.seleccionarCelda(celda_identificacion.Fila + 1, celda_identificacion.Columna);
celda_deposito = archivo.seleccionarCelda(celda_deposito.Fila + 1, celda_deposito.Columna);
celda_manifiesto = archivo.seleccionarCelda(celda_manifiesto.Fila + 1, celda_manifiesto.Columna);
celda_cliente = archivo.seleccionarCelda(celda_cliente.Fila + 1, celda_cliente.Columna);
if (variable == 1)
{
_cargas.Add(carga);
}
else
{
_cargas_transportadora.Add(carga);
}
}
}
/// <summary>
/// Leer las rutas del archivo y generar las cargas.
/// </summary>
private void generarRutas()
{
DocumentoExcel archivo = null;
try
{
_filas_incorrectas.Clear();
_cargas.Clear();
//_denominaciones.Clear();
archivo = new DocumentoExcel(_archivo, false);
archivo.seleccionarHoja(1);
Celda celda_a = archivo.seleccionarCelda(mtbPrimeraCelda.Text);
Celda celda_atm = archivo.seleccionarCelda(mtbatmcelda.Text);
Celda celda_ruta = archivo.seleccionarCelda(mtbRutaCelda.Text);
Celda celda_hora = archivo.seleccionarCelda(mtbHoraCelda.Text);
DateTime fecha = dtpFecha.Value;
this.generarCargasATMs(archivo, fecha, celda_a, celda_atm, celda_ruta, celda_hora);
dgvCargasSucursales.DataSource = _cargas;
archivo.mostrar();
archivo.cerrar();
// Dar formato a las cargas
foreach (DataGridViewRow fila in dgvCargasSucursales.Rows)
{
}
//this.validarCarga(fila);
}
catch (Exception ex)
{
archivo.mostrar();
archivo.cerrar();
throw ex;
}
}
public Mapa()
{
anchura = 200;
altura = 200;
celdas = new Celda[anchura, altura];
anchuraVentana = 41;
alturaVentana = 21;
// Rellenamos el mapa con celdas vacias
for (int x = 0; x < celdas.GetLength(0); x++)
{
for (int y = 0; y < celdas.GetLength(1); y++)
{
celdas[x, y] = new Celda();
celdas[x, y].estado = EstadoCelda.vacio;
}
}
}
//Dadas una posición x e y, hará que el puntero se mueva por la escena de 1 unidad en 1
private void moverse(float x, float y)
{
if (!personajeMov)
{
//Nos moveremos
transform.Translate(new Vector3(x, y, 0));
//Nota: otra forma de moverse poniendo la posición absoluta
//transform.position = new Vector3(x, y, transform.position.z);
//Y luego cargaremos las estadísticas de la unidad seleccionada por pantalla (si la hay)
CargarDatos();
}
else
{
/* En el caso de que haya un personaje moviéndose, el puntero sólo podrá moverse por las celdas que esten al alcance del personaje y nunca fuera de estas*/
float xAbsoluta = transform.position.x;
float yAbsoluta = transform.position.y;
//Sumaremos la x e y absolutas a sus contrapartes relativas para obtener la posición absoluta de la celda
Celda celda = new Celda((int)(xAbsoluta + x), (int)(yAbsoluta + y));
//Comprobaremos si esta celda está dentro de la lista
if (controlador.dentroLaLista(celda))
{
//Nos moveremos a esta celda
transform.Translate(new Vector3(x, y, 0));
}
//Si hay una acción en curso
if (controlador.getAccionEnCurso())
{
//Obtendremos la posición del objetivo seleccionado en la matriz del mapa
Personaje objetivo = controlador.getPosMapa((int)(xAbsoluta + x), (int)(yAbsoluta + y));
//Pasaremos al objetivo al controlador para que guarde su referencia
controlador.set_Objetivo(objetivo);
//Y mostraremos las previsiones del objetivo y de la unidad seleccionada
controlador.mostrarPrevisionesObjetivo();
controlador.mostrarPrevisionesUnidadSeleccionada();
}
}
}
public bool get_Puede_Cambiar_Mapa(MapaTeleportCeldas direccion, Celda celda)
{
switch (direccion)
{
case MapaTeleportCeldas.IZQUIERDA:
return((celda.x - 1) == celda.y);
case MapaTeleportCeldas.DERECHA:
return((celda.x - 27) == celda.y);
case MapaTeleportCeldas.ABAJO:
return((celda.x + celda.y) == 31);
case MapaTeleportCeldas.ARRIBA:
return(celda.y < 0 && (celda.x - Math.Abs(celda.y)) == 1);
}
return(true); // direccion NINGUNA
}
public bool get_Puede_Cambiar_Mapa(MapaTeleportCeldas direccion, Celda celda)
{
switch (direccion)
{
case MapaTeleportCeldas.LEFT:
return((celda.x - 1) == celda.y);
case MapaTeleportCeldas.RIGHT:
return((celda.x - 27) == celda.y);
case MapaTeleportCeldas.BOTTOM:
return((celda.x + celda.y) == 31);
case MapaTeleportCeldas.TOP:
return(celda.y < 0 && (celda.x - Math.Abs(celda.y)) == 1);
}
return(true); // direccion NINGUNA
}
private bool get_Mover_Para_Cambiar_mapa(Celda celda)
{
switch (get_Mover_A_Celda(celda, mapa.celdas_ocupadas))
{
case ResultadoMovimientos.EXITO:
if (GlobalConf.mostrar_mensajes_debug)
{
cuenta.logger.log_informacion("MOVIMIENTOS", $"Mapa actual: {mapa.id} desplazando para cambiar el mapa a la casilla: " + celda.id);
}
return(true);
default:
if (GlobalConf.mostrar_mensajes_debug)
{
cuenta.logger.log_informacion("MOVIMIENTOS", $"camino hacia {celda.id} fallado o bloqueado");
}
return(false);
}
}
public bool get_Verificar_Direccion_Correcta(MapaTeleportCeldas direccion, Celda celda)
{
switch (direccion)
{
case MapaTeleportCeldas.IZQUIERDA:
return((celda.x - 1) == celda.y || (celda.x - 2) == celda.y);
case MapaTeleportCeldas.DERECHA:
return(celda.x - (mapa.anchura + mapa.altura - 5) == celda.y || celda.x - (mapa.anchura + mapa.altura - 5) == celda.y - 1);
case MapaTeleportCeldas.ABAJO:
return(celda.y + celda.x > (mapa.anchura + mapa.altura - 5));
case MapaTeleportCeldas.ARRIBA:
return(celda.y < 0 && (celda.x - Math.Abs(celda.y)) < 5);
}
return(direccion == MapaTeleportCeldas.NINGUNO); //direccion ninguna
}
private int tamañoMaximo = 10,tamañoMinimo=6; //dimensiones minimas y maximas del tablero
#endregion Fields
#region Constructors
/**
* Creamos el tablero y establecemos su tamaño.
* @param tamaño del tablero.
*/
public Tablero(int tamaño)
{
//Ajustamos el tamaño
if (tamaño % 2 != 0) tamaño += 1;
if (tamaño < tamañoMinimo || tamaño > tamañoMaximo) tamaño = 8;
this.tamaño = tamaño;
celdas = new Celda[tamaño, tamaño];
int tmp = getTamaño() / 2 - 1; //Temporal para establecer las posiciones iniciales
//Creamos las celdas
for (int a = 0; a < getTamaño(); a++)
for (int b = 0; b < getTamaño(); b++)
getTablero()[a, b] = new Celda(a, b, '-');
//Establecemos el contenido de las celdas centrales
getCelda(tmp, tmp).setFicha('X');
getCelda(tmp, tmp + 1).setFicha('O');
getCelda(tmp + 1, tmp).setFicha('O');
getCelda(tmp + 1, tmp + 1).setFicha('X');
}
/**
* Esta función comprueba si hay celdas afectadas.
* En ese caso, las pasa a una variable global pública.
* @param celda de la jugada que vamos a comprobar.
* @return boolean dependiendo de si hay celdas afectadas o no.
*/
public bool comprobarSiHayCeldasAfectadas(Celda celda)
{
//Posibles celdas en donde buscará continuar
//Son las colindantes con ficha del oponente
List<Celda> viasTemporales = new List<Celda>();
//Celdas que igual cambiamos o igual no.
List<Celda> tmpCeldasFinales;
//Rotaciones que debemos hacer para recorrer una fila, columna o diagonal
int x_rotar, y_rotar, x_base_rotar, y_base_rotar;
//Inicializamos outputceldas para que se vacie.
outputCeldas = new List<Celda>();
int[,] posiciones = new int[8, 2];
posiciones[0, 0] = -1; posiciones[0, 1] = -1;
posiciones[1, 0] = -1; posiciones[1, 1] = 0;
posiciones[2, 0] = -1; posiciones[2, 1] = 1;
posiciones[3, 0] = 0; posiciones[3, 1] = -1;
posiciones[4, 0] = 0; posiciones[4, 1] = 1;
posiciones[5, 0] = 1; posiciones[5, 1] = -1;
posiciones[6, 0] = 1; posiciones[6, 1] = 0;
posiciones[7, 0] = 1; posiciones[7, 1] = 1;
//Visitamos todas las posibles posiciones en las que puede seguir la fila
for(int a=0;a<8;a++)
if (celda.getY() + posiciones[a, 0] >= 0 && celda.getY() + posiciones[a, 0] < tamaño
&& celda.getX() + posiciones[a, 1] >= 0 && celda.getX() + posiciones[a, 1] < tamaño
&& getCelda(celda.getY() + posiciones[a, 0], celda.getX() + posiciones[a, 1]).getFicha() == Jugador.fichaOponente(celda.getFicha()))
viasTemporales.Add(new Celda(celda.getY() + posiciones[a, 0], celda.getX() + posiciones[a, 1],
getCelda(celda.getY() + posiciones[a, 0], celda.getX() + posiciones[a, 1]).getFicha()));
//Hasta este momento hemos obtenido las direcciones de las celdas a las que podemos ir en busca de una ruta a voltear.
foreach (Celda viatemporal in viasTemporales)
{
tmpCeldasFinales = new List<Celda>();
//Obtenemos una base con la que iremos permutando
x_base_rotar = viatemporal.getX() - celda.getX();
y_base_rotar = viatemporal.getY() - celda.getY();
x_rotar = x_base_rotar;
y_rotar = y_base_rotar;
//Por si no entramos en el while, hay que aumentarlas igualmente
/*if (!(celda.getY() + y_rotar >= 0 && celda.getY() + y_rotar < tamaño && celda.getX() + x_rotar >= 0 && celda.getX() + x_rotar < tamaño &&
getCelda(celda.getY() + y_rotar, celda.getX() + x_rotar).getFicha() == Jugador.fichaOponente(celda.getFicha())))
{
y_rotar += y_base_rotar;
x_rotar += x_base_rotar;
}*/
//En este while vamos buscando rutas
while (celda.getY() + y_rotar >= 0 && celda.getY() + y_rotar < tamaño && celda.getX() + x_rotar >= 0 && celda.getX() + x_rotar < tamaño &&
getCelda(celda.getY() + y_rotar, celda.getX() + x_rotar).getFicha() == Jugador.fichaOponente(celda.getFicha()))
{
//Vamos añadiendo celdas y vamos rotando para hacernos con esa línea
tmpCeldasFinales.Add(new Celda(celda.getY() + y_rotar, celda.getX() + x_rotar, celda.getFicha()));
y_rotar += y_base_rotar;
x_rotar += x_base_rotar;
}
//Una vez llegado al limite, comprobamos si la ficha que hemos encontrado es nuestra
//En tal caso, volteamos todo
if (celda.getX() + x_rotar >= 0 && celda.getX() + x_rotar < tamaño && celda.getY() + y_rotar >= 0 && celda.getY() + y_rotar < tamaño
&& (getCelda(celda.getY() + y_rotar, celda.getX() + x_rotar).getFicha() == celda.getFicha()))
{
//Añadimos la celda actual
outputCeldas.Add(celda);
//Y las celdas que hemos obtenido (su ruta)
outputCeldas.AddRange(tmpCeldasFinales);
}
} //foreach
//Dependiendo de si tenemos algo en el output, devolvemos true o false.
if (outputCeldas.Count != 0)
return true;
return false;
}
/**
* Esta función nos devuelve si el movimiento pasado por parámetro es legal.
* @param celda del movimiento que queremos realizar.
* @return boolean dependiendo de si es legal o no el movimiento.
*/
public Boolean esLegal(Celda celda)
{
//Para que sea un movimiento legal, la celda tiene que estar vacia, y tiene que haber casillas afectadas
if (celda!=null && getCelda(celda.getY(),celda.getX()).getFicha()=='-' && comprobarSiHayCeldasAfectadas(celda))
return true;
return false;
}
/*
* Funcion: inicializarGrid()
*
* Inicializa <grid>, la estructura de datos que contiene todas las celdas del entorno.
*
* <grid> es una lista, donde cada entrada contiene una matriz bidimensional de celdas. Cada entrada de la lista representa
* un plano de celdas con el mismo <indice_y>. Estos son almacenados como matrices bidimensionales de celdas, donde las
* dimensiones representan el <indice_x> y el <indice_z> de cada celda.
*
* Ejemplo: grid[1][2,3] contiene la celda con <indice_y> = 1, <indice_x> = 2, <indice_z> = 3.
*/
void inicializarGrid()
{
grid = new List<Celda[,]>();
for (int y = 0; y < tamano_y; ++y) {
grid.Add (new Celda[tamano_x, tamano_z]);
for (int x = 0; x < tamano_x; ++x) {
for (int z = 0; z < tamano_z; ++z) {
grid[y][x, z] = new Celda(x, y, z);
}
}
}
}
static int Zona(Celda x) {
return M * (x.i / M) + x.j / M;
}