public static Mostro SceltaMostro(Eroe eroe, List <Mostro> listaMostri)
{
//in base al livello dell'eroe che gioca viene scelto il livello del mostro
int count = 0;
int livello = eroe.LivelloID;
List <Mostro> lista = new List <Mostro>();
//mi salvo su una lista i mostri con il livello < o = a quello del eroe
foreach (var item in listaMostri)
{
if (item.LivelloID <= livello)
{
lista.Add(item);
count++;
}
}
//con un valore random viene scelto il mostro
Random random = new Random();
int a = random.Next(1, count);
Mostro mostro = mostroService.GetMostroByID(a);
mostro.Arma = armaService.GetArmaByID(mostro.ArmaID);
mostro.Classe = classeService.GetClasseByID(mostro.ClasseID);
mostro.Livello = livelloService.GetLivello(mostro.LivelloID);
return(mostro);
}
public void Create(Mostro obj)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
try
{
//Aprire la connessione
connection.Open();
//Creo il comando
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "INSERT INTO Mostri (NomeMostro, Classe, Arma, Livello) VALUES (@nome, @classe, @arma, @livello)";
//Valori
command.Parameters.AddWithValue("@nome", obj.Nome);
command.Parameters.AddWithValue("@classe", obj.Classe);
command.Parameters.AddWithValue("@arma", obj.ArmaScelta.NomeArma);
command.Parameters.AddWithValue("@livello", obj.LivelloMostro.Numero);
command.ExecuteNonQuery();
}
catch (SqlException)
{
Console.WriteLine("Siamo spiacenti, è stato rilevato un errore");
}
finally
{
connection.Close();
}
}
}
public void Create(Mostro mostro)
{
using (SqlConnection connection = new SqlConnection(connectionstring))
{
//Aprire la connessione
connection.Open();
//Comando
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "INSERT INTO Mostro VALUES (@Nome, @ClasseID, @LivelloID, @ArmaID)";
//Aggiunta parametri
command.Parameters.AddWithValue("@Nome", mostro.Nome);
command.Parameters.AddWithValue("@ClasseID", mostro.ClasseID);
command.Parameters.AddWithValue("@LivelloID", mostro.LivelloID);
command.Parameters.AddWithValue("@ArmaID", mostro.ArmaID);
//Esecuzione comando
command.ExecuteNonQuery();
//Chiusura
connection.Close();
}
}
/// <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);
}
public bool Delete(Mostro mostro)
{
using (SqlConnection connection = new SqlConnection(connectionstring))
{
string nome = mostro.Nome;
//Aprire la connessione
connection.Open();
//Comando
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "DELETE FROM Mostro WHERE Nome = @nome";
//Aggiunta parametri
command.Parameters.AddWithValue("@Nome", mostro.Nome);
try
{
//Esecuzione comando
command.ExecuteNonQuery();
}catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
//Chiusura
connection.Close();
}
}
return(true);
}
public static bool TurnoEroe(Eroe eroe, Mostro mostro)
{
//ritorna true se la battaglia è finita, ritorna false se è il turno del mostro
Console.WriteLine("Scegli:");
Console.WriteLine("1 - Attaccare il Mostro");
Console.WriteLine("Premi un tasto per Tentare la fuga");
char a = Console.ReadKey().KeyChar;
Console.WriteLine();
switch (a)
{
case '1':
bool z = eroe.AttaccareMostro(eroe, mostro);
if (z == true)
{
Console.WriteLine("Il Mostro è morto");
//hai vinto la battaglia
eroe.PuntiAccumulati += (mostro.Livello.Num * 10);
//Controllo sul livello
eroe.LivelloID = eroe.Livello.DefinizioneLivello(eroe.PuntiAccumulati);
eroeservice.Update(eroe);
if (eroe.PuntiAccumulati >= 200)
{
//l'eroe ha vinto inserire un flag
eroe.Vittoria = true;
Console.WriteLine("Vittoria!!!!!!");
return(true);
}
return(true);
}
else
{
//la battaglia continua
return(false);
}
default:
bool x = eroe.TentareFuga();
if (x == true)
{
Console.WriteLine("Tentativo riuscito sei scappato!");
eroe.PuntiAccumulati -= (mostro.Livello.Num * 5);
//battaglia finita
return(true);
}
else
{
Console.WriteLine("Tentativo fallito! Turno del Mostro");
return(false);
}
}
}
public Mostro CreateMostro(Mostro m)
{
if (m != null)
{
_repo.Create(m);
return(m);
}
else
{
return(null);
}
}
public Mostro GetById(int ID)
{
Mostro mostro = new Mostro();
foreach (var item in mostri)
{
if (item.ID == ID)
{
mostro = item;
}
}
return(mostro);
}
/// <summary>
/// Metodo Set che in base a chi tocca tra mostro e eroe
/// chiama le operazioni corrispettive per eseguire lo scontro
/// e stabilire la vittoria o meno dell'eroe.
/// </summary>
/// <returns>
/// bool 'turno' - TRUE: al prossimo turno tocca all'eroe
/// FALSE: al prossimo turno tocca al mostro attaccare
/// </returns>
public static bool Set(ref Hero hero, IEnumerable <Mostro> mostri, bool turno)
{
Mostro mostro = Helper.SelectMostro(hero, mostri);
if (turno == true)
{
return(TurnoEroe(ref hero, mostro)); //turno del giocatore
}
else
{
return(TurnoMostro(ref hero, mostro)); //altrimenti turno del mostro
}
}
/// <summary>
/// Metodo SelectMostro che seleziona il mostro
/// avversario dell'eroe in base al livello
/// </summary>
/// <returns>
/// Mostro selectedMostro - mostro con il livelle minore
/// o uguale al livello dell'eroe
/// </returns>
public static Mostro SelectMostro(Hero hero, IEnumerable <Mostro> mostri)
{
Mostro selectedMostro = null;
foreach (var m in mostri)
{
if (m.Livello <= hero.Livello)
{
selectedMostro = m;
}
}
return(selectedMostro);
}
public static int Battaglia(Eroe eroe, Mostro mostro)
{
//faccio partite il conteggio del tempo di gioco dell'eroe
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
int x = 0;
do
{
bool y = Partita.TurnoEroe(eroe, mostro);
//ritorna true se la battaglia è finita, ritorna false se è il turno del mostro
if (y == true)
{
Console.WriteLine("Vuoi salvare i tuoi progressi? Premi 1, altrimenti esci dal gioco");
char ex = Console.ReadKey().KeyChar;
Console.WriteLine();
//stoppo il tempo e lo inserisco nel tempo di gioco dell'eroe
stopWatch.Stop();
eroe.TempoDiGioco += stopWatch.Elapsed;
switch (ex)
{
case '1':
eroeservice.Update(eroe);
x = 1;
break;
default: x = 1;
break;
}
}
else
{
bool z = Partita.TurnoMostro(eroe, mostro);
if (z == true)
{
//la battaglia è terminata e l'eroe è morto
x = 1;
}
else
{
//è il turno dell'eroe
x = 0;
}
}
} while (x == 0);
return(0);
}
public static Eroe Battaglia(Eroe eroe, Mostro mostro)
{
Console.BackgroundColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine($"\nUn {mostro.Classe} ti blocca la strada!");
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\nInizio battaglia!");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"{eroe.Nome}, {eroe.Classe}, Livello: {eroe.Livello} \tVS \t{mostro.Nome}, {mostro.Classe}, Livello: {mostro.LivelloMostro.Numero}");
Console.ResetColor();
bool fuga;
do
{
Console.WriteLine($"\n{eroe.Nome} PV: {eroe.PuntiVita} \t\tVS\t\t {mostro.Nome} PV: {mostro.LivelloMostro.PuntiVita}");
fuga = SceltaTurno(eroe, mostro);
//Se non riesce la fuga/eroe attacca e se il mostro è sopravvissuto all'attacco dell'eroe
if (fuga == false && mostro.LivelloMostro.PuntiVita > 0)
{
//Attacca il mostro
int attaccoMostro = mostro.Attacca();
eroe.PuntiVita -= attaccoMostro;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"{mostro.Nome} attacca con {mostro.ArmaScelta.NomeArma}! Danno: {mostro.ArmaScelta.PuntiDanno}");
Console.ResetColor();
}
}//Si ripete finchè l'eroe e il mostro sono vivi e l'eroe non riesce nella fuga
while ((fuga == false) && (eroe.PuntiVita > 0 && mostro.LivelloMostro.PuntiVita > 0));
//Se l'eroe è stato sconfitto
if (eroe.PuntiVita <= 0)
{
Console.WriteLine("Il tuo eroe è stato scofitto da " + mostro.Nome);
}
//Se il mostro è stato sconfitto
else if (mostro.LivelloMostro.PuntiVita <= 0)
{
Console.WriteLine("Complimenti! Hai sconfitto " + mostro.Nome);
//L'eroe vince punti
int puntiVinti = mostro.LivelloMostro.Numero * 10;
Console.WriteLine("Hai guadagnato {0} punti", puntiVinti);
eroe.PuntiAccumulati += puntiVinti;
Console.WriteLine("Ora hai {0} punti accumulati", eroe.PuntiAccumulati);
}
return(eroe);
}
public static bool TurnoMostro(Eroe eroe, Mostro mostro)
{
//ritorna true se la battaglia è finita e false se è il turno del eroe
bool y = mostro.Attacco(eroe, mostro);
if (y == true)
{
//non sei morto continua la battaglia
return(false);
}
//se y==false sei morto
eroeservice.DeleteEroe(eroe);
return(true);
}
public Mostro GetByName(string name)
{
Mostro mostro = new Mostro();
using (SqlConnection connection = new SqlConnection(connectionstring))
{
//Aprire la connessione
connection.Open();
//Comando
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "SELECT * FROM Mostro WHERE Nome = @name";
//Creare il parametro
SqlParameter param = new SqlParameter();
param.ParameterName = "@name";
param.Value = name;
command.Parameters.Add(param);
//Esecuzione comando
SqlDataReader reader = command.ExecuteReader();
//Lettura dati
while (reader.Read())
{
mostro = reader.ToMostro();
}
//Chiusura
reader.Close();
connection.Close();
}
return(mostro);
}
/// <summary>
/// Implementazione del metodo <c>Create</c> per creare un nuovo mostro nel database dato un oggetto di tipo Mostro
/// </summary>
/// <param name="obj">oggetto di tipo Mostro</param>
/// <returns>Restituisce un booleano: true se è andata a buon fine la creazione, false se viene generata un'eccezione</returns>
public bool Create(Mostro obj)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
try
{
//Aprire connessione
connection.Open();
//Creare comando
SqlCommand insertCommand = new SqlCommand();
insertCommand.Connection = connection;
insertCommand.CommandType = System.Data.CommandType.Text;
insertCommand.CommandText = "INSERT INTO Mostro VALUES(@Nome, @IDClasse, @IDArma, @IDLivello)";
//Creare param
insertCommand.Parameters.AddWithValue("@Nome", obj.Nome);
insertCommand.Parameters.AddWithValue("@IDClasse", obj.Classe.ID);
insertCommand.Parameters.AddWithValue("@IDArma", obj.Arma.ID);
insertCommand.Parameters.AddWithValue("@IDLivello", obj.Livello.ID);
//Esecuzione dei comandi
insertCommand.ExecuteNonQuery();
connection.Close();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
connection.Close();
return(false);
}
}
}
public void Create(Mostro obj)
{
throw new NotImplementedException();
}
public bool Update(Mostro obj)
{
throw new NotImplementedException();
}
static void Main(string[] args)
{
var serviceProvider = Configurazone.Configurazione();
EroeService eroeservice = serviceProvider.GetService <EroeService>();
GiocatoreService giocatoreService = serviceProvider.GetService <GiocatoreService>();
MostroService mostroService = serviceProvider.GetService <MostroService>();
ArmaService armaService = serviceProvider.GetService <ArmaService>();
ClasseService classeService = serviceProvider.GetService <ClasseService>();
LivelloService livelloService = serviceProvider.GetService <LivelloService>();
List <Giocatore> listaG = giocatoreService.GetAllGiocatori().ToList();
//inizio del gioco
Console.WriteLine("Benvenuto in eroi contro mostri");
Giocatore giocatore = new Giocatore();
Console.WriteLine("Inserisci il tuo nome:");
string n = Console.ReadLine();
giocatore.Nome = n;
Console.WriteLine();
//Controllo sul giocatore
Partita.ControlloGiocatore(giocatore, listaG);
giocatore = giocatoreService.GetGiocatore(n);
int x = 0;
do
{
//ogni volta che torno al menù vengono caricate le liste aggiornate
List <Livello> listaLivelli = livelloService.GetAllLivelli().ToList();
List <Classe> listaClassi = classeService.GetAllClassi().ToList();
List <Arma> listaArmi = armaService.GetAllArmi().ToList();
List <Giocatore> listaGiocatori = giocatoreService.GetAllGiocatori().ToList();
List <Eroe> listaeroi = eroeservice.GetAllEroi().ToList();
List <Mostro> listaMostri = mostroService.GetAllMostri().ToList();
Console.WriteLine("Se vuoi iniziare una partita premi 1");
Console.WriteLine("Se vuoi creare un eroe premi 2");
Console.WriteLine("Se vuoi eliminare un eroe premi 3");
Console.WriteLine("Se vuoi vedere le statistiche premi 4");
//inserisco questa scelta solo se il giocatore ha la caratteristica richiesta
if (giocatore.Ruolo == "Admin")
{
Console.WriteLine("Dato che sei Admin, se vuoi inserire un mostro premi 5");
}
Console.WriteLine("Se vuoi uscire dal gioco premi un tasto");
char a = Console.ReadKey().KeyChar;
Console.WriteLine();
switch (a)
{
case '1':
//Scelgo l'eroe per la partita
Eroe eroe = Partita.SceltaEroe(listaeroi, giocatore, listaClassi, listaArmi);
//controllo di non aver inserito male i dati
if (eroe == null)
{
giocatore.ListaEroi.Clear(); break;
}
//aggiorno i restanti campi
eroe.Classe = classeService.GetClasseByID(eroe.ClasseID);
eroe.Arma = armaService.GetArmaByID(eroe.ArmaID);
eroe.Giocatore = giocatoreService.GetGiocatore(giocatore.Nome);
eroe.GiocatoreID = eroe.Giocatore.ID;
eroe.Livello = livelloService.GetLivello(eroe.LivelloID);
if (eroe == null)
{
x = 0;
break;
}
//Scelgo il mostro con la funzione random
Mostro mostro = Partita.SceltaMostro(eroe, listaMostri);
//Inizia la battaglia
x = Partita.Battaglia(eroe, mostro);
Console.WriteLine("Se vuoi giocare ancora premi 0");
char d = Console.ReadKey().KeyChar;
Console.WriteLine();
if (d == '0')
{
giocatore.ListaEroi.Clear();
x = 0;
break;
}
else
{
x = 1;
}
break;
case '2':
Eroe eroe3 = Partita.CreazioneEroe(giocatore, listaClassi, listaArmi, listaeroi);
break;
case '3':
Partita.VisualizzaEroi(listaeroi, giocatore);
Console.WriteLine("Inserisci il nome dell'eroe che vuoi eliminare");
string nome = Console.ReadLine();
Eroe eroe2 = eroeservice.GetEroeByName(nome);
if (eroe2.Nome == null)
{
Console.WriteLine("Non esiste questo eroe!");
break;
}
eroeservice.DeleteEroe(eroe2);
break;
case '4':
Partita.VisualizzaStatistiche(giocatore, listaGiocatori, listaeroi);
break;
case '5':
//nel caso in cui un giocatore Utente inserisca il 5 faccio un controllo e lo riporto al menù
if (giocatore.Ruolo != "Admin")
{
Console.WriteLine("Scelta sbagliata, Torna al menu"); break;
}
Partita.CreazioneMostro(listaMostri, listaClassi, listaArmi, listaLivelli);
Console.WriteLine("Il Mostro é stato creato, torna al menù");
break;
default:
x = 1;
break;
}
} while (x == 0);
}
/// <summary>
/// Metodo per la creazione di un mostro
/// Si chiedono da Console le informazioni relative al mostro da creare mostrando le scelte (ottenute attraverso le repository _classeRepo e _armaRepo e _livelloRepo)
/// dopodiché chiama il metodo Create da repository _repo
/// </summary>
/// <returns>Restituisce un booleano: true se tutto è andato a buon fine, false altrimenti (se nessuna eccezione è stata generata nelle varie chiamate)</returns>
public bool CreateMostro()
{
string nome;
do
{
Console.WriteLine("Scegli un nome per il mostro");
nome = Console.ReadLine();
if (string.IsNullOrWhiteSpace(nome))
{
Console.WriteLine("Nome non valido\n");
}
} while (string.IsNullOrWhiteSpace(nome));
nome = nome.Trim();
Console.WriteLine("Scegli la classe del mostro tra queste:");
IEnumerable <Classe> classi = _classeRepo.GetAllClassiByIsEroe(false);
if (classi == null)
{
return(false); // Eccezione generata
}
int j;
for (int i = 0; i < classi.Count(); i++)
{
Console.WriteLine("Premi " + i.ToString() + " per " + classi.ElementAt(i).Nome);
}
while (int.TryParse(Console.ReadLine(), out j) == false || j < 0 || j >= classi.Count())
{
Console.WriteLine("Digita nuovamente");
}
Console.WriteLine("Scegli l'arma per il mostro tra queste:");
IEnumerable <Arma> armi = _armaRepo.GetArmiByClasseID(classi.ElementAt(j).ID);
if (armi == null)
{
return(false); // Eccezione generata
}
int index_arma;
for (int i = 0; i < armi.Count(); i++)
{
Console.WriteLine("Premi " + i.ToString() + " per " + armi.ElementAt(i).Nome);
}
while (int.TryParse(Console.ReadLine(), out index_arma) == false || index_arma < 0 || index_arma >= armi.Count())
{
Console.WriteLine("Digita nuovamente");
}
IEnumerable <Livello> livelli = _livelloRepo.GetAll();
if (livelli == null)
{
return(false); // Eccezione generata
}
int index_lev;
Console.WriteLine("Scegli un livello da 1 a " + livelli.Count());
while (int.TryParse(Console.ReadLine(), out index_lev) == false || index_lev < 1 || index_lev > livelli.Count())
{
Console.WriteLine("Digita nuovamente");
}
Mostro mostro = new Mostro(nome, armi.ElementAt(index_arma), livelli.ElementAt(index_lev - 1));
if (_repo.Create(mostro))
{
Console.WriteLine("Mostro creato!\n");
return(true);
}
else
{
return(false); // Eccezione generata
}
}
public void Create(Mostro obj)
{
mostri.Add(obj);
}
//Dato un oggetto mostro
//Lo crea nel db
public static void CreaMostro(Mostro mostro)
{
MostroService mostroService = serviceProvider.GetService <MostroService>();
mostroService.CreateNewMostro(mostro);
}
public static Mostro CreazioneMostroLocale()
{
bool check;
var classeScelta = new Classe()
{
};
var armaScelta = new Arma()
{
};
var livelloScelto = new Livello()
{
};
var classi = RegoleGioco.ClassiPerMostro();
//SCELTA CLASSE
do
{
Console.WriteLine("Ecco le classi disponibili: ");
for (int i = 1; i <= classi.Count; i++)
{
Console.WriteLine(i + " - " + classi[i - 1].ToString());
}
Console.WriteLine("Per scegliere una classe digita il numero corrispondente");
string scelta = Console.ReadLine();
check = Int32.TryParse(scelta, out int res);
int indiceClasse = res - 1;
//Try-Catch mi serve nel caso venga inserito un intero non valido (non tra le opzioni)
try
{
classeScelta = classi[indiceClasse];
}
catch (Exception)
{
Console.WriteLine("Scelta non valida");
check = false;
}
} while (check == false);
//SCELTA NOME
Console.WriteLine("\nScrivi il nome del nuovo {0}", classeScelta.nomeClasse);
string nomeMostro;
do
{
nomeMostro = Console.ReadLine().Trim();
//Caso nome vuoto (dato che ho usato trim(), questo caso comprende anche: viene inserito solo l'invio o solo spazi)
if (nomeMostro.Length == 0)
{
Console.WriteLine("\nNome non valido. Per favore, scrivi un altro nome");
check = false;
}
} while (check == false);
//SCELTA ARMA
var armi = RegoleGioco.ArmiPerClasse(classeScelta);
do
{
Console.WriteLine("Ecco le armi disponibili per {0}:", nomeMostro);
for (int i = 1; i <= armi.Count; i++)
{
Console.WriteLine(i + " - " + armi[i - 1].NomeArma + " Punti Danno: " + armi[i - 1].PuntiDanno);
}
Console.WriteLine("Per scegliere un'arma digita il numero corrispondente");
string scelta = Console.ReadLine();
check = Int32.TryParse(scelta, out int res);
int indiceArma = res - 1;
//Try-Catch mi serve nel caso venga inserito un intero non valido (non tra le opzioni)
try
{
armaScelta = armi[indiceArma];
}
catch (Exception)
{
Console.WriteLine("Scelta non valida");
check = false;
}
} while (check == false);
//SCELTA LIVELLO
do
{
Console.WriteLine("Quale livello vuoi assegnare?");
for (int i = 1; i <= livelli.Count; i++)
{
Console.WriteLine(i + " - Livello " + livelli[i - 1].Numero + "\tPunti Vita: " + livelli[i - 1].PuntiVita);
}
Console.WriteLine("Per scegliere un livello digita il numero corrispondente");
string scelta = Console.ReadLine();
check = Int32.TryParse(scelta, out int res);
int indiceLivello = res - 1;
//Try-Catch mi serve nel caso venga inserito un intero non valido (non tra le opzioni)
try
{
livelloScelto = livelli[indiceLivello];
}
catch (Exception)
{
Console.WriteLine("Scelta non valida");
check = false;
}
} while (check == false);
var mostro = new Mostro(nomeMostro, classeScelta.nomeClasse, armaScelta, livelloScelto)
{
};
Console.WriteLine("Hai creato un mostro:");
Console.WriteLine(mostro.ToString());
return(mostro);
}
public static bool SceltaTurno(Eroe eroe, Mostro mostro)
{
bool check = true;
do
{
//Scelte possibili
Console.WriteLine("Cosa vuoi fare?");
Console.WriteLine("1 - Attacco");
Console.WriteLine("2 - Tento la fuga");
string key = Console.ReadLine();
Console.WriteLine("\n");
switch (key)
{
case "1":
//Attacca l'eroe
int attaccoEroe = eroe.Attacca();
//Tolgo punti vita al mostro (in locale)
mostro.LivelloMostro.PuntiVita -= attaccoEroe;
//Comunico l'attacco all'utente
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"{eroe.Nome} attacca con {eroe.ArmaScelta.NomeArma}! Danno: {eroe.ArmaScelta.PuntiDanno}");
Console.ResetColor();
check = true;
break;
case "2":
//Tenta la fuga
var fuga = eroe.Fuga();
if (fuga == true)
{
Console.WriteLine("Sei riuscito a scappare!");
//Eroe perde i punti della fuga
int puntiPersi = mostro.LivelloMostro.Numero * 5;
eroe.PuntiAccumulati -= puntiPersi;
Console.WriteLine("La fuga ti è costata {0} punti!", puntiPersi);
Console.WriteLine("Ora hai {0} punti accumulati", eroe.PuntiAccumulati);
//Finisce la battaglia
return(true);
}
else
{
//Fuga non riuscita, continua la battaglia
Console.WriteLine("La fuga non è riuscita!");
break;
}
default:
Console.WriteLine("Scelta non valida\n");
check = false;
break;
}
} while (check == false);
return(false);
}
public static bool CreazioneMostro(List <Mostro> listaMostri, List <Classe> listaClassi, List <Arma> listaArmi, List <Livello> listaLivelli)
{
Mostro mostro = new Mostro();
Console.WriteLine("Inserisci il Nome");
string nome = Console.ReadLine();
int e = 0;
do
{
foreach (var item in listaMostri)
{
if (item.Nome == nome)
{
Console.WriteLine("Nome già presente! Inserisci un nuovo nome");
e = 0;
break;
}
else
{
e = 1;
}
}
} while (e == 0);
mostro.Nome = nome;
int x = 0;
do
{
Console.WriteLine("Scegli la classe:");
mostroService.SceltaClasse(listaClassi);
string classe = Console.ReadLine();
mostro.Classe = classeService.GetClasse(classe);
if (mostro.Classe.Nome == null)
{
x = 0;
Console.WriteLine("Inserisci la classe corretta!");
}
else
{
mostro.ClasseID = mostro.Classe.ID;
x = 1;
}
} while (x == 0);
int y = 0;
do
{
Console.WriteLine("Scegli l'arma:");
armaService.SceltaArma(listaArmi, mostro);
string arma = Console.ReadLine();
mostro.Arma = armaService.GetArma(arma);
if (mostro.Arma.Nome == null)
{
y = 0;
Console.WriteLine("Inserisci la classe corretta!");
}
else
{
mostro.ArmaID = mostro.Arma.ID;
y = 1;
}
} while (y == 0);
int z = 0;
do
{
Console.WriteLine("Scegli il livello:");
livelloService.SceltaLivello(listaLivelli);
int num = Int32.Parse(Console.ReadLine());
mostro.Livello = livelloService.GetLivello(num);
if (mostro.Arma.Nome == null)
{
z = 0;
Console.WriteLine("Inserisci la classe corretta!");
}
else
{
mostro.ArmaID = mostro.Arma.ID;
z = 1;
}
} while (z == 0);
mostro.LivelloID = mostro.Livello.ID;
mostroService.CreateMostro(mostro);
return(true);
}
public void CreateNewMostro(Mostro mostro)
{
_repo.Create(mostro);
}
