/// <summary>
/// Metodo CheckWin che verifica i progressi dell'eroe e li aggiorna.
/// Nel caso abbia terminato i punti vita l'eroe viene eliminato
/// </summary>
public static void CheckWin(Hero hero)
{
var serviceProvider = DIConfig.Config();
HeroService heroService = serviceProvider.GetService <HeroService>();
//Controllo punteggi finali di partita
if (hero.PuntiAccumulati >= 200)
{
Console.WriteLine("Partita Conclusa! HAI VINTO!!!");
Console.ReadLine();
//utilizzo ReadLine nel codice per non chiudere brutalmente il programma
//senza poter visualizzare un messaggio idoneo
}
else if (hero.PuntiVita <= 0)
{
heroService.DeleteHero(hero);
Console.WriteLine("Partita Conclusa! HAI PERSO!!!Il tuo eroe è stato eliminato definitivamente");
Console.ReadLine();
//utilizzo ReadLine nel codice per non chiudere brutalmente il programma
//senza poter visualizzare un messaggio idoneo
}
//else
//{
// Console.WriteLine("Progressi aggiornati! Premi un tasto per continuare!");
// Console.ReadLine();
// //utilizzo ReadLine nel codice per non chiudere brutalmente il programma
// //senza poter visualizzare un messaggio idoneo
//}
}
/// <summary>
/// Metodo TurnoMostro - è il turno del mostro che attacca l'eroe
/// </summary>
/// <returns>
/// bool mWin - TRUE: se l'eroe ha vinto lo scontro e al prossimo turno tocca a lui
/// FALSE: se l'eroe è stato sconfitto e al prossimo turno tocca sempre al mostro attaccare
/// </returns>
public static bool TurnoMostro(ref Hero hero, Mostro mostro)
{
//turno Mostro
var serviceProvider = DIConfig.Config();
ArmaService armaService = serviceProvider.GetService <ArmaService>();
Arma armaMostro = armaService.GetArma(mostro.Arma);
//Scontro con risultato random
bool mWin = Helper.Play(); //il mostro ha attaccato l'eroe
if (mWin == false) //ha vinto il mostro
{
//il mostro arreca danni all'eroe
hero.PuntiVita -= armaMostro.PuntiDanno;
return(mWin); //FALSE il prossimo turno sarà sempre del mostro
}
else
{
//caso in cui ha vinto l'eroe
hero.attack(mostro); //mostro subisce danni
return(mWin); //TRUE tocca all'eroe nel prossimo turno
}
}
/// <summary>
/// Metodo TurnoEroe - è il turno dell'eroe e deve scegliere l'azione da eseguire nei confronti
/// del mostro per provare a superare il turno.
/// - Attaccare il mostro!
/// - Tentare la fuga!
/// </summary>
/// <returns>
/// bool heroWin - TRUE: se l'eroe ha vinto lo scontro e al prossimo turno tocca sempre a lui
/// FALSE: se l'eroe ha perso e al prossimo turno tocca al mostro attaccare
/// </returns>
public static bool TurnoEroe(ref Hero hero, Mostro mostro)
{
var serviceProvider = DIConfig.Config();
ArmaService armaService = serviceProvider.GetService <ArmaService>();
//turno Giocatore
Console.WriteLine("Tocca a te Eroe! Scegli la tua mossa!");
Console.WriteLine("1 - per Attaccare il mostro!");
Console.WriteLine("2 - per tentare la Fuga dal mostro!");
bool IsCorrectUserInput = Int32.TryParse(Console.ReadLine(), out int key);
Console.WriteLine();
bool heroWin = false;
if (IsCorrectUserInput)
{
switch (key)
{
case 1: //Giocatore Attacca il Mostro
Arma armaMostro = armaService.GetArma(mostro.Arma);
//Scontro con risultato random
heroWin = Helper.Play(); //l'eroe ha attaccato il mostro
if (heroWin == true) //eroe ha vinto
{
hero.attack(mostro); //arreca danni al mostro
//heroWin TRUE
}
else
{
//ha vinto il mostro
//hero subisce danni
hero.PuntiVita -= armaMostro.PuntiDanno;
//heroWin FALSE eroe ha perso
}
return(heroWin);
case 2: //Giocatore decide di tentare la fuga!!
heroWin = Helper.Play(); //eroe tenta la fuga
if (heroWin == true) //la fuga è andata a buon fine
{
hero.escape(mostro);
Console.WriteLine("La fuga è Riuscita, ma il tuo punteggio è " + hero.PuntiAccumulati);
return(heroWin); //TRUE nel prossimo turno tocca ancora all'eroe
}
else //Se la fuga non va a buon fine l'eroe deve riaffrontare lo stesso mostro
{
Console.WriteLine("La fuga è Fallita! Devi riaffrontare lo stesso mostro! Scegli la tua prossima mossa");
return(TurnoEroe(ref hero, mostro));
}
}
}
return(heroWin);
}
/// <summary>
/// Metodo Game che richiama il metodo Turno.Set
/// per giocare i vari turni che compongono la partita
/// dell'eroe scelto dal giocatore
/// </summary>
public static void Game(Hero hero, IEnumerable <Mostro> mostri, Giocatore giocatore)
{
var serviceProvider = DIConfig.Config();
HeroService heroService = serviceProvider.GetService <HeroService>();
Hero updatedHero = hero;
int pVitaTotali = 0;
int puntiTotali = 0;
string q;
bool turno = true; //a inizio partita è sempre il turno dell'eroe
bool result;
do
{
result = Turno.Set(ref hero, mostri, turno);
if (result == true)
{
puntiTotali = hero.PuntiAccumulati;
Console.WriteLine("Il tuo eroe ha sconfitto il mostro e ha accumulato " + hero.PuntiAccumulati + " punti!");
//tocca ancora all'eroe
turno = true;
}
else
{
pVitaTotali = hero.PuntiVita;
Console.WriteLine("Il tuo eroe ha perso! Gli sono rimasti ancora " + hero.PuntiVita + " punti vita!");
//allora è il turno del mostro
turno = false;
}
updatedHero = new Hero(hero.Nome, hero.Classe, hero.Arma, pVitaTotali, hero.Livello, puntiTotali, giocatore);
Console.WriteLine("Continuare la partita? (SI o NO)");
q = Console.ReadLine().ToString();
} while (q != "NO");
//il giocatore ha deciso di terminare la partita e salvare i progressi
//quindi si procede all'aggiornamento dei progressi nel database
//e al controllo generale del punteggio
//Controllo punteggio
Helper.CheckWin(updatedHero);
Console.WriteLine("Salvare i progressi? (SI o NO)");
string s = Console.ReadLine().ToString();
if (s == "SI")
{
//Salvataggio progressi
heroService.UpdateHero(updatedHero);
}
}
/// <summary>
/// Metodo CheckGiocatore
/// che verifica se si tratti di un giocatore esistente nel database o di un nuovo giocatore.
/// Nel caso di nuovo giocatore lo si aggiunge nel database.
/// </summary>
public static void CheckGiocatore(Giocatore giocatore)
{
var serviceProvider = DIConfig.Config();
GiocatoreService giocatoreService = serviceProvider.GetService <GiocatoreService>();
//cerco il giocatore nel database
var g = giocatoreService.GetGiocatore(giocatore.Nome);
if (g != null && g.Nome == giocatore.Nome)
{
//giocatore esistente
Console.WriteLine("Bentornato!! Start Game!");
}
else
{
//si tratta di un nuovo utente
giocatoreService.CreateGiocatore(giocatore);
Console.WriteLine("Benvenuto!! Start Game!");
}
}
/// <summary>
/// Metodo Start che mostra il menù principale
/// e fa partire il gioco
/// </summary>
public static void Start(Giocatore giocatore)
{
#region Dependency Injection
var serviceProvider = DIConfig.Config();
HeroService heroService = serviceProvider.GetService <HeroService>();
ClasseService classeService = serviceProvider.GetService <ClasseService>();
ArmaService armaService = serviceProvider.GetService <ArmaService>();
//LevelService levelService = serviceProvider.GetService<LevelService>();
MostroService mostroService = serviceProvider.GetService <MostroService>();
var mostri = mostroService.GetAllMostri();
#endregion
//Chiamo il menù delle opzioniprima di iniziare l'eventuale partita
Helper.Menu();
//Catturo la scelta dell'utente da console
bool IsCorrectUserInput = Int32.TryParse(Console.ReadLine(), out int key);
Console.WriteLine();
//Se l'input è idoneo, per ogni opzione scelta
//vengono eseguite le istruzioni corrispondenti
if (IsCorrectUserInput)
{
switch (key)
{
#region CASO 1 NUOVO EROE
case 1: //Giocatore può creare un nuovo eroe con il quale giocare
#region CREAZIONE EROE
//Richiesta Parametri in input da console
Console.WriteLine("Inserisci il nome del tuo Eroe: ");
string Nome = Console.ReadLine();
Console.WriteLine("CLASSI: ");
var classi = classeService.GetAllClassi();
foreach (var cl in classi)
{
if (cl.Hero == true)
{
Console.WriteLine($"{cl.Nome}");
}
}
Console.WriteLine("Scegli la classe del tuo Eroe: ");
string Classe = Console.ReadLine();
Console.WriteLine("ARMI: ");
var armi = armaService.GetAllArmi();
foreach (var arma in armi)
{
if (arma.Classe == Classe)
{
Console.WriteLine($"{arma.Nome}");
}
}
Console.WriteLine("Scegli l'arma del tuo Eroe: ");
string Arma = Console.ReadLine();
Hero hero = new Hero(Nome, Classe, Arma, giocatore);
heroService.CreateHero(hero);
//è stato creato un nuovo oggetto eroe, sia nel programma
//nel database e può iniziare a giocare
Console.WriteLine("Premi il tasto invio per iniziare a giocare!");
Console.ReadLine();
#endregion
//GAME
//Chiamo il metodo che gioca la battaglia eroe selezionato contro mostri
//formata eventualmente da diversi scontri
Turno.Game(hero, mostri, giocatore);
break;
#endregion
#region CASO 2 ELIMINA EROE
case 2: //Giocatore sceglie di eliminare un suo eroe
Console.WriteLine("I Tuoi Eroi: ");
var heros = heroService.GetAllHeros();
//Seleziono solo gli eroi del giocatore corrente
foreach (var h in heros)
{
if (h.Giocatore.Nome == giocatore.Nome)
{
Console.WriteLine($"{h.Nome}");
}
}
Console.WriteLine("Seleziona l'Eroe da eliminare: ");
string heroDel = Console.ReadLine();
Hero heroToDelete = heroService.GetHero(heroDel);
bool deleted = heroService.DeleteHero(heroToDelete);
if (deleted == true)
{
Console.WriteLine("L'operazione di cancellazione è avvenuta correttamente");
}
else
{
Console.WriteLine("L'operazione di cancellazione NON è avvenuta correttamente");
}
Console.ReadLine();
break;
#endregion
#region CASO 3 CONTINUA PARTITA EROE
case 3: //il giocatore sceglie di continuare la partita con un suo eroe già esistente
Console.WriteLine("Ecco i Tuoi Eroi: ");
var eroi = heroService.GetAllHeros();
//Seleziono solo gli eroi associati al giocatore corrente
foreach (var h in eroi)
{
if (h.Giocatore.Nome == giocatore.Nome)
{
Console.WriteLine($"{h.Nome}");
}
}
Console.WriteLine("Seleziona l'Eroe col quale giocare la partita: ");
string nomeHero = Console.ReadLine();
hero = heroService.GetHero(nomeHero);
//GAME
//Chiamo il metodo che gioca la battaglia eroe selezionato contro mostri
//formata eventualmente da diversi scontri
Turno.Game(hero, mostri, giocatore);
break;
#endregion
case 'q': //Il giocatore sceglie di uscire dal gioco
Console.WriteLine("Arrivederci!!!");
Console.ReadLine();
break;
default: //caso in cui il giocatore ha inserito un input errato
Console.WriteLine("Riprovare.");
Console.ReadLine();
break;
}
}
Console.Clear();
}
