private static async void EseguiPartita()
{
using (DataBase db = new DataBase()) {
await db.Database.EnsureCreatedAsync();
Tavolo tavolo = new Tavolo();
Orologio orologio = new Orologio();
tavolo.Orologio = orologio;
Mossa mossa1 = new Mossa();
mossa1.Valore = "A2 A3";
mossa1.Tavolo = tavolo;
Mossa mossa2 = new Mossa();
mossa2.Valore = "A1 H1";
mossa2.Tavolo = tavolo;
db.Add(mossa1);
db.Add(mossa2);
await db.SaveChangesAsync();
Console.WriteLine("Dati inseriti");
}
}
private static void GiocaPartita() {
IScacchiera scacchiera = new Scacchiera();
IOrologio orologio = new Orologio();
IBloccoNote bloccoNote = new BloccoNote();
ITavolo tavolo = new Tavolo(scacchiera, orologio, bloccoNote);
bool partitaInCorso = true;
tavolo.Vittoria += (sender, colore) => {
Console.Clear();
Console.WriteLine($"Vince {tavolo.Giocatori[colore].Nome} ({colore})!");
partitaInCorso = false;
tavolo.FinisciPartita();
};
Console.Write("Giocatore bianco: ");
string giocatoreBianco = Console.ReadLine();
Console.Write("Giocatore nero: ");
string giocatoreNero = Console.ReadLine();
tavolo.RiceviGiocatori(giocatoreBianco, giocatoreNero);
tavolo.AvviaPartita();
bool errore = false;
bool automatico = false;
while (partitaInCorso) {
Console.Clear();
Colore coloreDiTurno = orologio.TurnoAttuale;
Console.WriteLine($"{tavolo.Giocatori[Colore.Bianco].Nome} ({Colore.Bianco}) VS {tavolo.Giocatori[Colore.Nero].Nome} ({Colore.Nero})");
Console.WriteLine();
Disegna(scacchiera);
Console.WriteLine();
if (errore)
Console.ForegroundColor = ConsoleColor.Red;
Console.Write($"Muove {tavolo.Giocatori[coloreDiTurno].Nome} ({coloreDiTurno}): ");
Console.ForegroundColor = ConsoleColor.White;
string mossa;
if (automatico){
mossa = DeterminaMossa(scacchiera, orologio.TurnoAttuale);
Console.Write(mossa);
Thread.Sleep(200);
} else {
mossa = Console.ReadLine();
}
if (mossa.Equals("auto", StringComparison.OrdinalIgnoreCase)) {
automatico = true;
mossa = DeterminaMossa(scacchiera, orologio.TurnoAttuale);
Console.Write(mossa);
Thread.Sleep(200);
}
try{
errore = false;
tavolo.InserisciMossa(mossa);
} catch (Exception) {
errore = true;
automatico = false;
}
}
Console.ReadLine();
}
static void Main(string[] args)
{
IOrologio orologio = new Orologio();
orologio.Accendi();
Console.WriteLine("Avvio il timer e mi metto in attesa per 2 secondi...");
orologio.Avvia();
Thread.Sleep(2000); //Il tempo di attesa va indicato in millisecondi
Console.WriteLine($"Il tempo residuo e' di: {orologio.TempoResiduoGiocatore1}");
Console.ReadKey();
}
public void AccendendoloITempiResiduiDevonoEssereDi5Minuti()
{
//Given
IOrologio orologio1 = new Orologio();
//When
orologio1.Accendi();
//Then
Assert.Equal(orologio1.TempoIniziale, orologio1.TempoResiduoBianco);
Assert.Equal(orologio1.TempoIniziale, orologio1.TempoResiduoNero);
}
public void QuandoAvvioSenzaAccendereDeveVerificarsiUnEccezione()
{
//Given
IOrologio orologio1 = new Orologio();
//When
//Then
Assert.Throws(typeof(InvalidOperationException), () => {
orologio1.Avvia();
});
}
static void Main(string[] args)
{
//SimpleXUnitRunner.SimpleXUnit.RunTests();
IOrologio orologio = new Orologio(TimeSpan.FromSeconds(5));
//orologio.TempoScaduto += notificaSconfitta;
orologio.Accendi();
orologio.Avvia();
Console.ReadKey();
}
static void Main(string[] args)
{
// SimpleXUnitRunner.SimpleXUnit.RunTests();
IOrologio orologio = new Orologio();
orologio.Accendi();
orologio.Avvia();
orologio.TempoScaduto += NotificaSconfitta;
Console.ReadKey();
//La sottoscrizione all'evento TempoScaduto è stata spostata
//in un test in OrologioTest.cs (vedi in fondo al file, riga 180)
}
public void QuandoSiAvviaAlloraIlTempoDeveAvanzarePerBianco()
{
//Given
IOrologio orologio1 = new Orologio();
orologio1.Accendi();
//When
orologio1.Avvia();
Thread.Sleep(attesa);
//Then
Assert.InRange(orologio1.TempoResiduoBianco,
orologio1.TempoIniziale - attesa - tolleranza,
orologio1.TempoIniziale - attesa);
}
static void Main(string[] args)
{
//SimpleXUnitRunner.SimpleXUnit.RunTests();
IOrologio orologio = new Orologio(TimeSpan.FromSeconds(5));
//L'evento va sottoscritto subito dopo aver creato l'oggetto
orologio.TempoScaduto += (sender, colore) => {
Console.WriteLine($"Il giocatore {colore} ha perso la partita, secondo l'orologio {sender}!");
};
orologio.Accendi();
orologio.Avvia();
Console.ReadKey();
}
public void AllAvvioDellaPartitaDeveEsserePredispostaUnaScacchieraELOrologioAvviato()
{
//Given
IScacchiera scacchiera = new Scacchiera();
IOrologio orologio = new Orologio();
ITavolo tavolo = new Tavolo(scacchiera, orologio);
//When
tavolo.RiceviGiocatori("", "");
tavolo.AvviaPartita();
//Then
Assert.NotEqual(null, tavolo.Scacchiera);
Assert.NotEqual(null, tavolo.Orologio);
Assert.False(orologio.InPausa);
}
public void QuandoInPausaIlTempoNonDeveAvanzare()
{
//Given
IOrologio orologio1 = new Orologio();
orologio1.Accendi();
orologio1.Avvia();
Thread.Sleep(attesa);
//When
orologio1.Pausa();
TimeSpan primaLettura = orologio1.TempoResiduoBianco;
Thread.Sleep(attesa);
//Then
Assert.Equal(primaLettura, orologio1.TempoResiduoBianco);
}
public void QuandoIlTempoDiUnGiocatoreScendeAZeroDeveEssereSollevatoTempoScaduto()
{
//Given
IOrologio orologio1 = new Orologio(TimeSpan.FromMilliseconds(50));
orologio1.Accendi();
orologio1.Avvia();
bool invocato = false;
orologio1.TempoScaduto += (sender, arg1) => {
invocato = true;
};
//When
Thread.Sleep(200);
//Then
Assert.True(invocato);
}
public void QuandoBiancoPassaIlTurnoIlTempoAvanzaPerNero()
{
//Given
IOrologio orologio1 = new Orologio();
orologio1.Accendi();
orologio1.Avvia();
//When
orologio1.FineTurno();
Thread.Sleep(attesa);
//Then
Assert.InRange(orologio1.TempoResiduoBianco,
orologio1.TempoIniziale - tolleranza,
orologio1.TempoIniziale);
Assert.InRange(orologio1.TempoResiduoNero,
orologio1.TempoIniziale - attesa - tolleranza,
orologio1.TempoIniziale - attesa);
}
public void SulResetSiRicominciaDalTempoIniziale()
{
//Given
IOrologio orologio1 = new Orologio();
orologio1.Accendi();
orologio1.Avvia();
Thread.Sleep(attesa);
orologio1.FineTurno();
Thread.Sleep(attesa);
orologio1.FineTurno();
Thread.Sleep(attesa);
//When
orologio1.Reset();
Thread.Sleep(1);
//Then
Assert.Equal(orologio1.TempoResiduoBianco, orologio1.TempoIniziale);
Assert.Equal(orologio1.TempoResiduoNero, orologio1.TempoIniziale);
}
public void pezzoSiSpostaSeMossaValida(string coord1, string coord2)
{
//Given
Scacchiera scacchiera = new Scacchiera();
Orologio orologio = new Orologio();
BloccoNote bloccoNote = new BloccoNote();
Tavolo tavolo = new Tavolo(scacchiera, orologio, bloccoNote);
//When
tavolo.RiceviGiocatori("Fhurer", "Mahatma");
tavolo.AvviaPartita();
var coordPartenza = tavolo.InterpretaCoordinataCasa(coord1);
var coordFine = tavolo.InterpretaCoordinataCasa(coord2);
var pezzoInQuestione = tavolo.Scacchiera[coordPartenza.Colonna, coordPartenza.Traversa].PezzoPresente;
tavolo.InserisciMossa(coord1 + " " + coord2);
Assert.Equal(tavolo.Scacchiera[coordPartenza.Colonna, coordPartenza.Traversa].PezzoPresente, null);
Assert.Equal(tavolo.Scacchiera[coordFine.Colonna, coordFine.Traversa].PezzoPresente, pezzoInQuestione);
}
internal void SyncroOrarioColServer()
{
DateTime orarioMio = DateTime.Now;
DateTime orarioDelServer = fpClient.GetOrario();
if (Math.Abs((orarioDelServer - orarioMio).TotalSeconds) > 5)
{
try {
Orologio.Set(orarioDelServer);
_giornale.Info(String.Format("Orologio del mio sistema = {0} ; Orologio del server {1}. Effettuata sincronizzazione", orarioMio, orarioDelServer));
} catch (Exception ee) {
_giornale.Error("Syncro orologio server", ee);
}
}
else
{
_giornale.Info("Orologio di sistema già sincronizzato con quello del sever. Non faccio nulla");
}
}
public void MossaInvalidaLanciaEccezione(string mossaInvalida)
{
//Given
Scacchiera scacchiera = new Scacchiera();
Orologio orologio = new Orologio();
BloccoNote bloccoNote = new BloccoNote();
Tavolo tavolo = new Tavolo(scacchiera, orologio, bloccoNote);
//When
tavolo.RiceviGiocatori("Robespierre", "Rob Van Dam");
tavolo.AvviaPartita();
//Simulazione di alcune mosse valide di pedoni
tavolo.InserisciMossa("A2 A4");
tavolo.InserisciMossa("A7 A5");
tavolo.InserisciMossa("B2 B4");
tavolo.InserisciMossa("A5 B4");
//Cosa succede per le mosse invalide
Assert.Throws(typeof(InvalidOperationException), () => {
tavolo.InserisciMossa(mossaInvalida);
});
}
public void QuandoIlTempoRiprendeSoloBiancoAvanza()
{
//Given
IOrologio orologio1 = new Orologio();
orologio1.Accendi();
orologio1.Avvia();
orologio1.Pausa();
TimeSpan primaLetturaBianco = orologio1.TempoResiduoBianco;
TimeSpan primaLetturaNero = orologio1.TempoResiduoNero;
//When
orologio1.Avvia();
Thread.Sleep(attesa);
//Then
Assert.InRange(orologio1.TempoResiduoBianco,
primaLetturaBianco - attesa - tolleranza,
primaLetturaBianco - attesa);
//Assert.Equal(primaLetturaNero, orologio1.TempoResiduoNero);
Assert.True(primaLetturaNero == orologio1.TempoResiduoNero);
}
public void TempoScadutoDeveNotificareTuttiISuoiSottoscrittori()
{
//Given
IOrologio orologio = new Orologio(TimeSpan.FromMilliseconds(50));
orologio.Accendi();
orologio.Avvia();
orologio.TempoScaduto += NotificaSconfitta;
//Oltre che sottoscrivere un evento con un metodo, posso anche indicare una lambda expression
orologio.TempoScaduto += (sender, colore) => {
sottoscrittoriInvocati++;
};
//When
Thread.Sleep(TimeSpan.FromMilliseconds(200));
//Then
//Mi aspetto che vengano invocati entrambi i metodi che ho sottoscritto all'evento
//1. Il metodo NotificaSconfitta definito in questa classe
//2. La lambda expression (che è un metodo anonimo)
Assert.Equal(2, sottoscrittoriInvocati);
}
static void Main(string[] args)
{
//SimpleXUnitRunner.SimpleXUnit.RunTests();
IOrologio orologio = new Orologio(TimeSpan.FromSeconds(5));
orologio.Accendi();
orologio.Avvia();
orologio.TempoScaduto += NotificaSconfitta;
//Oltre che sottoscrivere un evento con un metodo, posso anche indicare una lambda expression
EventHandler <Colore> notificaSconfitta = (sender, colore) => {
Console.WriteLine($"(Dalla lambda expression): Il giocatore {colore} ha perso la partita, secondo l'orologio {sender}!");
};
orologio.TempoScaduto += notificaSconfitta;
Console.ReadKey();
}
