Beispiel #1
0
        /// <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
            //}
        }
Beispiel #2
0
        /// <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
            }
        }
Beispiel #3
0
        /// <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);
        }
Beispiel #4
0
        /// <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);
            }
        }
Beispiel #5
0
        /// <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!");
            }
        }
Beispiel #6
0
        /// <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();
        }