» Forum » Programowanie » [C, C++] Szukam pomocy

Miganie planszy. Konsola

Ostatnio zmodyfikowano 2015-02-22 16:28

Autor Wiadomość

Buby

» 2015-02-21 21:09:46

PdCurses jak już :P
Tylko, że trzeba pobrać i zainstalować, a w linku do tematu, który wstawiłem, ma przykładowy kod i akurat według mnie wygodniejszą opcją jest WinApi. Ale oczywiście, co kto woli - WinApi, była pierwszą "zewnętrzną" biblioteką, jakiej się uczyłem, więc sentyment jakiś jest. ;p

P-127004

pekfos

» 2015-02-21 22:17:45

A dlaczego nie WinApi?

Bo curses to gotowiec. Jeśli chce się pobawić i potrafi szukać, WinAPI jest dobrą opcją. Tematów z usiłowaniem własnoręcznego przerobienia konsoli chyba wystarczy..

PdCurses jak już :P [..] WinApi

Nazw się czepiasz, a sam źle piszesz ;)

P-127024

assaltpl

Temat założony przez niniejszego użytkownika

» 2015-02-22 16:04:08

Po dłuższych zmaganiach udało się zainstalować PdCurses teraz jeszcze muszę powalczyć z kodem.Buby spojrzałem na ten temat który podrzuciłeś skompilowałem projekt ("snake")ale nie działał.

P-127103

Brunon3

» 2015-02-22 16:09:58

@up:
Skompilowałeś kod z pierwszego posta? ;)
No więc pewnie skompilowałeś "zły" kod.

P-127104

Buby

» 2015-02-22 16:11:24

Hmm? Mi się nadal kompiluje bez problemu - jaki kompilator i środowisko? Być może używasz VisualStudio - z tego co pamiętam, to w projekcie "Snake" używałem biblioteki conio.h, a jak ostatnio sprawdzałem w szkole, to wyglądało tak, jakby Visual jej nie znał :)

P-127105

pekfos

» 2015-02-22 16:12:18

Napisał, że nie działa, a nie, że się nie kompiluje.

P-127106

Brunon3

» 2015-02-22 16:14:30

Nie rozumiem przecież conio.h trzeba dołączyć...

#include <conio.h>

Jak to "nie zna"? U mnie działa... (biblioteka)

P-127108

Buby

» 2015-02-22 16:18:41

A widzisz, u mnie w szkole krzyczy, że biblioteka nie istnieje ;p

Jesteś pewien, że skompilowałeś ten kod i mrugało?

/*! 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-127109

1 « 2 » 3

Poprzednia strona

Strona 2 z 3

Następna strona

» Forum » Programowanie » [C, C++] Szukam pomocy