[C++] Gra typu "snake". Zacinanie gry.
Logowanie
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zapomniałem hasła
» Forum » Programowanie » [C, C++] Szukam pomocy

[C++] Gra typu "snake". Zacinanie gry.

Ostatnio zmodyfikowano 2013-11-26 00:34
Autor Wiadomość
CPnHorror
Temat założony przez niniejszego użytkownika
[C++] Gra typu "snake". Zacinanie gry.
» 2013-11-13 20:30:01
Witam Napisałem Gierkę "Zbieracz Gwiazdek", gra przycina tj. "miga" cały obraz w konsoli . Da się to naprawić pisząc w Dev C++ czy raczej nie? Proszę o Niewytykanie Bugów, wiem jakie są acz wpierw chciałbym zająć się tą kwestią.  :-)

Tutaj Jest Kod Jak Co:

C/C++
#include<windows.h>
#include<conio.h>
#include<iostream>
#include<time.h>

using namespace std;

int czas;
int czas_koniec;
int ok;
int nr_los;
int punkty = 0;
int ruchy = 0;
char key;
char mapa[ 25 ];
int character = 13;

void tworzenie_mapy()
{
    for( int petla01 = 0; petla01 < 25; petla01 += 1 )
    {
        mapa[ petla01 ] = 32;
    };
    mapa[ character ] = 'O';
}

void ruch()
{
    if( key == 'a' )
    {
        mapa[ character ] = 32;
        if( mapa[ character - 1 ] == '*' )
        {
            punkty += 1;
        };
        character -= 1;
        mapa[ character ] = 'O';
    }
    else if( key == 'w' )
    {
        mapa[ character ] = 32;
        if( mapa[ character - 5 ] == '*' )
        {
            punkty += 1;
        };
       
        character -= 5;
        mapa[ character ] = 'O';
    }
    else if( key == 'd' )
    {
        mapa[ character ] = 32;
        if( mapa[ character + 1 ] == '*' )
        {
            punkty += 1;
        };
       
        character += 1;
        mapa[ character ] = 'O';
    }
    else if( key == 's' )
    {
        mapa[ character ] = 32;
        if( mapa[ character + 5 ] == '*' )
        {
            punkty += 1;
        };
       
        character += 5;
        mapa[ character ] = 'O';
    };
}

void los_ele()
{
    time_t t;
    srand(( unsigned ) time( & t ) );
    nr_los = rand() % 24 + 1;
    if( nr_los != character )
    {
        ok = 1;
    }
}

void element()
{
    mapa[ nr_los ] = '*';
}

void odliczanie()
{
    czas = clock() / 1000;
    czas_koniec = 60 - czas;
}

int main()
{
    cout << "Wcisnij dowolny klawisz by zaczac grac .." << endl;
    getch();
    czas_koniec = 60;
    tworzenie_mapy();
    do
    {
        ok = 0;
        system( "cls" );
        cout << "Punkty: " << punkty << endl;
        cout << char( 201 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 187 ) << endl;
        cout << char( 186 ) << mapa[ 1 ] << mapa[ 2 ] << mapa[ 3 ] << mapa[ 4 ] << mapa[ 5 ] << char( 186 ) << endl;
        cout << char( 186 ) << mapa[ 6 ] << mapa[ 7 ] << mapa[ 8 ] << mapa[ 9 ] << mapa[ 10 ] << char( 186 ) << endl;
        cout << char( 186 ) << mapa[ 11 ] << mapa[ 12 ] << mapa[ 13 ] << mapa[ 14 ] << mapa[ 15 ] << char( 186 ) << endl;
        cout << char( 186 ) << mapa[ 16 ] << mapa[ 17 ] << mapa[ 18 ] << mapa[ 19 ] << mapa[ 20 ] << char( 186 ) << endl;
        cout << char( 186 ) << mapa[ 21 ] << mapa[ 22 ] << mapa[ 23 ] << mapa[ 24 ] << mapa[ 25 ] << char( 186 ) << endl;
        cout << char( 200 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 188 ) << endl;
        cout << "Pozostalo Ci Sekund.. : " << czas_koniec << endl;
        cout << "Wykonane Ruchy: " << ruchy << endl;
        cout << "ESC wychodzi z programu..." << endl;
        if( kbhit() )
        {
            key = getch();
            ruch();
            ruchy += 1;
        }
        do
        {
            los_ele();
        } while( ok != 1 );
       
        element();
        odliczanie();
    } while( czas_koniec != 0 );
   
    system( "cls" );
    cout << "Zdobyles " << punkty;
    if( punkty == 1 )
    {
        cout << " punkt .." << endl;
    }
    else if( punkty == 0 )
    {
        cout << " punktow .." << endl;
    }
    else if( 1 < punkty <= 4 )
    {
        cout << " punkty .." << endl;
    }
    else if( punkty > 4 )
    {
        cout << " punktow .." << endl;
    };
    cout << "Wcisnij klawisz aby wyjsc .." << endl;
    getch();
    exit( 0 );
}
P-96231
Buby
» 2013-11-13 21:46:50
Ekran miga, bo czyścisz całą zawartość i wyświetlasz ją na nowo.

Spróbuj czyścić tylko te obszary, które w danym momencie się zmieniają.
Do tego z pomocą przyjdzie ci
\r
 i
\b
.

Pierwsze cofa się do początku linijki, a drugie kasuje ostatni znak. :)

