Jak stopniowo narysować wisielca po nieudanej próbie?

0

Witam mam problem mianowicie w grze wisielec którą stworzyłem po wpisaniu błędnej litery chciałbym aby stopniowo pojawiał się wisielec niestety nie mogę tego zrobić

Oto kod:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Misc;
class wisielec
{
    private List<string> hasla;
    private string slowa;
    private char[] slowa_gracz;
    private int proby;
    private string bledne_slowa;
    private const string plik = "slowa_wisielec.txt";
/*    string[] draw =
                {
                    "  _____",
                    "  |   |",
                    "  |   O",
                    "  |  /|\\",
                    "  |   |",
                    "  |  / \\",
                    " /|\\",
                    "/ | \\"
                };
 */  
    public wisielec()
    {
        slowa_do_gry();
    }

    private void slowa_do_gry()
    {
        if (File.Exists(plik))
        {
            hasla = File.ReadAllLines(plik).ToList();
        }
        else
        {
            hasla = new List<string> { "telefon", "komputer", "programowanie", "kompresja", "laptop", "myszka" };
            File.WriteAllLines(plik, hasla);
        }
    }

    private void inicjacja_gry()
    {
        Random rand = new Random();
        int randomIndex = rand.Next(hasla.Count);
        slowa = hasla[randomIndex].ToLower();
        slowa_gracz = new char[slowa.Length];
        for (int i = 0; i < slowa.Length; i++)
        {
            slowa_gracz[i] = '_';
        }
        proby = 8;
        bledne_slowa = "";
    }

/*    public void chlopek()
    {
        bool koniec=true;
        for (int i = 0; i < proby; i++) 
        {
            Console.WriteLine(draw[i]);
        }

        while (koniec)
        {
            for (int i = 0; i < proby; i++)
            {
                Console.WriteLine(draw[i]);
            }
        }  koniec = false;
    }
*/
    static void chlopek(int proby)
    {
        string[] wisiel =
            {
                    $"{(proby >=8 ? "  _____" : "")}",
                    $"{(proby >=7 ?  "  |   |" : "")}",
                    $"{(proby >=6 ?  "  |   O" : "")}",
                    $"{(proby >=5 ?  "  |  /|\\" : "")}",
                    $"{(proby >=4 ?  "  |   |" : "")}",
                    $"{(proby >=3 ?  "  |  / \\" : "")}",
                    $"{(proby >=2 ? " /|\\" : "")}",
                    $"{(proby >=1 ? "/ | \\" : "")}"
                };
        Console.WriteLine(wisiel);
      /*  foreach (string lina in wisiel)
        {
            Console.WriteLine(lina);
        }*/
    }
    private void statystyki()
    {
        Console.WriteLine($"Słowo: {string.Join(" ", slowa_gracz)}");
        Console.WriteLine($"Błędne litery: {bledne_slowa}");
        Console.WriteLine($"Pozostałe próby: {proby}");
        
        Console.WriteLine($"{chlopek}");
    }

    private char wpisywana_litera()
    {
        Console.Write("Podaj literę: ");
        char input;
        while (!char.TryParse(Console.ReadLine(), out input) || !char.IsLetter(input))
        {
            Console.WriteLine("Błędny znak. Podaj literę.");
        }
        return char.ToLower(input);
    }

    private void proces_zgadywania(char zgadnij)
    {
        
        if (slowa.Contains(zgadnij))
        {
            for (int i = 0; i < slowa.Length; i++)
            {
                if (slowa[i] == zgadnij)
                {
                    slowa_gracz[i] = zgadnij;
                }
            }
        }
        else
        {
            proby--;
            bledne_slowa += zgadnij + " ";
        }
    }

    private bool rezultat()
    {
        if (proby == 0)
        {
            Console.WriteLine($"Przegrałeś! Hasło to: {slowa}");
            return true;
        }
        else if (!slowa_gracz.Contains('_'))
        {
            Console.WriteLine($"Gratulacje! Odgadłeś hasło: {slowa}");
            return true;
        }
        return false;
    }

    public void gra()
    {
        inicjacja_gry();

        while (true)
        {
            Console.Clear();
            statystyki();

            char guess = wpisywana_litera();
            proces_zgadywania(guess);

            if (rezultat())
            {
                Console.ReadLine();
                break;
            }
        }
    }

