• Najnowsze pytania
  • Bez odpowiedzi
  • Zadaj pytanie
  • Kategorie
  • Tagi
  • Zdobyte punkty
  • Ekipa ninja
  • IRC
  • FAQ
  • Regulamin
  • Książki warte uwagi
Zapytaj

Powiększanie pola gry w grze Sneka-u

Object Storage Arubacloud
–2 głosów
217 wizyt
pytanie zadane 8 kwietnia 2018 w C i C++ przez Arduino04 Użytkownik (560 p.)
Witam napisałem takiego snake:  i mam pytanie jak powiększyć pole gry?
 komentarz 8 kwietnia 2018 przez Arduino04 Użytkownik (560 p.)
przeniesione 9 kwietnia 2018 przez Arkadiusz Waluk 
/*! 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';
}

 

 komentarz 8 kwietnia 2018 przez Arduino04 Użytkownik (560 p.) 
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 Marsjanek$\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;
    }
}

 

 komentarz 8 kwietnia 2018 przez Arduino04 Użytkownik (560 p.) 
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;
    }

}

 

 komentarz 8 kwietnia 2018 przez Hiskiel Pasjonat (22,830 p.)
Wyznasz se po prostu dwie stałe lub dwa define na z szerokoscią i wysokością planszy i na ich podstawie rysuj mapę i sprawdzają kolizje.

1 odpowiedź

+3 głosów
odpowiedź 9 kwietnia 2018 przez Wiciorny Ekspert (269,790 p.)
Jeśli ty go napisałeś, to nie żartując nie możliwe jest to ze nie wiesz jak masz powiększyć pole... skoro sam generowałeś i tworzyłeś pole wraz z jego zakresem.

Podobne pytania

0 głosów
1 odpowiedź 840 wizyt
c++ - sterowanie wężem w grze snake ...
pytanie zadane 28 czerwca 2017 w C i C++ przez Jakub 0 Pasjonat (23,120 p.)
0 głosów
1 odpowiedź 593 wizyt
skręcanie węża w grze snake
pytanie zadane 5 maja 2017 w C i C++ przez Jakub 0 Pasjonat (23,120 p.)
+1 głos
1 odpowiedź 332 wizyt
Tabela wynikow w grze Snake
pytanie zadane 22 kwietnia 2019 w C i C++ przez Marcin Płoński Nowicjusz (130 p.)

92,568 zapytań

141,420 odpowiedzi

319,622 komentarzy

61,954 pasjonatów

Kategorie pytań
Programowanie
Sprzęt komputerowy
Systemy operacyjne, programy
Sieci komputerowe
Hostingi, domeny, usługi
Urządzenia mobilne
Bezpieczeństwo, hacking
Rozwój zawodowy, nauka, praca
Egzaminy zawodowe
Matematyka, fizyka, logika
Grafika i multimedia
Ogłoszenia, zlecenia
Nasze projekty
Nasze poradniki
Sprawy forum
Offtop
Programowanie
C i C++ HTML i CSS JavaScript PHP SQL, bazy danych C# Java SPOJ Python Ruby Assembler Visual Basic Android, Swift, Symbian OpenGL, Unity Inne języki Algorytmy Systemy CMS Mikrokontrolery

Motyw:

Akcja Pajacyk

Pajacyk od wielu lat dożywia dzieci. Pomóż klikając w zielony brzuszek na stronie. Dziękujemy! ♡

Oto polecana książka warta uwagi.
Pełną listę książek znajdziesz tutaj.

Akademia Sekuraka

Kolejna edycja największej imprezy hakerskiej w Polsce, czyli Mega Sekurak Hacking Party odbędzie się już 20 maja 2024r. Z tej okazji mamy dla Was kod: pasjamshp - jeżeli wpiszecie go w koszyku, to wówczas otrzymacie 40% zniżki na bilet w wersji standard!

Więcej informacji na temat imprezy znajdziecie tutaj. Dziękujemy ekipie Sekuraka za taką fajną zniżkę dla wszystkich Pasjonatów!

Akademia Sekuraka

Niedawno wystartował dodruk tej świetnej, rozchwytywanej książki (około 940 stron). Mamy dla Was kod: pasja (wpiszcie go w koszyku), dzięki któremu otrzymujemy 10% zniżki - dziękujemy zaprzyjaźnionej ekipie Sekuraka za taki bonus dla Pasjonatów! Książka to pierwszy tom z serii o ITsec, który łagodnie wprowadzi w świat bezpieczeństwa IT każdą osobę - warto, polecamy!

O działaniu forum

Pasja informatyki w internecie

Polecane miejsca w sieci

Snow Theme by Q2A Market
Powered by Question2Answer
...