Przeanalizuj uważnie poniższy przykład.

Przykładowy kod:

C/C++
#include <iostream>

int main()
{
    std::cout << "   znalazlo sie na poczatku.\rTo" << std::endl; /* Cofniecie wskaznika pisania na poczatek lini. */
    std::cout << "\nJeden wynosi 2\b1." << std::endl; /* Skasowanie ostatniego znaku */
    return 0;
}


Kod na wyjściu zwróci nam:

To znalazlo sie na poczatku.

Jeden wynosi 1.  


Uwaga! Znacznik
\r
 po przejściu na początek linii, nadpisze zawartość.
W kodzie są celowo trzy spacje więcej :P
P-96238
CPnHorror
Temat założony przez niniejszego użytkownika
» 2013-11-13 21:58:57
ok postaram się jakoś to zrozumieć. pierwszy raz to widzę :-) jakbym nie mógł dać sobie rady to będę pisał. dziękuję :-)

..

jednak nie do końca zrozumiałem tę metodę .. na wiele wszelakich sposobów próbowałem i nie dałem rady, w google nie znalazłem \b i \r na przykładzie 'char'.
mógłbyś ją zobrazować na poniższym przykładzie?

C/C++
cout << char( 200 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 205 ) << char( 188 ) << endl;
P-96239
Buby
» 2013-11-16 20:28:59
Hmm...Żeby użyć
\r i \b
 musisz zmienić pozycje kursora w konsoli.
Poszukałem w Google takiej funkcji i znalazłem.
Co więcej, owa funkcja działa jak
\r
, czyli nadpisuje zawartość.
Więc nie musisz używać dwóch, wyżej wymienionych sposobów, tylko jednej funkcji.
Łatwiej to zrozumiesz, uruchamiając CMD i wciskając klawisz insert.
Wszystko co napiszesz, zastąpi wcześniej napisany wyraz.

Stwierdziłem, że nie będę przerabiał twojego kodu, tylko napiszę własny. Dzięki temu
zaoszczędziłem czas.

W razie niejasności pisz, chociaż bardzo obszernie wytłumaczyłem wszystko w komentarzach.
Mój "wonsz" jak to nazwałem ten program, ma też kilka rzeczy do których można się przyczepić
np. ruch można wykonać tylko po nadaniu wiadomości przez stoper - odliczanie czasu, jednak
ciężko to zauważyć, bo stoper nadaje 100 wiadomości na sekundę - co 10ms, więc można wykonać
100 ruchów na sekundę - nawet nie jestem w stanie tego zrobić.
Poza tym potuningowałem twój program o kolorki - mamy kolorowe napisy etc. :)

No i wreszcie, wiem że mnie znowu wyzwą za wstawienie gotowca, ale ja osobiście szybciej coś zrozumiem
gdy zobaczę przykład.

Kod:
C/C++
/*! DOLACZENIE DYREKTYW !*/
#include <iostream>
#include <windows.h>
#include <conio.h>
#include <time.h>
#include <cstdio>
#include <string>
/* KONIEC */

/*! DEFINICJE MAKR !*/
#define NIEBIESKI 8700  /* Numer specjalny koloru. */
#define ZIELONY 8701    /* Numer specjalny koloru. */
#define CZERWONY 8702   /* Numer specjalny koloru. */
#define ZOLTY 8703      /* Numer specjalny koloru. */
#define BLEKIT 8704     /* Numer specjalny koloru. */
#define FIOLETOWY 8705  /* Numer specjalny koloru. */
#define ZEGAR 2719      /* Numer specjalny zegara. */
/* KONIEC */

typedef COORD PunktNaMapie; /* Utworzenie typu pochodnego od COORD z WinApi
dla wygody pracy. Struktura COORD zawiera dwie wspolrzedne konsoli:
a) |Kolumna - COORD.X| --> |Kolumna - PunktNaMapie.X|
b) |Wiersz - COORD.Y| --> |Wiersz - PunktNaMapie.Y|
*/

/*! Deklaracje funkcji !*/ /* W dalszej czesci kodu znajduja sie definicje ich ciala */
void Kolorek( int KOLOR );
void ZmienPozycjeKursora( PunktNaMapie Wspolrzedne );
void StworzMape();
int Menu( int & Petla );
void Sterowanie( PunktNaMapie & Waz, double & Czas, int & IloscRuchow, PunktNaMapie IleRuchow );
void RysujOwoc( PunktNaMapie & Owoc, PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[], int & NumerOwoca );
bool CzyZebrano( PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[] );
void UsuniecieInformacjiOwoca( PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[] );
/* KONIEC */