    public void dod_haslo()
    {
        Console.Write("Podaj nowe hasło: ");
        string nowe_haslo = Console.ReadLine().ToLower();
        if (!string.IsNullOrWhiteSpace(nowe_haslo))
        {
            hasla.Add(nowe_haslo);
            File.AppendAllLines(plik, new[] { nowe_haslo });
            Console.WriteLine("Hasło dodane pomyślnie!");
        }
        else
        {
            Console.WriteLine("Błędne hasło. Spróbuj ponownie.");
        }
    }

    public void wszystkie_hasla()
    {
        Console.WriteLine("Wszystkie dodane hasła:");
        foreach (var word in hasla)
        {
            Console.WriteLine(word);
        }
        Console.ReadLine(); 
    }

    static void Main()
    {
        wisielec gra = new wisielec();
        bool koniec = false;

        while (!koniec)
        {
            Console.Clear();
            Console.WriteLine(@"
                         __      __.__       .__       .__                          _____
                        /  \    /  \__| _____|__| ____ |  |   ____   ____           |   |   
                        \   \/\/   /  |/  ___/  |/ __ \|  | _/ __ \_/ ___\          |   O   
                         \        /|  |\___ \|  \  ___/|  |_\  ___/\  \___          |  /|\  
                          \__/\  / |__/____  >__|\___  >____/\___  >\___  >         |   |  
                               \/          \/        \/          \/     \/          |  / \  
                                                                                   /|\     
                                                                                  / | \  
");
            Narzedzia.Menu menu = new Narzedzia.Menu(ConsoleColor.Black, ConsoleColor.White, ConsoleColor.DarkGray, ConsoleColor.White);
            menu.Dodaj(new Narzedzia.PozycjaMenu(0, "Rozpocznij grę", ConsoleKey.F1));
            menu.Dodaj(new Narzedzia.PozycjaMenu(1, "Dodaj hasło", ConsoleKey.F2));
            menu.Dodaj(new Narzedzia.PozycjaMenu(2, "Wyświetl wszystkie hasła", ConsoleKey.F3));
            menu.Dodaj(new Narzedzia.PozycjaMenu(3, "Zakończ grę", ConsoleKey.Escape));


            Console.SetCursorPosition(30, 13);

            try
            {
                switch (menu.Wybierz())
                {
                    case 0:
                        Console.Clear();
                        gra.gra();
                        break;

                    case 1:
                        Console.Clear();
                        gra.dod_haslo();
                        break;

                    case 2:
                        Console.Clear();
                        gra.wszystkie_hasla();
                        break;

                    case 3:
                        koniec = true;
                        break;
                    default:
                        Console.Clear();
                        Console.WriteLine("Nieprawidłowy wybór. Spróbuj ponownie.");
                        Console.ReadLine();
                        break;
                }
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

Wysyłam dodatkowo plik Narzedzia.cs do uruchomienia samej gry prawidłowo:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Misc
{
    public class Narzedzia
    {
        public struct PozycjaMenu
        {
            public int Id;
            public string Tekst;
            public ConsoleKey Przycisk;
            public int DlugoscPozycjiMenu;



            public PozycjaMenu(int Id, string Tekst, ConsoleKey Przycisk)
            {
                this.Id = Id;
                this.Tekst = $"{Przycisk} {Tekst}";
                this.Przycisk = Przycisk;
                this.DlugoscPozycjiMenu = this.Tekst.Length;
            }

            public void Wyswietl(ConsoleColor kolorTla, ConsoleColor kolorCzcionki, int maksymalnaDlugosc)
            {
                Console.BackgroundColor = kolorTla;
                Console.ForegroundColor = kolorCzcionki;
                //Console.Write($"{Przycisk} {Tekst}".PadRight(maksymalnaDlugosc));
                //
                Console.Write(Tekst);

                if (DlugoscPozycjiMenu < maksymalnaDlugosc)
                {
                    for (int i = DlugoscPozycjiMenu; i < maksymalnaDlugosc; i++)
                        Console.Write(" ");
                }

                Console.ResetColor();
            }
        }

        public struct Menu
        {
            public List<PozycjaMenu> Pozycje = new List<PozycjaMenu>();
            public int MaksymalnaDlugoscMenu;
            public ConsoleColor KolorTla;
            public ConsoleColor KolorCzcionki;
            public ConsoleColor KolorTlaZaznaczony;
            public ConsoleColor KolorCzcionkiZaznaczony;
            public int AktualnaPozycjaMenu;

            public Menu(ConsoleColor KolorTla, ConsoleColor KolorCzcionki, ConsoleColor KolorTlaZaznaczony,
                        ConsoleColor KolorCzcionkiZaznaczony)
            {
                this.KolorTla = KolorTla;
                this.KolorCzcionki = KolorCzcionki;
                this.KolorTlaZaznaczony = KolorTlaZaznaczony;
                this.KolorCzcionkiZaznaczony = KolorCzcionkiZaznaczony;
                MaksymalnaDlugoscMenu = 0;
                AktualnaPozycjaMenu = 0;
            }

            public void Dodaj(PozycjaMenu pozycja)
            {
                Pozycje.Add(pozycja);

                if (pozycja.DlugoscPozycjiMenu > MaksymalnaDlugoscMenu)
                {
                    MaksymalnaDlugoscMenu = pozycja.DlugoscPozycjiMenu;
                }
            }

            public void Wyswietl(int Left, int Top)
            {
                int aktualnaPozycja = 0;

                foreach (var pozycja in Pozycje)
                {
                    Console.SetCursorPosition(Left, Top + aktualnaPozycja);
                    if (aktualnaPozycja == AktualnaPozycjaMenu)
                    {
                        pozycja.Wyswietl(KolorTlaZaznaczony, KolorCzcionkiZaznaczony, MaksymalnaDlugoscMenu);
                    }
                    else
                    {
                        pozycja.Wyswietl(KolorTla, KolorCzcionki, MaksymalnaDlugoscMenu);
                    }
                    aktualnaPozycja++;
                }
            }

            public int Wybierz()
            {
                var startRysowania = Console.GetCursorPosition();

                Console.CursorVisible = false;

                while (true)
                {
                    Wyswietl(startRysowania.Left, startRysowania.Top);

                    var przycisk = Console.ReadKey(true).Key;

                    if (przycisk == ConsoleKey.DownArrow && AktualnaPozycjaMenu < Pozycje.Count - 1)
                    {
                        AktualnaPozycjaMenu++;
                    }
                    else if (przycisk == ConsoleKey.UpArrow && AktualnaPozycjaMenu > 0)
                    {
                        AktualnaPozycjaMenu--;
                    }
                    else if (przycisk == ConsoleKey.Enter)
                    {
                        Console.CursorVisible = true;
                        return Pozycje[AktualnaPozycjaMenu].Id;
                    }

                    foreach (var pozycja in Pozycje)
                    {
                        if (pozycja.Przycisk == przycisk)
                        {
                            Console.CursorVisible = true;
                            return pozycja.Id;
                        }
                    }
                }
            }

        }
        public static int PodajInt(string tekst, int min = int.MinValue, int max = int.MaxValue)
        {
            while (true)
            {
                try
                {
                    Console.Write(tekst);
                    int wynik = int.Parse(Console.ReadLine());

                    if (wynik >= min && wynik <= max)
                    {
                        return wynik;
                    }
                    else
                    {
                        throw new Exception("Niepoprawny zakres wartosci!");
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }

        }
    }
}
0

Jaki masz problem z wyświetlaniem po wpisaniu błędnej litery?

0

Ja bym skorzystał z takiego czegoś jak

"""
 Cały wisielcowy string
"""

Mialbym cały ten string i poszczególne linie w locie bym zastępował pustymi (w zależności od ilości pozostałych szans). Jedna pętla i powinno smigac.
Rekomenduje wykorzystanie StringBuildera.

0

Chyba nie dodajesz nowych linii w metodzie chłopek tylko rysujesz wszystko w jednej.

0

Można zrobić kilka metod wyświetlających kilka etapów, każdy z osobna. To rozwiązanie nie będzie najładniejsze , ale gdyby chciało się zrobić jeden, trzeba by było pisać po wcześniejszych liniach a to chyba nie jest możliwe. Nawet jeśli jest możliwe, to na pewno nie jest łatwe.

1 użytkowników online, w tym zalogowanych: 0, gości: 1