Oto kolejne 2 bonusy.
Caid odpowiedzialny będzie za spadającą apteczkę z życiami. Apteczka ta nie będzie wypadała z wroga, lecz losowo z górnej części ekranu tak samo jak Cprzyspiesz, który będzie zwiększał dwukrotnie szybkość poruszania się robocika.
class Caid: public Cammo
{
public:
void aid()
{
cyfra_losowa=rand()%5;
if( (cyfra_losowa==4) && (poz_y>7000) )
{
poz_x=rand()%550;
poz_y=1;
}
}
};
//************************************************************************
class Cprzyspiesz: public Cammo
{
public:
void przyspiesz ()
{
cyfra_losowa=rand()%30;
if( (cyfra_losowa==8) && poz_y>800 )
{
poz_x=rand()%550;
poz_y=1;
}
}
};
30 wrz 2010
28 wrz 2010
Bonusy w grze
Pora no kolejnego posta... Mam nadzieję, że będę miał więcej czasu to poświęcę trochę więcej czasu na projekt w tym tyg.
Mając już kilka typów wrogów (zapewne dojdzie jeszcze kilka) czas na obiecane bonusy spadające po zestrzeleniu wroga.
Oto klasa bazowa Cammo zawierająca podstawowe zmienne i metodę, które będą dziedziczyły klasy pochodne.
Oto ona:
class Cammo
{
public:
int poz_x, poz_y;
int cyfra_losowa;
Cammo::Cammo()
{
poz_x=0;
poz_y=1000;
}
void ogranicznik()
{
if( (poz_y==465) || (poz_y==466) )
{
poz_y=1000;
}
}
};
Klasa sama w sobie nic nie robi... Zawiera tylko 3 elementy składowe. Pozycję x i y i cyfrę losową, a także funkcję ogranicznik(), która ogranicza zakres spadania bonusu do zmiennej y>=466 (aby bonusik nie leciał nam po interfejsie).
Dopiero klasy pochodne wyjaśnią koncepcję utworzenia klasy bazowej. Oto pierwsza z nich
class Cammo_bazooka: public Cammo
{
public:
void bazooka(int pozx,int pozy)
{
cyfra_losowa=rand()%8;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
Klasa ta dziedziczy publicznie z klasy Cammo i zawiera 1 metodę, która będzie używała odziedziczone elementy z klasy bazowej.
No ok ale po co to właściwie?? Już tłumaczę... Klasa zawiera metodę void bazooka(int pozx,int pozy), która przyjmuje 2 argumenty od trafionego przez nas wroga. Funkcja będzie wywoływana w main() TYLKO WTEDY gdy trafimy we "właściwego" wroga. Właściwego, bo z każdego wroga będzie wypadał inny rodzaj amunicji.
Po każdym obiegu głównej pętli gry i trafieniu we wroga cyfra losowa przyjmuje losową wartość z przedziału 0-8 i w instrukcji if( (cyfra_losowa==4) && (poz_y>800) ) sprawdzamy czy wylosowana cyfra to 4(akurat taką wybrałem nie ma to żadnego znaczenia) i czy na planszy gry nie ma bonusu (poz_y>800) to w miejscu trafionego wroga wypada nam bonus.
Jak sama nazwa wskazuje ta klasa dotyczy bonusu w postaci dodatkowej amunicji. Wykorzystanie jej będzie miało miejsce w main().
Oto pozostałe 3 klasy stworzone prawie identycznie jak Cammo_bazooka. Różnią się częstotliwością wypadania broni. Im mocniejsza broń tym rzadziej wypadnie.
class Cammo_machgun: public Cammo
{
public:
void machgun(int pozx,int pozy)
{
cyfra_losowa=rand()%13;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
//********************************************************************************************
class Cammo_laser: public Cammo
{
public:
void laser(int pozx,int pozy)
{
cyfra_losowa=rand()%17;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
//********************************************************************************************
class Cammo_flame: public Cammo
{
public:
void flame(int pozx,int pozy)
{
cyfra_losowa=rand()%22;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
W następnym poście umieszczę bonusy z życiem i przyśpieszaczem(czyt. dopalacz :P). Jak macie jakiś pomysł z jakimś bonusem, który uatrakcyjni grę to piszcie :)
Mając już kilka typów wrogów (zapewne dojdzie jeszcze kilka) czas na obiecane bonusy spadające po zestrzeleniu wroga.
Oto klasa bazowa Cammo zawierająca podstawowe zmienne i metodę, które będą dziedziczyły klasy pochodne.
Oto ona:
class Cammo
{
public:
int poz_x, poz_y;
int cyfra_losowa;
Cammo::Cammo()
{
poz_x=0;
poz_y=1000;
}
void ogranicznik()
{
if( (poz_y==465) || (poz_y==466) )
{
poz_y=1000;
}
}
};
Klasa sama w sobie nic nie robi... Zawiera tylko 3 elementy składowe. Pozycję x i y i cyfrę losową, a także funkcję ogranicznik(), która ogranicza zakres spadania bonusu do zmiennej y>=466 (aby bonusik nie leciał nam po interfejsie).
Dopiero klasy pochodne wyjaśnią koncepcję utworzenia klasy bazowej. Oto pierwsza z nich
class Cammo_bazooka: public Cammo
{
public:
void bazooka(int pozx,int pozy)
{
cyfra_losowa=rand()%8;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
Klasa ta dziedziczy publicznie z klasy Cammo i zawiera 1 metodę, która będzie używała odziedziczone elementy z klasy bazowej.
No ok ale po co to właściwie?? Już tłumaczę... Klasa zawiera metodę void bazooka(int pozx,int pozy), która przyjmuje 2 argumenty od trafionego przez nas wroga. Funkcja będzie wywoływana w main() TYLKO WTEDY gdy trafimy we "właściwego" wroga. Właściwego, bo z każdego wroga będzie wypadał inny rodzaj amunicji.
Po każdym obiegu głównej pętli gry i trafieniu we wroga cyfra losowa przyjmuje losową wartość z przedziału 0-8 i w instrukcji if( (cyfra_losowa==4) && (poz_y>800) ) sprawdzamy czy wylosowana cyfra to 4(akurat taką wybrałem nie ma to żadnego znaczenia) i czy na planszy gry nie ma bonusu (poz_y>800) to w miejscu trafionego wroga wypada nam bonus.
Jak sama nazwa wskazuje ta klasa dotyczy bonusu w postaci dodatkowej amunicji. Wykorzystanie jej będzie miało miejsce w main().
Oto pozostałe 3 klasy stworzone prawie identycznie jak Cammo_bazooka. Różnią się częstotliwością wypadania broni. Im mocniejsza broń tym rzadziej wypadnie.
class Cammo_machgun: public Cammo
{
public:
void machgun(int pozx,int pozy)
{
cyfra_losowa=rand()%13;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
//********************************************************************************************
class Cammo_laser: public Cammo
{
public:
void laser(int pozx,int pozy)
{
cyfra_losowa=rand()%17;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
//********************************************************************************************
class Cammo_flame: public Cammo
{
public:
void flame(int pozx,int pozy)
{
cyfra_losowa=rand()%22;
if( (cyfra_losowa==4) && (poz_y>800) )
{
poz_x=pozx;
poz_y=pozy;
}
}
};
W następnym poście umieszczę bonusy z życiem i przyśpieszaczem(czyt. dopalacz :P). Jak macie jakiś pomysł z jakimś bonusem, który uatrakcyjni grę to piszcie :)
22 wrz 2010
klasa wroga Boss1
Z powodu braku pomysłu na wroga veryhard zrobiłem boss1. Podobnie do poprzednich klas dziedziczymy z klasy bazowej Cwrog i tym razem "edytujemy" 2 metody ale o tym poniżej.
Mam już część bitmap do gry, jeżeli znacie jakieś stronki z darmowymi bitmapami z gier kosmicznych podobnych do mojej to dajcie link :)
class Cboss1 : public Cwrog
{
public:
int pozpocwro_x[5], pozpocwro_y[5];
Cboss1::Cboss1()
{
pozwro_x=300;
pozwro_y=20;
czest_poc=0;
zycia=100;
kierunek_poz=false;
}
void poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+101;
pozwro_y=1000;
zycia=100;
}
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>611)
{
kierunek_poz=false;
}
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
}
void strzelanie_wroga()
{
for(int i=0; i<5; i++)
{
if ( pozpocwro_y[i]>460)
{
if (czest_poc>=100)
{
pozpocwro_x[i]=pozwro_x-10;
pozpocwro_y[i]=pozwro_y+80;
pozpocwro_x[i+1]=pozwro_x+30;
pozpocwro_y[i+1]=pozwro_y+80;
pozpocwro_x[i+2]=pozwro_x+70;
pozpocwro_y[i+2]=pozwro_y+80;
pozpocwro_x[i+3]=pozwro_x+110;
pozpocwro_y[i+3]=pozwro_y+80;
pozpocwro_x[i+4]=pozwro_x+150;
pozpocwro_y[i+4]=pozwro_y+80;
}
}
if(czest_poc==100)
{
czest_poc=0;
}
if (pozpocwro_y[i]>430)
{
pozpocwro_y[i]=800;
}
czest_poc++;
pozpocwro_y[i]=pozpocwro_y[i]+3;
}
}
};
Metoda poruszanie_wroga() w zasadzie nie uległa zmianie poza ograniczeniem
else if(pozwro_x>611)
z powodu większej .bmp aby nie wyszła poza ekran.
Boss porusza się w lewo lub w prawo podobnie jak wrog_medium ale nie spada w dół.
Metoda strzelanie_wroga() jest trochę bardziej skomplikowana, ponieważ nasz Boss1 jak przystało na "matkę" musi być trudny i będzie strzelał 5 pociskami naraz. Wszystko dzieje się w pętli for i przy uzyciu 2- tablic 5-elementowych.
2-óch, ponieważ potrzebujemy 2 zmiennych do określenia położenia pocisku x i y. Reszty nie będę tłumaczył, ponieważ bym się powtarzał co post.
Od zmiennej x odejmuję lub dodaję jakieśwartości aby pociski nie nakładały się na siebie np:
pozpocwro_x[i]=pozwro_x-10;
Jeżeli chodzi o prace nad grą to w 1 dzień szukam jakiś bitmap i je wycinam itp, a resztęczasu poświęcam na kodzenie i testowanie tego co udało mi się napisać. Kolejne dni poświęcę na dodanie jakiś bonusów (dodatkowa amunicja, zwiększenie szybkości) spadających po zestrzeleniu wroga.
Rysunek pomocniczy obrazujący ruchy Boss1
Mam już część bitmap do gry, jeżeli znacie jakieś stronki z darmowymi bitmapami z gier kosmicznych podobnych do mojej to dajcie link :)
class Cboss1 : public Cwrog
{
public:
int pozpocwro_x[5], pozpocwro_y[5];
Cboss1::Cboss1()
{
pozwro_x=300;
pozwro_y=20;
czest_poc=0;
zycia=100;
kierunek_poz=false;
}
void poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+101;
pozwro_y=1000;
zycia=100;
}
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>611)
{
kierunek_poz=false;
}
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
}
void strzelanie_wroga()
{
for(int i=0; i<5; i++)
{
if ( pozpocwro_y[i]>460)
{
if (czest_poc>=100)
{
pozpocwro_x[i]=pozwro_x-10;
pozpocwro_y[i]=pozwro_y+80;
pozpocwro_x[i+1]=pozwro_x+30;
pozpocwro_y[i+1]=pozwro_y+80;
pozpocwro_x[i+2]=pozwro_x+70;
pozpocwro_y[i+2]=pozwro_y+80;
pozpocwro_x[i+3]=pozwro_x+110;
pozpocwro_y[i+3]=pozwro_y+80;
pozpocwro_x[i+4]=pozwro_x+150;
pozpocwro_y[i+4]=pozwro_y+80;
}
}
if(czest_poc==100)
{
czest_poc=0;
}
if (pozpocwro_y[i]>430)
{
pozpocwro_y[i]=800;
}
czest_poc++;
pozpocwro_y[i]=pozpocwro_y[i]+3;
}
}
};
Metoda poruszanie_wroga() w zasadzie nie uległa zmianie poza ograniczeniem
else if(pozwro_x>611)
z powodu większej .bmp aby nie wyszła poza ekran.
Boss porusza się w lewo lub w prawo podobnie jak wrog_medium ale nie spada w dół.
Metoda strzelanie_wroga() jest trochę bardziej skomplikowana, ponieważ nasz Boss1 jak przystało na "matkę" musi być trudny i będzie strzelał 5 pociskami naraz. Wszystko dzieje się w pętli for i przy uzyciu 2- tablic 5-elementowych.
2-óch, ponieważ potrzebujemy 2 zmiennych do określenia położenia pocisku x i y. Reszty nie będę tłumaczył, ponieważ bym się powtarzał co post.
Od zmiennej x odejmuję lub dodaję jakieśwartości aby pociski nie nakładały się na siebie np:
pozpocwro_x[i]=pozwro_x-10;
Jeżeli chodzi o prace nad grą to w 1 dzień szukam jakiś bitmap i je wycinam itp, a resztęczasu poświęcam na kodzenie i testowanie tego co udało mi się napisać. Kolejne dni poświęcę na dodanie jakiś bonusów (dodatkowa amunicja, zwiększenie szybkości) spadających po zestrzeleniu wroga.
Rysunek pomocniczy obrazujący ruchy Boss1
19 wrz 2010
Klasa wroga HARD
Podobnie do klasy MEDIUM dziedziczymy z Cwrog i "edytujemy" tylko funkcję poruszanie_wroga().
class Cwrog_hard : public Cwrog
{
public:
int lot_pion;
Cwrog_hard::Cwrog_hard()
{
lot_pion=0;
zycia=5;
ogranicz_czest_poc=100;
}
void poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+3;
}
if(lot_pion==3)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=5;
pozwro_x=rand()%740;
pozwro_y=-70;
}
if(pozwro_x>790)
{
pozwro_x=0;
}
pozwro_x++;
}
};
Dodałem do Bazowej klasy zmienną ogranicz_czest_poc. Dzięki niej możemy przy tworzeniu potomnych klas ustalić częstotliwość z jaką zostanie wystrzelony kolejny pocisk od wroga.
W klasie HARD edytowałem poruszanie wroga, które wygląda następująco:
po wróg porusza się po skosie w prawo, jak dojdzie do prawej krawędzi ekranu to pojawia się z lewej strony (taka teleportacja :P) i w porównaniu do wroga medium szybciej wystrzeli kolejny pocisk.
Aha i w zależności od stopnia wroga dostajemy za zestrzelenie punkty punktacja=punktacja+3; ale o tym czemu ma to służyć napiszę w przyszłości...
Rysunek pomocniczy obrazujący ruch wroga_hard
Jak narazie kończą mi się pomysły na kolejnych wrogów... Jeżeli nie będę miał pomysłów to zabiorę się za cośinnego np. stworzę bossa :P i może w trakcie prac coś wymyślę lub ktoś z WAS będzie miał jakieś pomysły?
class Cwrog_hard : public Cwrog
{
public:
int lot_pion;
Cwrog_hard::Cwrog_hard()
{
lot_pion=0;
zycia=5;
ogranicz_czest_poc=100;
}
void poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+3;
}
if(lot_pion==3)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=5;
pozwro_x=rand()%740;
pozwro_y=-70;
}
if(pozwro_x>790)
{
pozwro_x=0;
}
pozwro_x++;
}
};
Dodałem do Bazowej klasy zmienną ogranicz_czest_poc. Dzięki niej możemy przy tworzeniu potomnych klas ustalić częstotliwość z jaką zostanie wystrzelony kolejny pocisk od wroga.
W klasie HARD edytowałem poruszanie wroga, które wygląda następująco:
po wróg porusza się po skosie w prawo, jak dojdzie do prawej krawędzi ekranu to pojawia się z lewej strony (taka teleportacja :P) i w porównaniu do wroga medium szybciej wystrzeli kolejny pocisk.
Aha i w zależności od stopnia wroga dostajemy za zestrzelenie punkty punktacja=punktacja+3; ale o tym czemu ma to służyć napiszę w przyszłości...
Rysunek pomocniczy obrazujący ruch wroga_hard
Jak narazie kończą mi się pomysły na kolejnych wrogów... Jeżeli nie będę miał pomysłów to zabiorę się za cośinnego np. stworzę bossa :P i może w trakcie prac coś wymyślę lub ktoś z WAS będzie miał jakieś pomysły?
16 wrz 2010
Klasa wroga MEDIUM
Mamy już bazową klasę wroga. Utworzyliśmy w ostatnim poście klasę wroga EASY, teraz czas na wroga medium. Tworzymy ją dziedzicząc z klasy Cwrog dodając tylko metodę poruszanie_wroga(). Metoda ta ma taką samą nazwę i parametry(a właściwie ich brak) jak funkcja bazowa Cwrog, więc nie przeładowujemy jej tylko edytujemy ją na potrzeby klasy Cwrog_medium. Inne metody odziedziczone void strzelanie_wroga(); i
void odejm_zycia(int); pozostają niezmienne. No może w przyszłości podczas pracy nad projektem coś mi przyjdzie do głowy...
class Cwrog_medium : public Cwrog
{
public:
bool kierunek_poz;
Cwrog_medium::Cwrog_medium()
{
lot_pion=0;
kierunek_poz = true;
zycia=5;
}
void Cwrog_medium::poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+2;
}
if(lot_pion==3)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=5;
pozwro_x=rand()%740;
pozwro_y=-70;
}
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>748)
{
kierunek_poz=false;
}
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
}
};
W tej klasie dodałem typ logiczny bool:
bool kierunek_poz;
Dzięki niemu będziemy przechowywać kierunek lotu w orientacji poziomej czyli lewo lub prawo.
Tak więc jeżeli pozycja X wroga będzie mniejsza niż 0 to zmienna kierunek_poz przyjmie wartość true.
Jeżel pozycjai X wroga będzie większa niż 748 to zmienna kierunek_poz przyjmie wartość false.
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>748)
{
kierunek_poz=false;
}
Jeżeli kierunek_poz ma wartość true to wróg porusza się w prawo, bo
pozwro_x=pozwro_x+1;
Jeżeli kierunek_poz ma wartość false to wróg porusza się w lewo, bo pozwro_x=pozwro_x-1;
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
Zrobiłem rysunek pomocniczy w paincie :P żeby lepiej pokazać o co chodzi... wróg porusza się w lewo lub w prawo, spadając jednocześnie w dół ( if(lot_pion==3) ) trochę wolniej od wroga easy( if(lot_pion==2))
Rysunek pomocniczy obrazujący ruch wroga_medium
Mam zamiar stworzyć kilka rodzajów wrogów. Niestety nie mam zielonego pojęcia o sztucznej inteligencji, więc ruchy wroga muszę sam wymyśleć... Niedługo dodam klasę wroga o nazwie.... Hard ;p
Jak macie jakieś pomysły, zastrzeżenia co do stworzonych klas lub jakiś pomysł na przyszłego wroga to piszcie napewno skorzystam :)
void odejm_zycia(int); pozostają niezmienne. No może w przyszłości podczas pracy nad projektem coś mi przyjdzie do głowy...
class Cwrog_medium : public Cwrog
{
public:
bool kierunek_poz;
Cwrog_medium::Cwrog_medium()
{
lot_pion=0;
kierunek_poz = true;
zycia=5;
}
void Cwrog_medium::poruszanie_wroga()
{
if(zycia<=0)
{
punktacja=punktacja+2;
}
if(lot_pion==3)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=5;
pozwro_x=rand()%740;
pozwro_y=-70;
}
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>748)
{
kierunek_poz=false;
}
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
}
};
W tej klasie dodałem typ logiczny bool:
bool kierunek_poz;
Dzięki niemu będziemy przechowywać kierunek lotu w orientacji poziomej czyli lewo lub prawo.
Tak więc jeżeli pozycja X wroga będzie mniejsza niż 0 to zmienna kierunek_poz przyjmie wartość true.
Jeżel pozycjai X wroga będzie większa niż 748 to zmienna kierunek_poz przyjmie wartość false.
if(pozwro_x<0)
{
kierunek_poz=true;
}
else if(pozwro_x>748)
{
kierunek_poz=false;
}
Jeżeli kierunek_poz ma wartość true to wróg porusza się w prawo, bo
pozwro_x=pozwro_x+1;
Jeżeli kierunek_poz ma wartość false to wróg porusza się w lewo, bo pozwro_x=pozwro_x-1;
if(kierunek_poz)
{
pozwro_x=pozwro_x+1;
}
else if(!kierunek_poz)
{
pozwro_x=pozwro_x-1;
}
Zrobiłem rysunek pomocniczy w paincie :P żeby lepiej pokazać o co chodzi... wróg porusza się w lewo lub w prawo, spadając jednocześnie w dół ( if(lot_pion==3) ) trochę wolniej od wroga easy( if(lot_pion==2))
Rysunek pomocniczy obrazujący ruch wroga_medium
Mam zamiar stworzyć kilka rodzajów wrogów. Niestety nie mam zielonego pojęcia o sztucznej inteligencji, więc ruchy wroga muszę sam wymyśleć... Niedługo dodam klasę wroga o nazwie.... Hard ;p
Jak macie jakieś pomysły, zastrzeżenia co do stworzonych klas lub jakiś pomysł na przyszłego wroga to piszcie napewno skorzystam :)
13 wrz 2010
Klasa bazowa wroga pierwsza wzmianka o dziedziczeniu
Kolejny raz przebudowałem klasę wroga. Dzięki pomysłom Tomkos'a zmieniłem troszkę klasę. Oto efekt:
class Cwrog
{
protected :
int zycia;
public:
int pozwro_x, pozwro_y;
int pozpocwro_x, pozpocwro_y;
int czest_poc, lot_pion;
void poruszanie_wroga();
void strzelanie_wroga();
void odejm_zycia(int);
Cwrog::Cwrog()
{
pozwro_x=rand()%550;
pozwro_y=0;
czest_poc=0;
zycia=3;
lot_pion=0;
}
};
void Cwrog::poruszanie_wroga()
{
if(zycia<=0)
{
punktacja++;
}
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=3;
pozwro_x=rand()%740;
pozwro_y=-100;
}
if(lot_pion==2)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
}
void Cwrog::strzelanie_wroga()
{
if(pozwro_y>=0)
{
if ( (pozpocwro_y>460) || (pozpocwro_y==0) )
{
if (czest_poc>=200)
{
pozpocwro_x=pozwro_x+7;
pozpocwro_y=pozwro_y+25;
}
}
if(czest_poc==200)
{
czest_poc=0;
}
czest_poc++;
}
pozpocwro_y=pozpocwro_y+2;
if (pozpocwro_y>460)
{
pozpocwro_y=800;
}
}
void Cwrog::odejm_zycia(int minus)
{
zycia=zycia-minus;
}
Zmiany są nieznaczne.
- zmienna lot_pion oznacza szybkość z jaką będzie się przemieszczał wróg w dół. Spowodowane jest to tym, że nie mogę użyć zmiennej typu float, double, ponieważ przy wszystkie dotychczasowe funkcje przyjmują zmienne typu integer, także funkcje biblioteczne allegro. Mogłem oczywiście robić rzutowanie lub konwersję ale to by było trochę bez sensu i spowalniało by grę... Zrobiłem sobie pewną funkcję, która zwiększa pozwro_y o 1 co 2 obiegi pętli czyli tak naprawdę jakbyśmy mogli użyć float to daje ten sam efekt co pozwro_y=pozwro_y+0,5; Dzięki tej funkcji możemy opóźniać spadanie wroga w dół.
void Cwrog::poruszanie_wroga()
*
*
if(lot_pion==2)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
-usunąłem kilka if-ów z metod
I tak mamy podstawową klasę. Utworzę teraz klasę pochodną odpowiadającą za
wroga o poziomie easy.
class Cwrog_easy : public Cwrog
{
};
EDIT: rysunek pomocniczy obrazujący ruch wroga_easy
Kod źródłowy zamieszczę po stworzeniu kilku klas wrogow. Uporządkuję też kod i stworzę kilka plików nagłówkowych wraz z cpp dzięki radzie Michała Ciepłego (komentarz w jakimś poście). Ja jeszcze jako tako się w nim odnajduję ale jak ktoś inny otworzy kod tak jak Michał to jednak nie ma pojęcia co się dzieje. Tak więc kod zamieszczę dopiero za kilka postów.
Kilka postów wstecz inni urzytkownicy napisali mi klika cennych rad, które oczywiście w miarę czasu zastosuję :) Dzięki za pomoc i proszę o więcej, jeżeli macie jakieś pomysły :)
class Cwrog
{
protected :
int zycia;
public:
int pozwro_x, pozwro_y;
int pozpocwro_x, pozpocwro_y;
int czest_poc, lot_pion;
void poruszanie_wroga();
void strzelanie_wroga();
void odejm_zycia(int);
Cwrog::Cwrog()
{
pozwro_x=rand()%550;
pozwro_y=0;
czest_poc=0;
zycia=3;
lot_pion=0;
}
};
void Cwrog::poruszanie_wroga()
{
if(zycia<=0)
{
punktacja++;
}
if( (pozwro_y>430) || (zycia<=0) )
{
zycia=3;
pozwro_x=rand()%740;
pozwro_y=-100;
}
if(lot_pion==2)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
}
void Cwrog::strzelanie_wroga()
{
if(pozwro_y>=0)
{
if ( (pozpocwro_y>460) || (pozpocwro_y==0) )
{
if (czest_poc>=200)
{
pozpocwro_x=pozwro_x+7;
pozpocwro_y=pozwro_y+25;
}
}
if(czest_poc==200)
{
czest_poc=0;
}
czest_poc++;
}
pozpocwro_y=pozpocwro_y+2;
if (pozpocwro_y>460)
{
pozpocwro_y=800;
}
}
void Cwrog::odejm_zycia(int minus)
{
zycia=zycia-minus;
}
Zmiany są nieznaczne.
- zmienna lot_pion oznacza szybkość z jaką będzie się przemieszczał wróg w dół. Spowodowane jest to tym, że nie mogę użyć zmiennej typu float, double, ponieważ przy wszystkie dotychczasowe funkcje przyjmują zmienne typu integer, także funkcje biblioteczne allegro. Mogłem oczywiście robić rzutowanie lub konwersję ale to by było trochę bez sensu i spowalniało by grę... Zrobiłem sobie pewną funkcję, która zwiększa pozwro_y o 1 co 2 obiegi pętli czyli tak naprawdę jakbyśmy mogli użyć float to daje ten sam efekt co pozwro_y=pozwro_y+0,5; Dzięki tej funkcji możemy opóźniać spadanie wroga w dół.
void Cwrog::poruszanie_wroga()
*
*
if(lot_pion==2)
{
pozwro_y++;
lot_pion=0;
}
lot_pion++;
-usunąłem kilka if-ów z metod
I tak mamy podstawową klasę. Utworzę teraz klasę pochodną odpowiadającą za
wroga o poziomie easy.
class Cwrog_easy : public Cwrog
{
};
EDIT: rysunek pomocniczy obrazujący ruch wroga_easy
Kod źródłowy zamieszczę po stworzeniu kilku klas wrogow. Uporządkuję też kod i stworzę kilka plików nagłówkowych wraz z cpp dzięki radzie Michała Ciepłego (komentarz w jakimś poście). Ja jeszcze jako tako się w nim odnajduję ale jak ktoś inny otworzy kod tak jak Michał to jednak nie ma pojęcia co się dzieje. Tak więc kod zamieszczę dopiero za kilka postów.
Kilka postów wstecz inni urzytkownicy napisali mi klika cennych rad, które oczywiście w miarę czasu zastosuję :) Dzięki za pomoc i proszę o więcej, jeżeli macie jakieś pomysły :)
9 wrz 2010
Klasa bazowa wroga
Czas przebudować klasę wroga, pisałem o niej na początku bloga. Mam zamiar stworzyć bazową klasę wroga, z której będą dziedziczyły inne klasy. Zatem będzie można zmienić kilka wartości w klasach pochodnych aby pochodne "obiekty" różniły się poziomem wystrzymałości, strzelaniem, itp.
class Cwrog_easy
{
private:
int zycia;
public:
int pozwro_x, pozwro_y;
int pozpocwro_x, pozpocwro_y;
int czest_poc;
void poruszanie_wroga();
void strzelanie_wroga();
void odejm_zycia(int);
Cwrog_easy::Cwrog_easy()
{
pozwro_x=rand()%550;
pozwro_y=0;
czest_poc=0;
zycia=3;
}
};
void Cwrog_easy::poruszanie_wroga()
{
pozwro_y++;
if( (pozwro_y>430) || (pozwro_y==0) || (zycia<=0) )
{
zycia=3;
pozwro_x=rand()%740;
pozwro_y=0;
}
}
void Cwrog_easy::strzelanie_wroga()
{
if ( (pozpocwro_y>460) || (pozpocwro_y==0) )
{
if (pozpocwro_y>460)
{
pozpocwro_y=800;
}
if (czest_poc>=200)
{
pozpocwro_x=pozwro_x+7;
pozpocwro_y=pozwro_y+25;
}
}
if(czest_poc==200)
{
czest_poc=0;
}
pozpocwro_y=pozpocwro_y+3;
czest_poc++;
}
void Cwrog_easy::odejm_zycia(int minus)
{
zycia=zycia-minus;
}
Dodałem:
-poziom żyć wroga
-poprawione strzelanie wroga tzn, jeżeli pocisk wystrzelony przez wroga trafi szybko w cel to następny tak szybko nie wyleci służy temu instrukcja i zmienne
if (czest_poc>=200).
- metoda odejm_zycia(int minus) będzie wywoływana w main() w momencie trafienia wroga pociskiem wystrzelonym z robocika. Wartość przesyłana do tej funkcji będzie zależała od rodzaju broni, którą trafiliśmy wroga.
np. dla karabinu maszynowego pocisk będzie tracił wrogowi 1 życie
enemy.odejm_zycia(1);
Narazie to jest kawałek kodu, który testuję, zmieniam i NAPEWNO jeszcze zmienię jak większość kodu, który trzeba przebudować. Zamieszczam go tutaj bo chcę się podzielić swoim pomysłem :P
class Cwrog_easy
{
private:
int zycia;
public:
int pozwro_x, pozwro_y;
int pozpocwro_x, pozpocwro_y;
int czest_poc;
void poruszanie_wroga();
void strzelanie_wroga();
void odejm_zycia(int);
Cwrog_easy::Cwrog_easy()
{
pozwro_x=rand()%550;
pozwro_y=0;
czest_poc=0;
zycia=3;
}
};
void Cwrog_easy::poruszanie_wroga()
{
pozwro_y++;
if( (pozwro_y>430) || (pozwro_y==0) || (zycia<=0) )
{
zycia=3;
pozwro_x=rand()%740;
pozwro_y=0;
}
}
void Cwrog_easy::strzelanie_wroga()
{
if ( (pozpocwro_y>460) || (pozpocwro_y==0) )
{
if (pozpocwro_y>460)
{
pozpocwro_y=800;
}
if (czest_poc>=200)
{
pozpocwro_x=pozwro_x+7;
pozpocwro_y=pozwro_y+25;
}
}
if(czest_poc==200)
{
czest_poc=0;
}
pozpocwro_y=pozpocwro_y+3;
czest_poc++;
}
void Cwrog_easy::odejm_zycia(int minus)
{
zycia=zycia-minus;
}
Dodałem:
-poziom żyć wroga
-poprawione strzelanie wroga tzn, jeżeli pocisk wystrzelony przez wroga trafi szybko w cel to następny tak szybko nie wyleci służy temu instrukcja i zmienne
if (czest_poc>=200).
- metoda odejm_zycia(int minus) będzie wywoływana w main() w momencie trafienia wroga pociskiem wystrzelonym z robocika. Wartość przesyłana do tej funkcji będzie zależała od rodzaju broni, którą trafiliśmy wroga.
np. dla karabinu maszynowego pocisk będzie tracił wrogowi 1 życie
enemy.odejm_zycia(1);
Narazie to jest kawałek kodu, który testuję, zmieniam i NAPEWNO jeszcze zmienię jak większość kodu, który trzeba przebudować. Zamieszczam go tutaj bo chcę się podzielić swoim pomysłem :P
5 wrz 2010
Bronie w grze- poziom amunicji
W grze mając do dyspozycji jakieś bronie ważym elementem jest ich amunicja. W mojej grze jak wcześniej pisałem występują 4 rodzaje broni:
1-bazooka
2-karabin maszynowy
3-laser
4-miotacz ognia
na blogu jak we wcześniejszych postach będę się posługiwał tymi obiektami z poniższymi kolorami:
Cshots strzal_bazooka;
Cshots strzal_machinegun;
Cshots strzal_laser;
Cshots strzal_flamethrower;
Na początku w pliku klasy.h deklarujemy sobie zmienne, które będą przechowywały stan amunicji i definiujemy je w main() przykładowymi wartościami:
ammo_bazo=100;
ammo_machgun=30;
ammo_laser=20;
ammo_flame=10;
W grze maksymalny stan amunicji będzie wynosił 100. Poniżej przedstawiam znany fragment kodu odpowiedzialny za strzał poszczególną bronią. Widzimy nowe linijki:
ammo_bazo--;
ammo_machgun--;
ammo_laser=--;
ammo_flame=--;
Oczywiście oznaczają one zmniejszenie zmiennej o 1, gdy wystrzelimy pocisk.
Zmieniłem także 4 instrukcje warunowe if np:
if( (bron==1) && (ammo_bazo>0) )
Oznacza, że możemy oddać strzał jeżeli mamy wybraną broń bazooka(klawisz 1) i poziom amunicji jest dodatni.
if( key[KEY_SPACE])
{
if( (bron==1) && (ammo_bazo>0) )
{
if( (strzal_bazooka.pozpoc_y<0) || (strzal_bazooka.pozpoc_y==0) )
{
strzal_bazooka.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(dzwiek, 200,200,1000,0);
ammo_bazo--;
}
}
if( (bron==2) && (ammo_machgun>0) )
{
if( (strzal_machinegun.pozpoc_y<0) || (strzal_machinegun.pozpoc_y==0) )
{
strzal_machinegun.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(machingunn, 200,200,1000,0);
ammo_machgun--;
}
}
if( (bron==3) && (ammo_laser>0) )
{
if( (strzal_laser.pozpoc_y<0) || (strzal_laser.pozpoc_y==0) )
{
strzal_laser.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(laserr, 200,200,1000,0);
ammo_laser--;
}
}
if( (bron==4) && (ammo_flame>0) )
{
if( (strzal_flamethrower.pozpoc_y<0) ||(strzal_flamethrower.pozpoc_y==0) )
{
strzal_flamethrower.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(flamethrow, 200,200,1000,0);
ammo_flame--;
}
}
}
Zmianie uległ(co pewnie nikogo nie dziwi :p) interfejs gry:
Widzimy jakies 4 znaczki. Onaczać będą amunicję w grze. Od góry:
bazooka, karabin maszynowy, laser i miotacz ognia.
Celowo widzimy biały pasek, ponieważ ten pasek będzie pokryty czerwonym zależnie od poziomu amunicji poszczególnej broni.
Odpowiadać za to będzie funkcja:
void poziom_ammo(int poz_ammo, BITMAP* bitmapa, int wysokosc)
{
for(int j=0; j<=poz_ammo ; j++)
{
if(poz_ammo!=0)
{
draw_sprite(bufor, bitmapa, 109+j, wysokosc);
}
}
}
1- argumentem w funkcji jest przesyłana zmienna zawierająca stan amunicji
2- argumentem w funkcji jest wskaźnik do bitmapy
3- argumentem w funkcji jest wysokość na jakiej ma być wyświetlany pasek dla poszczególnej broni.
Jak już wspomiałem będziemy rysować czerwne linie na białym pasku w interfejsie:
draw_sprite(bufor, bitmapa, 109+j, wysokosc);
109 -tyle pikseli od lewej rozpoczyna się biały pasek i mierzy on 100 pikselidługości i 2 szerokości.
109+j będziemy pasek zwiększali(lub zmiejszali) o j-pikseli tzn. o tyle ile będzie miała przesyłana zmienna poz_ammo.
W main wywołujemy ją tak:
poziom_ammo(ammo_bazo, menudolne_poz_ammo, 523);
poziom_ammo(ammo_machgun, menudolne_poz_ammo, 543);
poziom_ammo(ammo_laser, menudolne_poz_ammo, 562);
poziom_ammo(ammo_flame, menudolne_poz_ammo, 583);
Ten element dodaje sensu grze, lecz nie jest do końca dopracowany (jeżeli chodzi o kod). Nie miałem pomysłu jak to lepiej zrobić i zrobiłem ten element funkcyjnie, a nie obiektowo ale znając życie kod przejdzie NAPEWNO modyfikację i będzie obiektowo. Narazie ważne aby działało i motywowało do dalszej pracy :)
W grze dodałem też kolizję pocisku robocika(miotacza ognia) z pociskiem wroga co umożliwia robocikowi jakąś obronę. Nie będę po raz kolejny pisał i objaśniał kodu na blogu, ponieważ jest do ściągnięcia wraz z plikami potrzebnymi do uruchomienia gry (ver 1.04).
Gra na tym etapie wygląda następująco:
1-bazooka
2-karabin maszynowy
3-laser
4-miotacz ognia
na blogu jak we wcześniejszych postach będę się posługiwał tymi obiektami z poniższymi kolorami:
Cshots strzal_bazooka;
Cshots strzal_machinegun;
Cshots strzal_laser;
Cshots strzal_flamethrower;
Na początku w pliku klasy.h deklarujemy sobie zmienne, które będą przechowywały stan amunicji i definiujemy je w main() przykładowymi wartościami:
ammo_bazo=100;
ammo_machgun=30;
ammo_laser=20;
ammo_flame=10;
W grze maksymalny stan amunicji będzie wynosił 100. Poniżej przedstawiam znany fragment kodu odpowiedzialny za strzał poszczególną bronią. Widzimy nowe linijki:
ammo_bazo--;
ammo_machgun--;
ammo_laser=--;
ammo_flame=--;
Oczywiście oznaczają one zmniejszenie zmiennej o 1, gdy wystrzelimy pocisk.
Zmieniłem także 4 instrukcje warunowe if np:
if( (bron==1) && (ammo_bazo>0) )
Oznacza, że możemy oddać strzał jeżeli mamy wybraną broń bazooka(klawisz 1) i poziom amunicji jest dodatni.
if( key[KEY_SPACE])
{
if( (bron==1) && (ammo_bazo>0) )
{
if( (strzal_bazooka.pozpoc_y<0) || (strzal_bazooka.pozpoc_y==0) )
{
strzal_bazooka.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(dzwiek, 200,200,1000,0);
ammo_bazo--;
}
}
if( (bron==2) && (ammo_machgun>0) )
{
if( (strzal_machinegun.pozpoc_y<0) || (strzal_machinegun.pozpoc_y==0) )
{
strzal_machinegun.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(machingunn, 200,200,1000,0);
ammo_machgun--;
}
}
if( (bron==3) && (ammo_laser>0) )
{
if( (strzal_laser.pozpoc_y<0) || (strzal_laser.pozpoc_y==0) )
{
strzal_laser.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(laserr, 200,200,1000,0);
ammo_laser--;
}
}
if( (bron==4) && (ammo_flame>0) )
{
if( (strzal_flamethrower.pozpoc_y<0) ||(strzal_flamethrower.pozpoc_y==0) )
{
strzal_flamethrower.strzelaniee(ludek.pozs_x, ludek.pozs_y );
play_sample(flamethrow, 200,200,1000,0);
ammo_flame--;
}
}
}
Zmianie uległ(co pewnie nikogo nie dziwi :p) interfejs gry:
Widzimy jakies 4 znaczki. Onaczać będą amunicję w grze. Od góry:
bazooka, karabin maszynowy, laser i miotacz ognia.
Celowo widzimy biały pasek, ponieważ ten pasek będzie pokryty czerwonym zależnie od poziomu amunicji poszczególnej broni.
Odpowiadać za to będzie funkcja:
void poziom_ammo(int poz_ammo, BITMAP* bitmapa, int wysokosc)
{
for(int j=0; j<=poz_ammo ; j++)
{
if(poz_ammo!=0)
{
draw_sprite(bufor, bitmapa, 109+j, wysokosc);
}
}
}
1- argumentem w funkcji jest przesyłana zmienna zawierająca stan amunicji
2- argumentem w funkcji jest wskaźnik do bitmapy
3- argumentem w funkcji jest wysokość na jakiej ma być wyświetlany pasek dla poszczególnej broni.
Jak już wspomiałem będziemy rysować czerwne linie na białym pasku w interfejsie:
draw_sprite(bufor, bitmapa, 109+j, wysokosc);
109 -tyle pikseli od lewej rozpoczyna się biały pasek i mierzy on 100 pikselidługości i 2 szerokości.
109+j będziemy pasek zwiększali(lub zmiejszali) o j-pikseli tzn. o tyle ile będzie miała przesyłana zmienna poz_ammo.
W main wywołujemy ją tak:
poziom_ammo(ammo_bazo, menudolne_poz_ammo, 523);
poziom_ammo(ammo_machgun, menudolne_poz_ammo, 543);
poziom_ammo(ammo_laser, menudolne_poz_ammo, 562);
poziom_ammo(ammo_flame, menudolne_poz_ammo, 583);
Ten element dodaje sensu grze, lecz nie jest do końca dopracowany (jeżeli chodzi o kod). Nie miałem pomysłu jak to lepiej zrobić i zrobiłem ten element funkcyjnie, a nie obiektowo ale znając życie kod przejdzie NAPEWNO modyfikację i będzie obiektowo. Narazie ważne aby działało i motywowało do dalszej pracy :)
W grze dodałem też kolizję pocisku robocika(miotacza ognia) z pociskiem wroga co umożliwia robocikowi jakąś obronę. Nie będę po raz kolejny pisał i objaśniał kodu na blogu, ponieważ jest do ściągnięcia wraz z plikami potrzebnymi do uruchomienia gry (ver 1.04).
Gra na tym etapie wygląda następująco:
2 wrz 2010
Bronie w grze Cz.2
Jak obiecałem teraz czas na kolizję:
O kolizji napisałem na początku bloga. Teraz bardziej się rozpiszę. Kolizję wziąłem ze strony easykodera:
http://www.easykoder.vot.pl/
bool kolizja(int x1,int y1,int s1,int w1,int x2,int y2,int s2,int w2)
{
if( x2<=x1+s1 && x2>x1 && y2>=y1 && y2<=y1+w1) return true; else
if( x2<=x1+s1 && x2>x1 && y2+w2>=y1 && y2+w2<=y1+w1) return true; else
if( x2+s2<=x1+s1 && x2+s2>x1 && y2>=y1 && y2<=y1+w1) return true; else
if( x2+s2<=x1+s1 && x2+s2>x1 && y2+w2>=y1 && y2+w2<=y1+w1) return true;
else return false;
};
x1 - współrzędna x lewego górnego rogu naszego prostokąta.
y1 - współrzędna y lewego górnego rogu naszego prostokąta.
w1 - wysokość pierwszego prostokąta.
s1 - szerokość pierwszego prostokąta.
i analogicznie z x2,y2,w2,s2
Teraz wykorzystujemy kolizję dla 4 rozdzji broni tzn. jeżeli pocisk wystrzelony z jednej z 4 broni trafi wrog'a to wrog znika i pojawia się losowo na pozycji x od 0 do 550 i y=0. Także wtedy zmieniamy pozycję pocisku na y=-40 aby można było go znowu wystrzelić(pisałem o tym wcześniej) jak narazie pociski lasera i miotacza ognia przelatują przez wrog'a :P
if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_bazooka.pozpoc_x,strzal_bazooka.pozpoc_y,pocisk->w,pocisk->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
strzal_bazooka.pozpoc_y=-40;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_machinegun.pozpoc_x,strzal_machinegun.pozpoc_y,mach_gun->w,mach_gun->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
strzal_machinegun.pozpoc_y=-30;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_laser.pozpoc_x,strzal_laser.pozpoc_y,laser->w,laser->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_flamethrower.pozpoc_x,strzal_flamethrower.pozpoc_y,flame->w,flame->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
}
Tutaj mamy kolizję pociku wroga z naszym robocikiem, pocisk trafiony w robocika traci nam 3% zyc
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy.pozpocwro_x,enemy.pozpocwro_y,pociskwroga->w,pociskwroga->h) )
{
enemy.pozpocwro_x=enemy.pozwro_x+7;
enemy.pozpocwro_y=enemy.pozwro_y+25;
ycia=zycia-3;
}
Tutaj mamy kolizję wroga z naszym robocikiem, zetknięcie wroga z robocikiem traci nam 5% zyc
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->h) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
zycia=zycia-5;
}
Szczerze mówiąc te kolizje nie zabardzo mi się podobają :/, ponieważ zaczynam się powoli gubić w main(), za dużo if-ów... ale jeszcze się uczę(obiektowości i allegro naraz) i niedługo mam zamiar upchnąć wszystko do klas żeby to jakoś lepiej wyglądało i działało... Do pobrania kod wraz z plikami potrzebnymi do uruchomienia gry ver.1.03.
O kolizji napisałem na początku bloga. Teraz bardziej się rozpiszę. Kolizję wziąłem ze strony easykodera:
http://www.easykoder.vot.pl/
bool kolizja(int x1,int y1,int s1,int w1,int x2,int y2,int s2,int w2)
{
if( x2<=x1+s1 && x2>x1 && y2>=y1 && y2<=y1+w1) return true; else
if( x2<=x1+s1 && x2>x1 && y2+w2>=y1 && y2+w2<=y1+w1) return true; else
if( x2+s2<=x1+s1 && x2+s2>x1 && y2>=y1 && y2<=y1+w1) return true; else
if( x2+s2<=x1+s1 && x2+s2>x1 && y2+w2>=y1 && y2+w2<=y1+w1) return true;
else return false;
};
x1 - współrzędna x lewego górnego rogu naszego prostokąta.
y1 - współrzędna y lewego górnego rogu naszego prostokąta.
w1 - wysokość pierwszego prostokąta.
s1 - szerokość pierwszego prostokąta.
i analogicznie z x2,y2,w2,s2
Teraz wykorzystujemy kolizję dla 4 rozdzji broni tzn. jeżeli pocisk wystrzelony z jednej z 4 broni trafi wrog'a to wrog znika i pojawia się losowo na pozycji x od 0 do 550 i y=0. Także wtedy zmieniamy pozycję pocisku na y=-40 aby można było go znowu wystrzelić(pisałem o tym wcześniej) jak narazie pociski lasera i miotacza ognia przelatują przez wrog'a :P
if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_bazooka.pozpoc_x,strzal_bazooka.pozpoc_y,pocisk->w,pocisk->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
strzal_bazooka.pozpoc_y=-40;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_machinegun.pozpoc_x,strzal_machinegun.pozpoc_y,mach_gun->w,mach_gun->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
strzal_machinegun.pozpoc_y=-30;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_laser.pozpoc_x,strzal_laser.pozpoc_y,laser->w,laser->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
}
else if( kolizja(enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->w,strzal_flamethrower.pozpoc_x,strzal_flamethrower.pozpoc_y,flame->w,flame->w) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
}
Tutaj mamy kolizję pociku wroga z naszym robocikiem, pocisk trafiony w robocika traci nam 3% zyc
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy.pozpocwro_x,enemy.pozpocwro_y,pociskwroga->w,pociskwroga->h) )
{
enemy.pozpocwro_x=enemy.pozwro_x+7;
enemy.pozpocwro_y=enemy.pozwro_y+25;
ycia=zycia-3;
}
Tutaj mamy kolizję wroga z naszym robocikiem, zetknięcie wroga z robocikiem traci nam 5% zyc
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy.pozwro_x,enemy.pozwro_y,wrog->w,wrog->h) )
{
enemy.pozwro_x=rand()%550;
enemy.pozwro_y=0;
zycia=zycia-5;
}
Szczerze mówiąc te kolizje nie zabardzo mi się podobają :/, ponieważ zaczynam się powoli gubić w main(), za dużo if-ów... ale jeszcze się uczę(obiektowości i allegro naraz) i niedługo mam zamiar upchnąć wszystko do klas żeby to jakoś lepiej wyglądało i działało... Do pobrania kod wraz z plikami potrzebnymi do uruchomienia gry ver.1.03.
Subskrybuj:
Posty (Atom)