/*! FUNKCJA GLOWNA !*/
int main( void )
{
    /*! DEKLARACJE ZMIENNYCH */
    PunktNaMapie Waz; /* Egzemplarz struktury PunktNaMapie, przechowuje polozenie weza. */
    PunktNaMapie Owoc; /* Egzemplarz struktury PunktNaMapie, przechowuje polozenie owoca. */
    PunktNaMapie IleRuchow; /* Egzemplarz struktury PunktNaMapie, przechowuje polozenie wyniku ruchow. */
    PunktNaMapie Zegarek; /* Egzemplarz struktury PunktNaMapie, przechowuje polozenie stopera. */
    PunktNaMapie TablicaWyniku; /* Egzemplarz struktury PunktNaMapie, przechowuje polozenie tablicy z wynikiem. */
    MSG Komunikat; /* MSG - wiadomosc. Zmienna przechowujaca zdarzenia programu.
        Potrzebujemy jej do wlaczenia stopera,ktory bedzie nam odliczac czas. */
   
    IleRuchow.X = 19; /* Nadanie wartosci X egzemplarzowi struktury. */
    IleRuchow.Y = 13; /* Nadanie wartosci Y egzemplarzowi struktury. */
    Waz.X = 4; /* Nadanie wartosci X egzemplarzowi struktury. */
    Waz.Y = 6; /* Nadanie wartosci Y egzemplarzowi struktury. */
    Zegarek.X = 18; /* Nadanie wartosci X egzemplarzowi struktury. */
    Zegarek.Y = 11; /* Nadanie wartosci Y egzemplarzowi struktury. */
    TablicaWyniku.X = 9; /* Nadanie wartosci X egzemplarzowi struktury. */
    TablicaWyniku.Y = 9; /* Nadanie wartosci Y egzemplarzowi struktury. */
   
    int IloscRuchow; /* Zmienna przechowujaca ilosc ruchow. */
    int Wynik; /* Zmienna przechowujaca wynik */
    int GenerujOwoc; /* Zmienna, ktora przechowuje wynik losowania,
        czy utworzyc owoc, czy nie. */
    int Zakoncz = 1; /* Zmienna pozwalajaca wyjsc z petli programu i go zakonczyc. */
    double Czas; /* Zmienna przechowujaca czas. */
    const WORD Zegar = ZEGAR; /* Utworzenie stopera o nazwie zegar, z numerem
        identyfikacyjnym makra ZEGAR, czyli 2719. Makra definiujemy sami i nadajemy
        im wartosci. */
    int IdentyfikatorOwocaX[ 47 ]; /* Tablica przechowujaca punkty X pola, na ktorych dostaniemy punkty
        za zebranie owocka. */
    int IdentyfikatorOwocaY[ 47 ]; /* Tablica przechowujaca punkty Y pola, na ktorych dostaniemy punkty
        za zebranie owocka. */
    int NumerOwoca; /* Zmienna do numerowania tablic owocow. */
    bool Punkt; /* Zmienna przechowujaca wartosci, czy przyznac punkt czy nie. */
    /* KONIEC */
   
   
    srand( time( NULL ) ); /* Wyrazenie zapewniajace pseudolosowosc liczb. */
   
    /*! PETLA GLOWNA !*/
    for(;; ) /* Petla nieskonczona, ktora opuscimy tylko wychodzac z programu. */
    {
        system( "cls" ); /* Czyszczenie ekranu. Wywoluje je tutaj, ze wzgledu na mozliwosc,
            zagrania jeszcze raz. Wtedy wymarze stary obraz i wyswietli nowy. */
        Menu( Zakoncz ); /* Wywolanie funkcji Menu. [Definicja ciala znajduje sie pod funkcja main]. */
       
        if( Zakoncz == 0 ) /* Jesli z menu wybierzemy opcje 'wyjdz', to wylaczymy program. */
        {
            return 0;
        }
       
        /*! Nadanie wartosci nowej gry zmiennym !*/
        IloscRuchow = 0;
        NumerOwoca = 0;
        Wynik = 0;
        Czas = 60;
        /* Koniec */
       
        SetTimer( NULL, Zegar, 10, NULL ); /* Wlaczenie stopera, ktory nada komunikat [wiadomosc]
            co 10 milisekund. */
        Kolorek( ZOLTY ); /* Wywolanie funkcji Kolorek */
        std::cout << "\nWynik:   ";
       
        Kolorek( FIOLETOWY );
        std::cout << Wynik << '\n' << '\n';
       
        Kolorek( ZIELONY );
        std::cout << "Pozostaly czas:   ";
       
        Kolorek( CZERWONY );
        std::cout << Czas << '\n' << '\n';
       
        Kolorek( BLEKIT );
        std::cout << "Wykonano ruchow:   ";
       
        Kolorek( NIEBIESKI );
        std::cout << IloscRuchow;
       
        std::cout << '\n' << '\n' << "Wcisnij Escape, aby zakonczyc.";
       
        Kolorek( ZOLTY );
        ZmienPozycjeKursora( Waz ); /* Wywolanie funkcji zmiany pozycji, i przejscie do pozycji startowej weza. */
        std::cout << "O";
       
       
        while( Czas > 0 ) /* Petla rozgrywki, ktora zakonczy sie, gdy czas bedzie mniejszy od zera. */
        {
            if( GetMessage( & Komunikat, NULL, 0, 0 ) == 1 ) /* Jesli aplikacja dostanie jakis komunikat,
                    a w naszym przypadku od stopera. */
            {
                Kolorek( CZERWONY );
                if( Komunikat.message == WM_TIMER ) /* Sprecyzowanie, od stopera. */
                {
                    Czas -= 0.01; /* Odjecie jednej setnej sekundy od pozostalego czasu. */
                    GenerujOwoc =( rand() % 99 ) + 1; /* Wylosowanie liczby dla generatora owocu. */
                    ZmienPozycjeKursora( Zegarek ); /* Przejscie na pozycje miernika czasu. */
                    std::cout << Czas; /* Nadpisanie jego zawartosci, pozostalym czasem. */
                }
               
                if( GenerujOwoc % 99 == 0 ) /* Zabezpieczenie, aby owoce nie tworzyly sie co jedna
                                    setna sekundy - owoc utworzy sie, gdy program wylosuje liczbe 99. */
                {
                    RysujOwoc( Owoc, Waz, IdentyfikatorOwocaX, IdentyfikatorOwocaY, NumerOwoca ); /* Wywolanie
                                            funkcji rysuj owoc. Jej cialo znajduje sie ponizej. */
                }
               
                if( kbhit() ) /* Jesli wcisniemy jakis przycisk na klawiaturze, to wywolaj funkcje sterowanie. */
                     Sterowanie( Waz, Czas, IloscRuchow, IleRuchow ); /* Wywolanie funkcji - jej cialo ponizej. */
               
                Punkt = CzyZebrano( Waz, IdentyfikatorOwocaX, IdentyfikatorOwocaY ); /* Sprawdzenie, czy nasz waz
                                    zjadl owocka :P. Sprawdzamy to funkcja CzyZebrano - jej cialo patrz nizej. */
                if( Punkt == true ) /* Jesli zjadl to: */
                {
                    ZmienPozycjeKursora( TablicaWyniku ); /* Przejscie kursora na miejsce wyniku. */
                    Wynik++; /* Zwiekszenie o jeden zmiennej wynik */
                    Kolorek( FIOLETOWY );
                    std::cout << Wynik; /* Nadpisanie. */
                    UsuniecieInformacjiOwoca( Waz, IdentyfikatorOwocaX, IdentyfikatorOwocaY ); /* Usuwamy informacje,     ze pole na ktore wjechalismy, posiada owoc. Gdybysmy tego nie zrobili, to dodawaloby nam punkty, tak dlugo, jak stalibysmy na tym polu. Wywolujemy funkcje - jej cialo patrz nizej. */
                }
            }
        }
        system( "cls" ); /* Gdy czas sie skonczy czyscimy ekran. */
       
        /* Wysietlamy statystyki gry. */
        Kolorek( ZIELONY );
        std::cout << "\n\t\tZdobyles ";
       
        Kolorek( FIOLETOWY );
        std::cout << Wynik;
       
        Kolorek( ZIELONY );
        std::cout << " punktow.";
       
        Kolorek( ZOLTY );
        std::cout << "\n\n\t\tWykonales ";
       
        Kolorek( CZERWONY );
        std::cout << IloscRuchow;
       
        Kolorek( ZOLTY );
        std::cout << " ruchow.";
       
        getch();
        std::cout << "\n\n";
       
        Kolorek( BLEKIT );
        system( "pause" );
       
        /* Az dotad. Zauwaz, ze musimy wcisnac dwa razy dowolny klawisz, zabezpieczy to przed
                niepowolanym wyjsciem bez obejrzenia statystyk.*/
       
       
    }
}
/*! KONIEC FUNKCJI GLOWNEJ !*/


