///----------------------> Torres
public void AgregarTorre(Torre m, int bando)
{
if (bando == 1)
{
jugador1.torres.Add(m);
}
else
{
jugador2.torres.Add(m);
}
}
public void QuitarTorre(Torre m, int bando)
{
if (bando == 1)
{
jugador1.torres.Remove(m);
}
else
{
jugador2.torres.Remove(m);
}
}
/// <summary>
/// Agrega una torre a la base de datos
/// </summary>
/// <remarks>
/// Permite agregar una torre a la base de datos.
/// </remarks>
/// <param name="torre">Torre que queremos añadir</param>
/// <returns>Tarea de añadir una torre</returns>
public async Task AgregarTorre(Torre torre)
{
int result = 0;
try
{
result = await conn.InsertAsync(torre);
}
catch (Exception ex)
{
}
}
public void LaTorreNonPuòRestareFerma(Colore c)
{
//Given
var torre = new Torre(c);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.A,
traversaPartenza: Traversa.Prima,
colonnaArrivo: Colonna.A,
traversaArrivo: Traversa.Prima
);
Assert.False(esito);
}
public void LaTorreMuoveAvantiDiQuattroCase()
{
//Given
Torre torre = new Torre(Colore.Bianco);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.F,
traversaPartenza: Traversa.Quarta,
colonnaArrivo: Colonna.F,
traversaArrivo: Traversa.Ottava);
//Then
Assert.True(esito);
}
public void LaTorreMuoveIndietroDiTreCase()
{
//Given
Torre torre = new Torre(Colore.Bianco);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.F,
traversaPartenza: Traversa.Quarta,
colonnaArrivo: Colonna.F,
traversaArrivo: Traversa.Prima);
//Then
Assert.True(esito);
}
public void LaTorreMuoveASinistraDiCinqueCase()
{
//Given
Torre torre = new Torre(Colore.Bianco);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.F,
traversaPartenza: Traversa.Quinta,
colonnaArrivo: Colonna.A,
traversaArrivo: Traversa.Quinta);
//Then
Assert.True(esito);
}
public void LaTorreNonPuòRimanereFermaUnaVoltaScelta()
{
//Given
Torre torre = new Torre(Colore.Bianco);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.F,
traversaPartenza: Traversa.Quinta,
colonnaArrivo: Colonna.F,
traversaArrivo: Traversa.Quinta);
//Then
Assert.False(esito);
}
public void LaTorrePuoMoversiInOrizzontale()
{
//Given
Torre torre = new Torre(Colore.Nero);
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.A,
traversaPartenza: Traversa.Ottava,
colonnaArrivo: Colonna.H,
traversaArrivo: Traversa.Ottava);
//Then
Assert.True(esito);
}
static void Main(string[] args)
{
StreamWriter writer;
Scacchiera s = Scacchiera.Istanza;
Pedone p = new Pedone(Colore.Bianco)
{
Posizione = s.GetCella('B', 2)
};
Torre t = new Torre(Colore.Bianco)
{
Posizione = s.GetCella('C', 1)
};
Alfiere a = new Alfiere(Colore.Bianco)
{
Posizione = s.GetCella('E', 2)
};
Re re = new Re(Colore.Bianco)
{
Posizione = s.GetCella('E', 1)
};
Regina r = new Regina(Colore.Bianco)
{
Posizione = s.GetCella('G', 3)
};
Cavallo c = new Cavallo(Colore.Bianco)
{
Posizione = s.GetCella('F', 2)
};
s.Print();
Console.WriteLine();
Console.WriteLine("".PadRight(40, '-'));
Console.WriteLine();
try
{
p.Muovi(s.GetCella('B', 3));
t.Muovi(s.GetCella('C', 4));
a.Muovi(s.GetCella('B', 5));
re.Muovi(s.GetCella('F', 1));
r.Muovi(s.GetCella('G', 5));
c.Muovi(s.GetCella('E', 5));
s.Stampa();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
public Peca PromoverPeao(Movimento m, int tipoNovaPeca)
{
int indicePeao = 0;
Peca peaoAtual = m.destino.PecaAtual;
//tipoNovaPeca = FUNÇÂOQUEUSAINTERFACEPARADEFINIR (TODO)
// acha a posicao do peao no array de peças do jogador
foreach (Peca p in peaoAtual.jDono.conjuntoPecas)
{
if (p == peaoAtual)
{
break;
}
indicePeao++;
}
Peca novaPeca;
//se 1, então vira rainha
//se 2, então vira torre
//se 3, então vira cavalo
//senao, então vira Bispo
if (tipoNovaPeca == 1)
{
novaPeca = new Rainha(peaoAtual.jDono);
}
else if (tipoNovaPeca == 2)
{
novaPeca = new Torre(peaoAtual.jDono);
}
else if (tipoNovaPeca == 3)
{
novaPeca = new Cavalo(peaoAtual.jDono);
}
else
{
novaPeca = new Bispo(peaoAtual.jDono);
}
//define a posição e salva a peça na casa e no jogador
novaPeca.jDono.conjuntoPecas[indicePeao] = novaPeca;
m.destino.ColocarPeca(novaPeca);
novaPeca.CasaAtual = m.destino;
novaPeca.UltimoTurnoMovido = this.UltimoTurnoMovido;
return(novaPeca);
}
public static Peca ObterPeca(CorPeca cor, NomePeca nome)
{
Peca pecaXadrez = null;
if (nome == NomePeca.Torre)
{
pecaXadrez = new Torre((Cor)cor, nome.ToString());
}
else if (nome == NomePeca.Rei)
{
pecaXadrez = new Rei((Cor)cor, nome.ToString());
}
return(pecaXadrez);
}
static void Main(string[] args)
{
Tabuleiro tab = new Tabuleiro(8, 8);
Bispo bp = new Bispo(tab, Cor.Preta);
Torre t1p = new Torre(tab, Cor.Preta);
Torre t2p = new Torre(tab, Cor.Preta);
Rei rp = new Rei(tab, Cor.Preta);
tab.colocarPeca(t1p, new Posicao(0, 0));
tab.colocarPeca(t2p, new Posicao(1, 3));
tab.colocarPeca(rp, new Posicao(2, 4));
Tela.imprimirTabuleiro(tab);
Console.WriteLine();
}
public void LaTorreNonPuoMuovereInDiagonale(Colore colore)
{
//Given
Torre torre = new Torre(colore);
Scacchiera scacchiera = new Scacchiera();
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.A,
traversaPartenza: Traversa.Prima,
colonnaArrivo: Colonna.F,
traversaArrivo: Traversa.Quarta,
scacchiera: scacchiera);
//Then
Assert.False(esito);
}
public void LaTorrePuoMuovereInVerticale(Colore colore)
{
//Given
Torre torre = new Torre(colore);
Scacchiera scacchiera = new Scacchiera();
//When
bool esito = torre.PuòMuovere(
colonnaPartenza: Colonna.A,
traversaPartenza: Traversa.Prima,
colonnaArrivo: Colonna.A,
traversaArrivo: Traversa.Sesta,
scacchiera: scacchiera);
//Then
Assert.True(esito);
}
/// <summary>
/// Genera una fabrica con tres productos válidos para utilizarse en las pruebas de fabricación
/// </summary>
/// <returns></returns>
public Fabrica getFabricaCompleta()
{
Fabrica fabrica = Fabrica.Instance;
fabrica.ResetearFabrica();
Insumo maderaUno = new Madera(ETipoMadera.Mdf, EForma.Tablon, 100);
Insumo maderaDos = new Madera(ETipoMadera.Pino, EForma.Tablon, 200);
Insumo maderaSecundaria = new Madera(ETipoMadera.Mdf, EForma.Tubo, 100);
Insumo telaUno = new Tela(EColor.Bordo, ETipoTela.Alfombra, 100);
Insumo telaDos = new Tela(EColor.Rosa, ETipoTela.Corderito, 200);
Insumo adicionalUno = new InsumoAccesorio(ETipoAccesorio.Barniz, 300);
Insumo adicionalDos = new InsumoAccesorio(ETipoAccesorio.Tornillo, 300);
Insumo adicionalTres = new InsumoAccesorio(ETipoAccesorio.Pegamento, 300);
List <Insumo> insumosAgregar = new List <Insumo>();
insumosAgregar.Add(adicionalUno);
insumosAgregar.Add(adicionalDos);
insumosAgregar.Add(adicionalTres);
insumosAgregar.Add(maderaUno);
insumosAgregar.Add(maderaDos);
insumosAgregar.Add(maderaSecundaria);
insumosAgregar.Add(telaUno);
insumosAgregar.Add(telaDos);
Madera maderaProductoUno = new Madera(ETipoMadera.Mdf, EForma.Tablon, 4);
Madera maderaSecundariaProducto = new Madera(ETipoMadera.Mdf, EForma.Tubo, 3);
Tela telaProducto = new Tela(EColor.Bordo, ETipoTela.Alfombra, 3);
List <Insumo> faltantes = new List <Insumo>();
Producto productoUno = new Torre(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Bordo, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.King, new Madera(ETipoMadera.Mdf, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA));
Producto productoDos = new Torre(new Madera(ETipoMadera.Pino, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Rosa, ETipoTela.Corderito, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.King, new Madera(ETipoMadera.Mdf, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA));
Producto productoTres = new Estante(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_ESTANTE), new Tela(EColor.Rosa, ETipoTela.Corderito, Fabrica.CANTIDAD_TELA_ESTANTE), 3);
fabrica.AgregarInsumosAStock(insumosAgregar);
fabrica.AgregarProductoLineaProduccion(productoUno, out faltantes);
fabrica.AgregarProductoLineaProduccion(productoDos, out faltantes);
fabrica.AgregarProductoLineaProduccion(productoTres, out faltantes);
return(fabrica);
}
private void ProcessarMovimentacao(Game game, int disco, Torre origem, Torre destino)
{
var isValid = (!destino.Discos.Any() || destino.Discos.First().Id > disco) &&
(!game.IsFinalDoJogo());
if (isValid)
{
ArmazenarMovimento(game.Id, disco, origem.Id, destino.Id);
logService.CriarLogMovimento(game.Id, disco, origem.Id, destino.Id);
game.QuantidadeDeMovimentosExecutados++;
}
if (game.IsFinalDoJogo())
{
logService.FinalizarHistorico(game.Id);
}
}
private void OnMouseDown()
{
// Buscar el script torre
Torre torre = torreObject.GetComponentInChildren <Torre>();
// Verificar que tenemos suficiente oro para construir esta torre
if (Jugador.oro >= torre.costoOro)
{
Instantiate(torreObject, transform.parent.position, Quaternion.identity);
Destroy(transform.parent.gameObject);
// Solo empezar a poner enemigos cuando haya por lo menos una torre
FindObjectOfType <PoolingUnidades>().hayTorres = true;
// Descontar el oro gastado
Jugador.oro -= torre.costoOro;
}
}
public void laTorrePuòMangiarePezzoAvversarioInOrizzontaleEVerticale(
Colonna colonnaPartenza, Traversa traversaPartenza,
Colonna colonnaArrivo, Traversa traversaArrivo,
Colore colore, Colore colorePezzoBloccante,
Colonna colonnaPezzoBloccante,
Traversa traversaPezzoBloccante)
{
//Given
Torre torre = new Torre(colore);
Scacchiera scacchiera = new Scacchiera();
scacchiera[colonnaPezzoBloccante, traversaPezzoBloccante].PezzoPresente =
new Pedone(colorePezzoBloccante);
//When
bool esito = torre.PuòMuovere(colonnaPartenza, traversaPartenza,
colonnaArrivo, traversaArrivo, scacchiera);
//Then
Assert.True(esito);
}
public void laTorreNonSiPuòMuovereSeUnPezzoBloccaLoSpostamento(
Colonna colonnaPartenza, Traversa traversaPartenza,
Colonna colonnaArrivo, Traversa traversaArrivo,
Colore colore, Colore colorePezzoBloccante,
Colonna colonnaPezzoBloccante,
Traversa traversaPezzoBloccante)
{
//Given
Torre torre = new Torre(colore);
Scacchiera scacchiera = new Scacchiera();
scacchiera[colonnaPezzoBloccante, traversaPezzoBloccante].PezzoPresente =
new Pedone(colorePezzoBloccante);
//When
bool esito = torre.PuòMuovere(colonnaPartenza, traversaPartenza,
colonnaArrivo, traversaArrivo, scacchiera);
//Then
Assert.False(esito);
}
public async Task <ActionResult <Torre> > Post(
[FromServices] DataContext context,
[FromBody] Torre model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
context.Torre.Add(model);
await context.SaveChangesAsync();
return(Ok(model));
}
catch
{
return(BadRequest(new { message = "Não foi possivel concluir o cadastro" }));
}
}
//clasico
public void GenerarNivel1() //jugador 1 rojas, jugador 2 blancas
{
FichaLogica faraonR = new Faraon(0, 1, 1, 5, 7); fichaslogicasactivas.Add(faraonR);
FichaLogica faraonB = new Faraon(0, 6, 2, 4, 0); fichaslogicasactivas.Add(faraonB);
//piramides rojas
FichaLogica piramideR1 = new Piramide(0, 3, 1, 7, 7); fichaslogicasactivas.Add(piramideR1);
FichaLogica piramideR2 = new Piramide(0, 3, 1, 2, 6); fichaslogicasactivas.Add(piramideR2);
FichaLogica piramideR3 = new Piramide(0, 3, 1, 0, 4); fichaslogicasactivas.Add(piramideR3);
FichaLogica piramideR4 = new Piramide(0, 3, 1, 7, 4); fichaslogicasactivas.Add(piramideR4);
FichaLogica piramideR5 = new Piramide(0, 3, 1, 0, 3); fichaslogicasactivas.Add(piramideR5);
FichaLogica piramideR6 = new Piramide(0, 3, 1, 7, 3); fichaslogicasactivas.Add(piramideR6);
FichaLogica piramideR7 = new Piramide(0, 3, 2, 3, 5); fichaslogicasactivas.Add(piramideR7);
//piramides blancas
FichaLogica piramideB1 = new Piramide(0, 8, 2, 7, 1); fichaslogicasactivas.Add(piramideB1);
FichaLogica piramideB2 = new Piramide(0, 8, 2, 2, 3); fichaslogicasactivas.Add(piramideB2);
FichaLogica piramideB3 = new Piramide(0, 8, 2, 9, 3); fichaslogicasactivas.Add(piramideB3);
FichaLogica piramideB4 = new Piramide(0, 8, 2, 2, 4); fichaslogicasactivas.Add(piramideB4);
FichaLogica piramideB5 = new Piramide(0, 8, 2, 9, 4); fichaslogicasactivas.Add(piramideB5);
FichaLogica piramideB6 = new Piramide(0, 8, 1, 6, 2); fichaslogicasactivas.Add(piramideB6);
FichaLogica piramideB7 = new Piramide(0, 8, 2, 2, 0); fichaslogicasactivas.Add(piramideB7);
//Generador Rojo
FichaLogica generadorR = new Generador(0, 0, 1, 0, 7); fichaslogicasactivas.Add(generadorR);
//Generador Blanco
FichaLogica generadorB = new Generador(0, 5, 2, 9, 0); fichaslogicasactivas.Add(generadorB);
//Escarabajo Rojo
FichaLogica escarabajoR1 = new Escarabajo(0, 4, 1, 4, 4); fichaslogicasactivas.Add(escarabajoR1);
FichaLogica escarabajoR2 = new Escarabajo(0, 4, 1, 5, 4); fichaslogicasactivas.Add(escarabajoR2);
//Escarabajo Blanco
FichaLogica escarabajoB1 = new Escarabajo(0, 9, 2, 4, 3); fichaslogicasactivas.Add(escarabajoB1);
FichaLogica escarabajoB2 = new Escarabajo(0, 9, 2, 5, 3); fichaslogicasactivas.Add(escarabajoB2);
//Torre Roja
FichaLogica torreR1 = new Torre(0, 2, 1, 4, 7); fichaslogicasactivas.Add(torreR1);
FichaLogica torreR2 = new Torre(0, 2, 1, 6, 7); fichaslogicasactivas.Add(torreR2);
//Torre Blanca
FichaLogica torreB1 = new Torre(0, 7, 2, 3, 0); fichaslogicasactivas.Add(torreB1);
FichaLogica torreB2 = new Torre(0, 7, 2, 5, 0); fichaslogicasactivas.Add(torreB2);
}
void OnMouseDown()
{
GameObject temp;
Vector3 pos = this.transform.position;
pos.y = pos.y + .4f;
temp = (GameObject)Instantiate(go_torre, pos, Quaternion.identity);
temp.transform.position = pos;
temp.layer = 7;
torre = temp.GetComponent <Torre>();
hud = Hud.GetInstance();
if (torre.Valor_nivel_actual <= hud.Contador_monedas)
{
torre.Esta_activa = true;
Destroy(this.gameObject);
hud.DescontarSaldo(torre.Valor_nivel_actual);
}
else
{
Destroy(temp);
hud.ErrorSaldoInsuficiente();
}
}
public void CalcularMovimento(Game game, int disco, Torre origem, Torre destino, Torre torreTemporaria)
{
if (game == null || origem == null || destino == null || torreTemporaria == null)
{
throw new ArgumentNullException("Parametros não podem ser null");
}
if (disco == 0 && origem.Discos.Any())
{
ProcessarMovimentacao(game, origem.Discos.ElementAt(0).Id, origem, destino);
destino.Discos.Insert(0, origem.Discos.ElementAt(0));
origem.Discos.RemoveAt(0);
}
else
{
if (!game.IsFinalDoJogo())
{
CalcularMovimento(game, disco - 1, origem, torreTemporaria, destino);
var dId = origem.Discos.Any() ? origem.Discos.ElementAt(0).Id : torreTemporaria.Discos.ElementAt(0).Id;
ProcessarMovimentacao(game, dId, origem, destino);
if (origem.Discos.Any())
{
destino.Discos.Insert(0, origem.Discos.ElementAt(0));
origem.Discos.RemoveAt(0);
}
CalcularMovimento(game, disco - 1, torreTemporaria, destino, origem);
}
}
}
static void Main(string[] args)
{
Console.Title = "Seghesio, Marcos Daniel TP3 2D";
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("----------Fabrica de Productos para Gatos: demostración Consola--------");
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
// Declarar los objetos necesarios para leer archivos XML
FabricaXmlService serviceXmlFabrica = new FabricaXmlService($"{AppDomain.CurrentDomain.BaseDirectory}Origen\\");
Fabrica fabrica = serviceXmlFabrica.ReadXmlFabrica();
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.WriteLine("------------Atributos asignados a fabrica correctamente----------------");
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("---------------------Iterar lista de insumos --------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
foreach (Insumo i in fabrica.StockInsumos)
{
Console.WriteLine(i.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
//1- Usuario Ingresa insumos a fabrica existente
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("---------------------Agregar nuevos Insumos----------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
List <Insumo> insumosAgregar = new List <Insumo>();
Insumo maderaUno = new Madera(ETipoMadera.Pino, EForma.Tablon, 10);
Insumo maderaSecundaria = new Madera(ETipoMadera.Pino, EForma.Tubo, 5);
Insumo telaUno = new Tela(EColor.Rosa, ETipoTela.Alfombra, 15);
Insumo adicionalUno = new InsumoAccesorio(ETipoAccesorio.Barniz, 10);
Insumo adicionalDos = new InsumoAccesorio(ETipoAccesorio.Tornillo, 24);
Insumo adicionalTres = new InsumoAccesorio(ETipoAccesorio.Pegamento, 10);
Insumo adicionalCuatro = new InsumoAccesorio(ETipoAccesorio.Yute, 10);
insumosAgregar += maderaUno;
insumosAgregar += maderaUno;
insumosAgregar += maderaSecundaria;
insumosAgregar += telaUno;
insumosAgregar += adicionalUno;
insumosAgregar += adicionalDos;
insumosAgregar += adicionalTres;
insumosAgregar += adicionalCuatro;
insumosAgregar += maderaUno;
fabrica.AgregarInsumosAStock(insumosAgregar);
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("-------Insumos agregados con éxito-------------------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("--Se itera de nuevo el stock de insumos----------------------------");
foreach (Insumo i in fabrica.StockInsumos)
{
Console.WriteLine(i.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.ReadKey();
Console.Clear();
//2- Usuario da de alta un producto para agregar a la linea de producción
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.WriteLine("--------Se van a cargar dos nuevos productos---------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
Producto productoTorre = new Torre(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Bordo, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.Queen, new Madera(ETipoMadera.Pino, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA), 3);
Producto productoEstante = new Estante(new Madera(ETipoMadera.Pino, EForma.Tablon, Fabrica.CANTIDAD_MADERA_ESTANTE), new Tela(EColor.Rosa, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_ESTANTE), 5);
List <Insumo> faltantes = new List <Insumo>();
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("-----Productos cargados, se procedera a iterar-------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
fabrica.AgregarProductoLineaProduccion(productoTorre, out faltantes);
fabrica.AgregarProductoLineaProduccion(productoEstante, out faltantes);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("---Se van a ejecutar los procesos de la fábrica en orden---------------");
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.WriteLine("----------------Lijar Maderas------------------------------------------");
//3- Ejecutar procesos de linea de Producción
fabrica.EjecutarProcesoLineaProduccion(EProceso.Lijar);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
Console.WriteLine("\n----------------Barnizar---------------------------------------------");
fabrica.EjecutarProcesoLineaProduccion(EProceso.Barnizar);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
Console.WriteLine("\n----------------Alfombrar--------------------------------------------");
fabrica.EjecutarProcesoLineaProduccion(EProceso.Alfombrar);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
Console.WriteLine("\n----------------Agregar Yute-----------------------------------------");
fabrica.EjecutarProcesoLineaProduccion(EProceso.AgregarYute);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
Console.WriteLine("\n----------------Ensamblar--------------------------------------------");
fabrica.EjecutarProcesoLineaProduccion(EProceso.Ensamblar);
foreach (Producto p in fabrica.LineaProduccion)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
// 4 - Mudar productos terminados de la linea de producción al stock de productos terminados
Console.WriteLine("-------------------------------------------------------------------------");
Console.WriteLine("--Mudar productos terminados al stock de productos terminados-----------");
Console.WriteLine("-------------------------------------------------------------------------");
fabrica.MudarProductosAStockTerminado();
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("--------Iterar lista de productos terminados de la fabrica-------------");
Console.WriteLine("-----------------------------------------------------------------------");
foreach (Producto p in fabrica.StockProductosTerminados)
{
Console.WriteLine(p.Mostrar());
}
Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
Console.ReadKey();
Console.Clear();
// 5 - Guardar datos de fábrica en archivos XML
Console.WriteLine("\n-----------------------------------------------------------------------");
Console.WriteLine("----------------Persistir atributos de fábrica en archivos XML---------");
Console.WriteLine("-----------------------------------------------------------------------");
try
{
serviceXmlFabrica.Path = $"{AppDomain.CurrentDomain.BaseDirectory}Destino\\";
serviceXmlFabrica.SaveXmlFabrica(fabrica);
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("----------------Datos guardados correctamente -------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
}
catch (SaveFactoryException e)
{
Console.WriteLine("-----------------------------------------------------------------------");
Console.WriteLine("----------------Errores al guardar los datos --------------------------");
Console.WriteLine("-----------------------------------------------------------------------");
}
}
// Metodos Awake, Start, Update....
void Start()
{
GameObject torre = GameObject.FindGameObjectWithTag("Torre");
if (torre != null)
Torre = torre.GetComponent<Torre>();
}
//TODO: Hacer una pieza objeto con pos y cion... la tengo que poder mover a veces.
//Piezas
static void Main(string[] args)
{
//Creacion de tablero
//Creacion de piezas
Pieza TorreNegra1 = new Torre(1, TipoPieza.Torre, "negra", 1, 1);
//Pieza CaballoNegro1 = new Caballo(2, TipoPieza.Caballo, "negra", 1, 2);
Pieza AlfilNegro1 = new Alfil(3, TipoPieza.Alfil, "negra", 1, 3);
//Pieza ReinaNegra1 = new Pieza(4, TipoPieza.Reina, "negra", 1, 4);
//Pieza ReyNegro1 = new Pieza(5, TipoPieza.Rey, "negra", 1, 5);
Pieza TorreBlanca1 = new Torre(6, TipoPieza.Torre, "blanca", 8, 1);
//List<Posiciones> posiciones = new List<Posiciones>();
List <Pieza> piezas = new List <Pieza>();
piezas.Add(TorreNegra1);
//piezas.Add(CaballoNegro1);
piezas.Add(AlfilNegro1);
//piezas.Add(ReinaNegra1);
//piezas.Add(ReyNegro1);
piezas.Add(TorreBlanca1);
Tablero tablero = new Tablero(piezas);
Console.WriteLine("Tablero de Ajedrez");
Console.WriteLine("------------------");
tablero.DibujarTablero(tablero.Filas, tablero.Columnas, null, piezas);
while (true)
{
Console.WriteLine("---------------------------------");
Console.WriteLine("Eleji la pieza que quieras mover:");
Console.WriteLine("---------------------------------");
Tablero.ListadoPiezasMenu(piezas);
var selectPieza = Console.ReadLine();
var piezaMover = Tablero.GetPiezaById(int.Parse(selectPieza), piezas);
Console.WriteLine("---------------------------------");
Console.WriteLine("Eleji tus coordenadas A-H:");
Console.WriteLine("---------------------------------");
var coLetras = Console.ReadLine();
Console.WriteLine("---------------------------------");
Console.WriteLine("Eleji tus coordenadas 1-8:");
Console.WriteLine("---------------------------------");
var coNumeros = Console.ReadLine();
var nuevaPosicion = new Posicion(tablero.LetrasANumeros(coLetras), int.Parse(coNumeros), DateTime.Now);
if (piezaMover.Mover(nuevaPosicion.PosY, nuevaPosicion.PosX, piezas))
{
piezaMover.Movimientos.Add(nuevaPosicion);
Console.Clear();
}
else
{
Console.Clear();
//ConsoleColor newForeColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No es posible moverse aqui");
}
tablero.DibujarTablero(tablero.Filas, tablero.Columnas, piezaMover, piezas);
}
}
static void Main(string[] args)
{
ItensMagico Cajado = new ItensMagico();
Cajado.Preco = 900;
Cajado.magicoItem.DanoMagico = 50;
ItensMagico Vazio = new ItensMagico();
Vazio.Preco = 200;
Vazio.magicoItem.DanoMagico = 150;
Darius darius = new Darius(1);
Diana diana = new Diana(2);
Torre torre = new Torre(300, 100);
Console.WriteLine(darius.Vida);
try
{
torre.AtirarEmUmCampeao(darius);
torre.AtirarEmUmCampeao(darius);
// torre.AtirarEmUmCampeao(darius);
// torre.AtirarEmUmCampeao(darius);
}
catch (PersonagemVidaException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine(darius.Vida);
Console.WriteLine(diana.Vida);
ISkillQ skillQDiana = new ISkillQ();
ISkillW skillWDiana = new ISkillW();
skillQDiana.UparSkill();
skillQDiana.personagem = diana;
skillWDiana.personagem = diana;
ISkillQ skillQDarius = new ISkillQ();
ISkillW skillWDarius = new ISkillW();
skillQDarius.UparSkill();
skillQDarius.personagem = darius;
skillWDarius.personagem = darius;
ControleDano controleDano = new ControleDano();
controleDano.AdicionaDano(diana, Vazio);
//try
// {
controleDano.DanoSkill(diana, skillWDarius);
controleDano.DanoSkill(diana, skillQDarius);
controleDano.DanoSkill(diana, skillQDarius);
// }catch(PersonagemVidaException ex)
// {
//Console.WriteLine(ex.Message);
//}
//Console.WriteLine("Vida da Daina "+diana.Vida);
Console.WriteLine("Daiana------------");
Console.WriteLine("Vida da Diana :" + diana.Vida);
Console.WriteLine("Dano da diana é " + diana.magico.DanoMagico);
darius.AttackBasico(diana);
Console.WriteLine(diana.Vida);
controleDano.AdicionaDanoExtra(diana);
Console.WriteLine("Dano da diana é " + diana.magico.DanoMagico);
Console.WriteLine("Dinheiro da diana é" + diana.Dinheiro);
Console.WriteLine("Darius----------");
Console.WriteLine("Vida Do Darius " + darius.Vida);
Console.WriteLine("Dano do darius é " + darius.fisico.DanoFisico);
controleDano.AdicionaDanoExtra(darius);
controleDano.AdicionaDano(darius, Vazio);
Console.WriteLine("Dano do darius é " + darius.fisico.DanoFisico);
Console.WriteLine("Dano do darius é " + darius.magico.DanoMagico);
Console.ReadLine();
}
// Metodos Awake, Start, Update...
void Start()
{
_torre = GameObject.FindGameObjectWithTag("Torre").GetComponent<Torre>();
}
public void Activar(Torre torre)
{
disparada = true;
objetivo = torre.Enemigo;
}
public virtual Movimento Roque(Tabuleiro tabuleiro, Torre torre = null)
{
return(null);
}
protected bool PodeRoque(Torre torre, Rei rei, Tabuleiro tabuleiro, Movimento movrei, Movimento movtorre)
{
if (torre == null || rei == null || movrei == null || movtorre == null)
{
return(false);
}
// lembrando que as condições de roque são:
// rei não pode ter se movimentado nenhuma vez
// torre não pode ter se movimentado nenhuma vez
if (!torre.primeiraJogada || !rei.primeiraJogada)
{
// Debug.Log("NÃO É A PRIMEIRA JOGADA!");
return(false);
}
// nao pode haver peças entre o rei e a torre
int linha = rei.CasaAtual.PosY;
// Debug.Log("linha rei:");
// Debug.Log(linha);
int torrepos = torre.PosX;
int reipos = rei.PosX;
// Debug.Log("Coluna torre:");
// Debug.Log(torrepos);
// Debug.Log("Coluna rei:");
// Debug.Log(reipos);
int i, f;
if (torrepos < reipos)
{
// Debug.Log("a posição entre torre e rei caracteriza um roque maior(ou era para caracterizar)");
i = torrepos;
f = reipos;
}
else
{
// Debug.Log("a posição entre torre e rei caracteriza um roque menor(ou era para caracterizar)");
i = reipos;
f = torrepos;
}
for (int p = i + 1; p < f; p++)
{
if (tabuleiro.GetCasa(p, linha).EstaOcupada())
{
//Debug.Log(p);
// Debug.Log("TEM CASAS OCUPADAS NO CAMINHO!");
return(false);
}
}
// rei nao pode estar em xeque
if (rei.jDono.EmXeque(false))
{
// Debug.Log("Rei está em xeque!");
return(false);
}
// rei não pode passar nem terminar em uma casa que está sendo atacada por peça adversaria(rei entraria em xeque)
//dependendo de quem se mova primeiro (torre ou rei ) antes de chamar a função CausaAutoXeque() sempre teremos um rei em xeque
// mesmo se a torre o proteger(bloquear o ataque)
// então o movimento da torre será "simulado"
Peca movida;
movida = movtorre.origem.PopPeca();
// lembrando que se chegamos até aqui não há ninguem ocupando essa casa! (eu acho...), podemos colocar a peça sem receio
movtorre.destino.ColocarPeca(movida);
if (movrei.CausaAutoXeque())
{
// Debug.Log("rei esta indo para casa sob ataque!(entraria em xeque)");
// voltar para a torre para a poisção original
movtorre.destino.PopPeca();
movtorre.origem.ColocarPeca(movida);
return(false);
}
// voltar para a torre para a poisção original
movida = movtorre.destino.PopPeca();
movtorre.origem.ColocarPeca(movida);
return(true);
}