/*! CIALA INNYCH FUNKCJI !*/
void Kolorek( int KOLOR )
{
    HANDLE UchwytKonsoli = GetStdHandle( STD_OUTPUT_HANDLE ); /* Pobieramy uchwyt konsoli i przypisujemy do zmiennej. */
   
    /* Jesli kolor wynosi pewna liczbe [tutaj uzywamy zdefiniowancyh makr], to zmien kolor
        czcionki na owy kolor ;). Reszta analogicznie. */
    if( KOLOR == 8700 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_BLUE | FOREGROUND_INTENSITY );
    }
   
    if( KOLOR == 8701 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_GREEN | FOREGROUND_INTENSITY );
    }
   
    if( KOLOR == 8702 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_RED | FOREGROUND_INTENSITY );
    }
   
    if( KOLOR == 8703 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY );
    }
   
    if( KOLOR == 8704 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY );
    }
   
    if( KOLOR == 8705 )
    {
        SetConsoleTextAttribute( UchwytKonsoli, FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
    }
}
void ZmienPozycjeKursora( PunktNaMapie Wspolrzedne )
{
    SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), Wspolrzedne ); /* Ustaw pozycje kursora funkcja
        SetConsoleCursorPosition, w miejsce o koordynatach 'Wspolrzedne', ktore deklarujemy do funkcji jako struktura
        punkt na mapie. */
}
void StworzMape()
{
    /* Narysowanie mapy. */
    std::cout << "##########" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "#        #" << '\n';
    std::cout << "##########" << '\n';
}
int Menu( int & Zakoncz )
{
    int Petla = 1;
    char Wybor;
   
    Kolorek( FIOLETOWY );
    printf( "\t SnakeConsole Version Alpha! \n" ); /* printf to w uogolnieniu to samo co std::cout,
        piszac ten program naszla mnie dziwna ochota na uzycie go. */
   
    Kolorek( ZOLTY );
    printf( "\t\t\t\t\t\t\t$Programed by Buby$\n\n\n" );
   
    Kolorek( BLEKIT );
    printf( "\t\t MENU \n\n" );
   
    Kolorek( CZERWONY );
    printf( "[1] \t" );
   
    Kolorek( ZIELONY );
    printf( " Rozpocznij gre\n" );
   
    Kolorek( CZERWONY );
    printf( "[2] \t" );
   
    Kolorek( ZIELONY );
    printf( " Wyjdz\n" );
   
   
    while( Petla != 2 ) /* Petla wyboru opcji */
    {
        Wybor = getch();
       
        if( Wybor == '1' ) /* Jesli wcisnie jeden na klawiaturze, to wlacz nowa gre. */
        {
            system( "cls" );
           
            Kolorek( NIEBIESKI );
            StworzMape();
           
            Petla = 2;
        }
       
        if( Wybor == '2' ) /* Jesli wcisnie dwa na klawiaturze, to zamknij program. */
        {
            Petla = 2;
            Zakoncz = 0;
        }
       
    }
   
}
void Sterowanie( PunktNaMapie & Waz, double & Czas, int & IloscRuchow, PunktNaMapie IleRuchow )
{
    int Kierunek; /* Zmienna przechowująca numer znaku. */
    Kierunek = getch(); /* Pobranie numeru znaku funkcją getch() i zapis do zmiennej. */
   
    switch( Kierunek ) /* Instrukcja warunkowa switch. */
    {
    case 72: /* Strzalka w gore. */
        ZmienPozycjeKursora( Waz );
        std::cout << " "; /* Zamazanie starej pozycji. */
       
        if( Waz.Y != 1 ) /* Zabezpieczenie, ze waz nie wyjdzie poza mape. */
        {
            Waz.Y -= 1; /* Jeden wiersz w gore. */
            IloscRuchow++; /* Zwiekszenie ilosci ruchow. */
            ZmienPozycjeKursora( IleRuchow ); /* Zmiana pozycji na tabele wyswietlania ilosci ruchow. */
            Kolorek( NIEBIESKI );
            std::cout << IloscRuchow; /* Nadpisanie. */
        }
       
        Kolorek( ZOLTY );
        ZmienPozycjeKursora( Waz ); /* Przejscie do nowej pozycji weza. */
        std::cout << "O"; /* Nadpisanie. */
        break;
       
    case 80: /* Strzalka w dol. */
        ZmienPozycjeKursora( Waz );
        std::cout << " ";
       
        if( Waz.Y != 6 )
        {
            Waz.Y += 1; /* Jeden wiersz w dol. */
            IloscRuchow++;
            ZmienPozycjeKursora( IleRuchow );
            Kolorek( NIEBIESKI );
            std::cout << IloscRuchow;
        }
       
        Kolorek( ZOLTY );
        ZmienPozycjeKursora( Waz );
        std::cout << "O";
        break;
       
    case 75: /* Strzalka w lewo. */
        ZmienPozycjeKursora( Waz );
        std::cout << " ";
       
        if( Waz.X != 1 )
        {
            Waz.X -= 1; /* Jedna kolumna w lewo. */
            IloscRuchow++;
            ZmienPozycjeKursora( IleRuchow );
            Kolorek( NIEBIESKI );
            std::cout << IloscRuchow;
        }
       
        Kolorek( ZOLTY );
        ZmienPozycjeKursora( Waz );
        std::cout << "O";
        break;
       
    case 77: /* Strzalka w prawo. */
        ZmienPozycjeKursora( Waz );
        std::cout << " ";
       
        if( Waz.X != 8 )
        {
            Waz.X += 1; /* Jedna kolumna w prawo. */
            IloscRuchow++;
            ZmienPozycjeKursora( IleRuchow );
            Kolorek( NIEBIESKI );
            std::cout << IloscRuchow;
        }
       
        Kolorek( ZOLTY );
        ZmienPozycjeKursora( Waz );
        std::cout << "O";
        break;
       
    case VK_ESCAPE: /* Jesli wcisnie ESCAPE to petla sie zakonczy i wyjdzie do menu. */
        Czas = 0;
        break;
       
    }
   
}

void RysujOwoc( PunktNaMapie & Owoc, PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[], int & NumerOwoca )
{
    Owoc.X =( rand() % 7 ) + 1; /* Losujemy pozycje X owocka. */
    Owoc.Y =( rand() % 6 ) + 1; /* Losujemy pozycje Y owocka. */
   
    if( Owoc.X != Waz.X ) /* Jesli wylosowany punkt nie jest punktem weza. */
    {
        ZmienPozycjeKursora( Owoc );
        std::cout << "*";
        IdentyfikatorOwocaX[ NumerOwoca ] = Owoc.X; /* Zapis informacji, ze po najechaniu na to pole, ma przyznac punkt. X */
        IdentyfikatorOwocaY[ NumerOwoca ] = Owoc.Y; /* Zapis informacji, ze po najechaniu na to pole, ma przyznac punkt. Y */
        NumerOwoca++;
    }
    else
    {
        if( Owoc.X != 1 ) /* Jesli owoc znajduje sie w miejscu weza i nie jest przy lewej scianie to : */
        {
            Owoc.X -= 1; /* Owoc pojawi sie w lewo od weza. */
            ZmienPozycjeKursora( Owoc );
            std::cout << "*";
            IdentyfikatorOwocaX[ NumerOwoca ] = Owoc.X;
            IdentyfikatorOwocaY[ NumerOwoca ] = Owoc.Y;
            NumerOwoca++;
        }
       
       
        if( Owoc.X != 9 ) /* Analogicznie tylko w prawo. */
        {
            Owoc.X += 1;
            ZmienPozycjeKursora( Owoc );
            std::cout << "*";
            IdentyfikatorOwocaX[ NumerOwoca ] = Owoc.X;
            IdentyfikatorOwocaY[ NumerOwoca ] = Owoc.Y;
            NumerOwoca++;
        }
    }
   
    if( NumerOwoca == 47 ) /* Jesli zapelnimy tablice, to zerujemy licznik tablicy, aby
        program nie dostal critical error. */
    {
        NumerOwoca = 0;
    }
}

bool CzyZebrano( PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[] )
{
    /* Jesli wjechales na pole na ktorym jest owoc to zwroci prawde. */
    if(( Waz.X == IdentyfikatorOwocaX[ 0 ] && Waz.Y == IdentyfikatorOwocaY[ 0 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 24 ] && Waz.Y == IdentyfikatorOwocaY[ 24 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 1 ] && Waz.Y == IdentyfikatorOwocaY[ 1 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 25 ] && Waz.Y == IdentyfikatorOwocaY[ 25 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 2 ] && Waz.Y == IdentyfikatorOwocaY[ 2 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 26 ] && Waz.Y == IdentyfikatorOwocaY[ 26 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 3 ] && Waz.Y == IdentyfikatorOwocaY[ 3 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 27 ] && Waz.Y == IdentyfikatorOwocaY[ 27 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 4 ] && Waz.Y == IdentyfikatorOwocaY[ 4 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 28 ] && Waz.Y == IdentyfikatorOwocaY[ 28 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 5 ] && Waz.Y == IdentyfikatorOwocaY[ 5 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 29 ] && Waz.Y == IdentyfikatorOwocaY[ 29 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 6 ] && Waz.Y == IdentyfikatorOwocaY[ 6 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 30 ] && Waz.Y == IdentyfikatorOwocaY[ 30 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 7 ] && Waz.Y == IdentyfikatorOwocaY[ 7 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 31 ] && Waz.Y == IdentyfikatorOwocaY[ 31 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 8 ] && Waz.Y == IdentyfikatorOwocaY[ 8 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 32 ] && Waz.Y == IdentyfikatorOwocaY[ 32 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 9 ] && Waz.Y == IdentyfikatorOwocaY[ 9 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 33 ] && Waz.Y == IdentyfikatorOwocaY[ 33 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 10 ] && Waz.Y == IdentyfikatorOwocaY[ 10 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 34 ] && Waz.Y == IdentyfikatorOwocaY[ 34 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 11 ] && Waz.Y == IdentyfikatorOwocaY[ 11 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 35 ] && Waz.Y == IdentyfikatorOwocaY[ 35 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 12 ] && Waz.Y == IdentyfikatorOwocaY[ 12 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 36 ] && Waz.Y == IdentyfikatorOwocaY[ 36 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 13 ] && Waz.Y == IdentyfikatorOwocaY[ 13 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 37 ] && Waz.Y == IdentyfikatorOwocaY[ 37 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 14 ] && Waz.Y == IdentyfikatorOwocaY[ 14 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 38 ] && Waz.Y == IdentyfikatorOwocaY[ 38 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 15 ] && Waz.Y == IdentyfikatorOwocaY[ 15 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 39 ] && Waz.Y == IdentyfikatorOwocaY[ 39 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 16 ] && Waz.Y == IdentyfikatorOwocaY[ 16 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 40 ] && Waz.Y == IdentyfikatorOwocaY[ 40 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 17 ] && Waz.Y == IdentyfikatorOwocaY[ 17 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 41 ] && Waz.Y == IdentyfikatorOwocaY[ 41 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 18 ] && Waz.Y == IdentyfikatorOwocaY[ 18 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 42 ] && Waz.Y == IdentyfikatorOwocaY[ 42 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 19 ] && Waz.Y == IdentyfikatorOwocaY[ 19 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 43 ] && Waz.Y == IdentyfikatorOwocaY[ 43 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 20 ] && Waz.Y == IdentyfikatorOwocaY[ 20 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 44 ] && Waz.Y == IdentyfikatorOwocaY[ 44 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 21 ] && Waz.Y == IdentyfikatorOwocaY[ 21 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 45 ] && Waz.Y == IdentyfikatorOwocaY[ 45 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 22 ] && Waz.Y == IdentyfikatorOwocaY[ 22 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 46 ] && Waz.Y == IdentyfikatorOwocaY[ 46 ] ) ||
    ( Waz.X == IdentyfikatorOwocaX[ 23 ] && Waz.Y == IdentyfikatorOwocaY[ 23 ] ) ||( Waz.X == IdentyfikatorOwocaX[ 47 ] && Waz.Y == IdentyfikatorOwocaY[ 47 ] ) )
    {
        return true;
    }
    else /* W przeciwnym wypadku falsz */
    {
        return false;
    }
}

void UsuniecieInformacjiOwoca( PunktNaMapie & Waz, int IdentyfikatorOwocaX[], int IdentyfikatorOwocaY[] )
{
    /* Cala funkcja polega na sprawdzeniu, czy wjechales na pole z owocem. Jesli tak to funkcja ustawia informacje o    punkcie poza mapa. Gdybysmy tego nie zrobili, to wystarczyloby stac w jednym miejscu, a punkty lecialy by rowno z    odmierzaniem stopera. Wiem, ze topornie wyglada, ale mialem pustke w glowie. -,-' */
    if( Waz.X == IdentyfikatorOwocaX[ 0 ] && Waz.Y == IdentyfikatorOwocaY[ 0 ] )
    {
        IdentyfikatorOwocaX[ 0 ] = 0;
        IdentyfikatorOwocaY[ 0 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 1 ] && Waz.Y == IdentyfikatorOwocaY[ 1 ] )
    {
        IdentyfikatorOwocaX[ 1 ] = 0;
        IdentyfikatorOwocaY[ 1 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 2 ] && Waz.Y == IdentyfikatorOwocaY[ 2 ] )
    {
        IdentyfikatorOwocaX[ 2 ] = 0;
        IdentyfikatorOwocaY[ 2 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 3 ] && Waz.Y == IdentyfikatorOwocaY[ 3 ] )
    {
        IdentyfikatorOwocaX[ 3 ] = 0;
        IdentyfikatorOwocaY[ 3 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 4 ] && Waz.Y == IdentyfikatorOwocaY[ 4 ] )
    {
        IdentyfikatorOwocaX[ 4 ] = 0;
        IdentyfikatorOwocaY[ 4 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 5 ] && Waz.Y == IdentyfikatorOwocaY[ 5 ] )
    {
        IdentyfikatorOwocaX[ 5 ] = 0;
        IdentyfikatorOwocaY[ 5 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 6 ] && Waz.Y == IdentyfikatorOwocaY[ 6 ] )
    {
        IdentyfikatorOwocaX[ 6 ] = 0;
        IdentyfikatorOwocaY[ 6 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 7 ] && Waz.Y == IdentyfikatorOwocaY[ 7 ] )
    {
        IdentyfikatorOwocaX[ 7 ] = 0;
        IdentyfikatorOwocaY[ 7 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 8 ] && Waz.Y == IdentyfikatorOwocaY[ 8 ] )
    {
        IdentyfikatorOwocaX[ 8 ] = 0;
        IdentyfikatorOwocaY[ 8 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 9 ] && Waz.Y == IdentyfikatorOwocaY[ 9 ] )
    {
        IdentyfikatorOwocaX[ 9 ] = 0;
        IdentyfikatorOwocaY[ 9 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 10 ] && Waz.Y == IdentyfikatorOwocaY[ 10 ] )
    {
        IdentyfikatorOwocaX[ 10 ] = 0;
        IdentyfikatorOwocaY[ 10 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 11 ] && Waz.Y == IdentyfikatorOwocaY[ 11 ] )
    {
        IdentyfikatorOwocaX[ 11 ] = 0;
        IdentyfikatorOwocaY[ 11 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 12 ] && Waz.Y == IdentyfikatorOwocaY[ 12 ] )
    {
        IdentyfikatorOwocaX[ 12 ] = 0;
        IdentyfikatorOwocaY[ 12 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 13 ] && Waz.Y == IdentyfikatorOwocaY[ 13 ] )
    {
        IdentyfikatorOwocaX[ 13 ] = 0;
        IdentyfikatorOwocaY[ 13 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 14 ] && Waz.Y == IdentyfikatorOwocaY[ 14 ] )
    {
        IdentyfikatorOwocaX[ 14 ] = 0;
        IdentyfikatorOwocaY[ 14 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 15 ] && Waz.Y == IdentyfikatorOwocaY[ 15 ] )
    {
        IdentyfikatorOwocaX[ 15 ] = 0;
        IdentyfikatorOwocaY[ 15 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 16 ] && Waz.Y == IdentyfikatorOwocaY[ 16 ] )
    {
        IdentyfikatorOwocaX[ 16 ] = 0;
        IdentyfikatorOwocaY[ 16 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 17 ] && Waz.Y == IdentyfikatorOwocaY[ 17 ] )
    {
        IdentyfikatorOwocaX[ 17 ] = 0;
        IdentyfikatorOwocaY[ 17 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 18 ] && Waz.Y == IdentyfikatorOwocaY[ 18 ] )
    {
        IdentyfikatorOwocaX[ 18 ] = 0;
        IdentyfikatorOwocaY[ 18 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 19 ] && Waz.Y == IdentyfikatorOwocaY[ 19 ] )
    {
        IdentyfikatorOwocaX[ 19 ] = 0;
        IdentyfikatorOwocaY[ 19 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 20 ] && Waz.Y == IdentyfikatorOwocaY[ 20 ] )
    {
        IdentyfikatorOwocaX[ 20 ] = 0;
        IdentyfikatorOwocaY[ 20 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 21 ] && Waz.Y == IdentyfikatorOwocaY[ 21 ] )
    {
        IdentyfikatorOwocaX[ 21 ] = 0;
        IdentyfikatorOwocaY[ 21 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 22 ] && Waz.Y == IdentyfikatorOwocaY[ 22 ] )
    {
        IdentyfikatorOwocaX[ 22 ] = 0;
        IdentyfikatorOwocaY[ 22 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 23 ] && Waz.Y == IdentyfikatorOwocaY[ 23 ] )
    {
        IdentyfikatorOwocaX[ 23 ] = 0;
        IdentyfikatorOwocaY[ 23 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 24 ] && Waz.Y == IdentyfikatorOwocaY[ 24 ] )
    {
        IdentyfikatorOwocaX[ 24 ] = 0;
        IdentyfikatorOwocaY[ 24 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 25 ] && Waz.Y == IdentyfikatorOwocaY[ 25 ] )
    {
        IdentyfikatorOwocaX[ 25 ] = 0;
        IdentyfikatorOwocaY[ 25 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 26 ] && Waz.Y == IdentyfikatorOwocaY[ 26 ] )
    {
        IdentyfikatorOwocaX[ 26 ] = 0;
        IdentyfikatorOwocaY[ 26 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 27 ] && Waz.Y == IdentyfikatorOwocaY[ 27 ] )
    {
        IdentyfikatorOwocaX[ 27 ] = 0;
        IdentyfikatorOwocaY[ 27 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 28 ] && Waz.Y == IdentyfikatorOwocaY[ 28 ] )
    {
        IdentyfikatorOwocaX[ 28 ] = 0;
        IdentyfikatorOwocaY[ 28 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 29 ] && Waz.Y == IdentyfikatorOwocaY[ 29 ] )
    {
        IdentyfikatorOwocaX[ 29 ] = 0;
        IdentyfikatorOwocaY[ 29 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 30 ] && Waz.Y == IdentyfikatorOwocaY[ 30 ] )
    {
        IdentyfikatorOwocaX[ 30 ] = 0;
        IdentyfikatorOwocaY[ 30 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 31 ] && Waz.Y == IdentyfikatorOwocaY[ 31 ] )
    {
        IdentyfikatorOwocaX[ 31 ] = 0;
        IdentyfikatorOwocaY[ 31 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 32 ] && Waz.Y == IdentyfikatorOwocaY[ 32 ] )
    {
        IdentyfikatorOwocaX[ 32 ] = 0;
        IdentyfikatorOwocaY[ 32 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 33 ] && Waz.Y == IdentyfikatorOwocaY[ 33 ] )
    {
        IdentyfikatorOwocaX[ 33 ] = 0;
        IdentyfikatorOwocaY[ 33 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 34 ] && Waz.Y == IdentyfikatorOwocaY[ 34 ] )
    {
        IdentyfikatorOwocaX[ 34 ] = 0;
        IdentyfikatorOwocaY[ 34 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 35 ] && Waz.Y == IdentyfikatorOwocaY[ 35 ] )
    {
        IdentyfikatorOwocaX[ 35 ] = 0;
        IdentyfikatorOwocaY[ 35 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 36 ] && Waz.Y == IdentyfikatorOwocaY[ 36 ] )
    {
        IdentyfikatorOwocaX[ 36 ] = 0;
        IdentyfikatorOwocaY[ 36 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 37 ] && Waz.Y == IdentyfikatorOwocaY[ 37 ] )
    {
        IdentyfikatorOwocaX[ 37 ] = 0;
        IdentyfikatorOwocaY[ 37 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 38 ] && Waz.Y == IdentyfikatorOwocaY[ 38 ] )
    {
        IdentyfikatorOwocaX[ 38 ] = 0;
        IdentyfikatorOwocaY[ 38 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 39 ] && Waz.Y == IdentyfikatorOwocaY[ 39 ] )
    {
        IdentyfikatorOwocaX[ 39 ] = 0;
        IdentyfikatorOwocaY[ 39 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 40 ] && Waz.Y == IdentyfikatorOwocaY[ 40 ] )
    {
        IdentyfikatorOwocaX[ 40 ] = 0;
        IdentyfikatorOwocaY[ 40 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 41 ] && Waz.Y == IdentyfikatorOwocaY[ 41 ] )
    {
        IdentyfikatorOwocaX[ 41 ] = 0;
        IdentyfikatorOwocaY[ 41 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 42 ] && Waz.Y == IdentyfikatorOwocaY[ 42 ] )
    {
        IdentyfikatorOwocaX[ 42 ] = 0;
        IdentyfikatorOwocaY[ 42 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 43 ] && Waz.Y == IdentyfikatorOwocaY[ 43 ] )
    {
        IdentyfikatorOwocaX[ 43 ] = 0;
        IdentyfikatorOwocaY[ 43 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 44 ] && Waz.Y == IdentyfikatorOwocaY[ 44 ] )
    {
        IdentyfikatorOwocaX[ 44 ] = 0;
        IdentyfikatorOwocaY[ 44 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 45 ] && Waz.Y == IdentyfikatorOwocaY[ 45 ] )
    {
        IdentyfikatorOwocaX[ 45 ] = 0;
        IdentyfikatorOwocaY[ 45 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 46 ] && Waz.Y == IdentyfikatorOwocaY[ 46 ] )
    {
        IdentyfikatorOwocaX[ 46 ] = 0;
        IdentyfikatorOwocaY[ 46 ] = 0;
    }
   
    if( Waz.X == IdentyfikatorOwocaX[ 47 ] && Waz.Y == IdentyfikatorOwocaY[ 47 ] )
    {
        IdentyfikatorOwocaX[ 47 ] = 0;
        IdentyfikatorOwocaY[ 47 ] = 0;
    }
   
}
 
P-96372
CPnHorror
Temat założony przez niniejszego użytkownika
» 2013-11-26 00:34:53
Panie Mój i Królu :-) o wiele łatwiej idzie nauka przy takich ludziach. acz nadal mam problem z tą metodą.
Ale poniekąd udało mnie się znaleźć inne rozwiązanie. zbytnio nie wiem co w tym jest do czego acz wystarczy skopiować, wkleić , wykonać funkcję podając coordy i działa :-) dziękuje za twoją życzliwość.

C/C++
void nadpis( const int x, const int y )
{
    HANDLE hCon = GetStdHandle( STD_OUTPUT_HANDLE );
   
    COORD coord = { x, y };
    SetConsoleCursorPosition( hCon, coord );
}
P-97528
« 1 »
  Strona 1 z 1  
» Forum » Programowanie » [C, C++] Szukam pomocy
© Wszelkie prawa zastrzeżone 2005-2024