Space destroyer (gra)

Finał konkursu

2010-11-23T22:48:00.000+01:00

Space Destroyer ku mojemu zaskoczeniu przeszedł przez I-szy etap eliminacji i dostał się do finału. Informacja o finale i jego uczestnikach
II etap i jego końcowa klasyfikacja zależy od Was głosujących...
Wystarczy wejść na stronę http://dajsiepoznac.devmedia.pl/ -Głosowanie - Etap II i przyporządkować miejscom 1-3 wybrane projekty.
Należy także wskazać najbardziej wartościowy wpis na blogu.

Oto instrukcja głosowania podana przez organizatora konkursu:

w przeciągu kolejnych 7 dni wejdź na stronę http://dajsiepoznac.devmedia.pl/ (w razie niesłabnącego zainteresowania termin ten może ulec nieznacznemu wydłużeniu)
kliknij link "Głosowanie - Etap II"
z trzech list wybierz projekty, które Twoim zdaniem zasługują na największe wyróżnienie
do rozdania masz 6 punków: 3 za pierwsze miejsce, 2 za drugie i 1 za trzecie
obsadzenie dwóch pierwszych miejsc jest obowiązkowe; trzecie miejsce można zostawić puste
pod każdą z pozycji należy podać link do najbardziej wartościowego wg Ciebie posta z bloga, na który oddajesz głos (pokaż za co cenisz dany projekt!)
na podany adres email zostanie wysłana wiadomość z linkiem aktywującym głos - odbierz maila i kliknij (jeśli wiadomość nie dojdzie w ciągu kilku godzin - sprawdź SPAM, jeśli i tam jej nie ma - zgłoś się do mnie)
każdy może zagłosować tylko raz

Osobiście polecam także zagłosowanie na mojego dobrego kolegę, także finalistę w/w konkursu.
Link do jego bloga: http://poznaj-tomkos.blogspot.com/ jego projekt to GPS Biker

Dziekuję za Wasze głosy na mój projekt Space Destroyer

Podsumowanie pracy

2010-11-14T14:38:00.015+01:00

Uczestnictwo w konkursie

Przyszedł czas na podsumowanie tych 15 tygodni pracy nad moim projektem.

Jak wiadomo od pierwszego posta blog powstał w ramach uczestnictwa w konkursie Maćka Aniserowicza "daj się poznać".

Moja gra spełnia wymagania konkursu tj. minimum 10 tyg. pracy nad projektem, w sumie uzbierało się ponad 13 tygodni blogowania na temat gierki.

To tyle na temat konkursu...

Co udało mi się przez ten czas osiągnąć?

Zaczynając projekt moja wiedza kończyła się na napisaniu prostego programu w stylu rozbudowany kalkulator itp. Po tych trzech miesiącach mogę z czystym sumieniem powiedzieć sobie, że dużo się nauczyłem. Zaczynając kodowanie tak naprawdę nie do końca wiedziałem co to jest klasa...

Pisząc bloga równorzędnie czytałem Symfonię c++ i Thinking in c++ poznając cały czas nowe możliwości języka, przez co kod co chwilę się zmieniał.

Powolnymi krokami, praktycznie co posta optymalizowałem kod zmieniając niekiedy całość moich wypocin. Dzięki konkursowi, który w jakiś sposób motywował mnie do dalszej pracy i komentarzom niektórych użytkowników np: http://forum.gamedev.pl/ pomyślnie zakończyłem projekt.

Poznałem także bibliotekę allegro, która jak na pierwszy projekt według mnie jest łatwa w opanowaniu.

Za główny cel tworzenia projektu uważam naukę czyli poznanie języka c++.

Kilka słów o grze

Na początku bloga założyłem sobie jak ma wyglądać gierka i swoje swoje przemyślenia przelałem na kompilator :p. W trakcie pisania cały czas miałem nowe pomysły, które wcielałem do projektu.

Do tej pory udało mi się napisać prawie 2000 linii kodu. Czy to dużo- Tak, za dużo. Gdybym napisał grę czysto obiektowo wyszło by o połowę mniej. Gra jest napisana pół obiektowo -pół funkcyjnie przez co nie jestem do końca zadowolony. Dostałem kilka pomocnych komentarzy co do zmiany kodu; niektóre wykorzystałem, a te wpisy, z których nie skorzystałem poprostu nie do końca zrozumiałem. Dziękuję każdemu za chęć pomocy :)

Gra jest już grywalna i nie ma większych bugów.

Podsumowanie

Projekt uważam za zakończony(chyba, że znajdziecie błędy to je naprawię), choć nie wykluczam napisania Space Destroyera w wersji multiplayer...

Obserwując blogi innych uczestników konkursu nie mam wielkich szans na zajęcie wysokiego miejsca, chociaż nadzieja umiera ostania :p. Niektóre Wasze blogi i opisywany w nich materiał być może pomogą mi w poszerzaniu swojej wiedzy :) Samo uczestnictwo w konkursie przyniosło mi wiele frajdy i motywacji do pisania, pisania i pisania. Przez cały czas trwania konkursu było 2500 wyświetleń stron i ponad 800 unikalnych wejść co napawa mnie optymizmem i radością, że nie piszę tego tylko dla siebie. Najpopularniejszy post to :biblioteka allegro i poczatki gry space destroyer zapewne przez najczęściej Wyszukiwane słowa kluczowe w stylu: allegro c++ gra strzelanie.

Mimo wszystko, jeżeli mój projekt przypadł Wam do gustu proszę o Wasze głosy w konkursie.

Dla mnie i tak jestem w nim zwycięzcą bo "wygrałem" wiedzę :)

Możliwość pobrania i przetestowania gotowej 20-etapowej gry (Uwagi co do gry i błędów zawsze mile widziane )

Pobierz grę

Próbowałem dwoma innymi programami nagrać trailer z gry i tylko tym (AviScreen Pro) udało mi się to osiągnąć. Filmik nie powala jakością i (cichym, opóźnionym) dźwiękiem ale zapewniam, że w grze jest o wiele lepiej. Oczywiście gra działa płynnie i jest fullscreen, a na filmiku wyszło w okienku.

TRAILER Z GRY:

SCREENY Z GRY

Pozostałe screeny w poprzednim poście Animacja wybuchu i zmiana GUI

Animacja wybuchu i zmiana GUI

2010-11-12T19:30:00.002+01:00

Tak, nie pomyliliście się... to jest blog o grze Space destroyer ;p
Wiem wiem menu, jak i interfejs gry w porównaniu do poprzednich postów, a nawet tego ostatniego diametralnie się zmienił na lepsze. Gra odstraszała(-ła mam nadzieję :p) grafiką juz od jej samego uruchomienia i ukazania się menu. Teraz GUI w grze przeszło rewolucję i ładniej i czytelniej wygląda dzięki mojemu koledze Lopezowi za co serdeczne dzięki :)
Poprzedniego posta nazwałem "menu- wersja finalna" i niestety wychodzi na to, że jestem niesłowny... Tak bywa przy pracy nad grą, kiedy to 1 element będzie -n razy modyfikowany. Jeżeli ktoś śledzi mojego bloga od początku to wie, ile razy było wszystko zmieniane począwszy na kodzie, a skończywszy na elementach graficznych.
No dobra już pokazuję nowe GUI :)

Główne menu:

Menu pomoc:

Wrzucam także screena z nowym, o wiele lepszym interfejsem, wpadającym w klimat tej gry. Screen ukazuje także wybuch czyli moment zestrzelenia wroga.

Teraz przejdźmy do kodu... Najpierw pokażę funkcję, która wyświetla wybuch

funkcje.h
void animacjawybuchu(int x, int y)
{
if( (frame2>=0) && (frame2<=13) )
{
draw_sprite(bufor, wybuch0, x, y);
}
// frame od 14 do 65
else if( (frame2>=66) && (frame2<=80) )
{
draw_sprite(bufor, wybuch5, x, y);
}
frame2--;
}
Funkcja przyjmuje 2 parametry-współrzędne x i y i na ich podstawie wyświetla poszczególne bitmapy wybuchu. Poszczególne, bo wybuch złożony jest z 6 bitmap, które są wyświetlane w zależności od wartości frame2. Już tłumaczę po co ta zmienna skoro istnieje frame.
Podczas wywołanie tej funkcji frame może mieć różną wartość np. 35 czyli animacja wybuchu zaczęła się od wybuch3.BMP, a nie od początku czyli wybuch0.BMP. zmienną frame2 możemy sobie manipulować jak chcemy bo nie ma większych powiązań z grą i: frame2 ustawiane jest na 80 czyli nasz wybuch zostanie wyświetlony w wymiarze 80 klatek(1 sekunda w grze) po czym jego wartość będzie równa 0, bo po każdym obiegu pętli jest dekrementacja.

W pliku wrog.h
class Cwrog
{
//kod...
void Cwrog::poruszanie_wroga()
{
//kod...
animacjawybuchu(x, y); //wywołanie funkcji
if(zycia<=0)
{
punktacja++;
play_sample(wybuch, 255,255,1000,0); //odglos wybuchu
}

if( (pozwro_y>430) || (zycia<=0) )
{
frame2=80; //ustawienie frame na 80
x=pozwro_x; //przypisanie x-owi współrzędnej x wroga
y=pozwro_y; //przypisanie y-kowi współrzędnej y wroga
zycia=3*mnoznik; //opiszę to niżej
pozwro_x=rand()%740;
pozwro_y=-70;
}
}
};

Przy każdej klasie wrogów dopisałem kilka linijek. Przy każdym obiegu pętli jest wywoływana funkcja animacjawybuchu(x, y); , jak pamiętamy aby wybuch się wyświetlił to frame2 musi być większe od 0. Jeżeli zestrzelimy wroga to: frame2 ustawia się na 80 i przypisane zostają x-owi i y-kowi współrzędne zestrzelonego wroga. Te współrzędne przyjmuje funkcja animacjawybuchu(x, y); i na ich podstawie wyświetla w danym miejscu wybuch, aż frame2>0.
Czemu nie dałem togo do warunku if(zycia<=0)? dlatego, że brzydko to wygląda jak wróg wychodzi za planszę i momentalnie znika, a tak będzie wybuchał. Oczywiście za to nie dostajemy punktów... Odgłos wybuchu usłyszymy po zestrzeleniu wroga.

Zmodyfikowałem także funkcję wyświetlająca tło w grze, która przyjmuje wskaźnik do bitmapy zawierającej tło. Zrobiłem to, ponieważ w grze będą 3 tła zmieniane naprzemiennie co etap(nowe tło pokazane w screenie z gry).

void Cmenu::wyswietl_tlo(BITMAP *tlo)//owa funkcja
{

}

if(etap%3==0) //jeżeli reszta z dzielenia wartości zmiennej etap wynosi 0
{
menu.wyswietl_tlo(tlo);
}
else if(etap%3==1) //jeżeli reszta z dzielenia wartości zmiennej etap wynosi 1
{
menu.wyswietl_tlo(tlo2);
}
else if(etap%3==2) //jeżeli reszta z dzielenia wartości zmiennej etap wynosi 2
{
menu.wyswietl_tlo(tlo3);
}

Zrobiłem także 20 etapów w grze. W 10-ciu pierwszych wartość mnożnik=1; w następnych mnożnik=2; czyli wartość żyć wrogów zostaje zwiększona dwukrotnie.
Odpowiada za to linijka (zaznaczone na niebiesko plik wrog.h )
np: zycia=6*mnoznik;
Grę wrzucę w niedzielę. Wtedy zrobię podsumowanie całej swojej pracy nad projektem :)

menu- wersja finalna

2010-11-09T17:50:00.005+01:00

Menu uważam za ukończone. Wiem wiem graficznie pozostawia wiele do życzenia ale nie jestem grafikiem...
"buttony" w Menu->pomoc działają na zasadzie kolizji myszki z "buttonem" czyli jeżeli najedziemy myszką na "button" to wyświetla nam się odpowiednia informacja
Przez ten czas dodałem także lepsze bitmapy, które w jakimś stopniu oddają efekt animacji.

Postaram się ukończyć grę do 15 listopada tj. dzień zakończenia konkursu Daj się poznać.

Do zrobienia pozostało:

wybuch po zestrzeleniu wroga i jakiś dźwięk

ustawienie żyć dla różnych wrogów

ustawienie mocy pocisków wrogich statków tzn ile żyć będą nam traciły poszczególne pociski
ustawienie mocy naszych broni

ustawienie odpowiednich szans (%-towo) na wypadnięcie broni (im lepsza broń tym rzadniej wypadnie)

a także inne małe niedociągnięcia w tym minimalne zmiany graficzne... Kod wraz z wszystkimi plikami wrzucę do końca tygodnia.

Menu główne:

Menu pomoc:

SCREEN

Menu -> pomoc

2010-11-06T21:03:00.001+01:00

Główne menu już działa... W międzyczasie szukam bitmap dla wrogów (już na stałe) i meszę znaleźć jeszcze 1 bitmapę dla wroga_vhard. Pozostałe "poruszają się".
Także popracowałem nad menu pomocy. Owe menu będzie działało na zasadzie najechania myszką na poszczególne pole. Otóż jeżeli najedziemy myszką na pole sterowanie to obok wyświetli się nam informacja dotycząca sterowania w grze itd.
Pole powrót oczywiście trzeba będzie kliknąć aby powrócić do głównego menu.
Hmmm pole "o autorze" zmienię na pole "o grze" (komu by się chciało je kliknąć :P) i w nim opiszę rozgrywkę w grze...

Kod jest prawie identyczny jak w poprzednich 2-óch postach, tyle że w pętli głównej wyświetlana jest funkcja gmenu_pomoc(); dla wartości gra==3; , a także małe zabiegi kosmetyczne związane z graficznym położeniem "buttonów"

case 3:
gmenu_pomoc();
break;

W miejscu oznaczonym czerwonym prostokątem będą wyświetlane poszczególne informacje...

Menu w grze- poprawiony błąd pauzy

2010-11-04T12:04:00.001+01:00

Wczoraj trochę się głowiłem jak usunąć ten błąd i niestety nic nie wymyśliłem. Dzisiaj przebudowałem trochę program (dzięki pomysłowi tomkosa) i zamiast kilku pętli while ( lol) menu gry będzie na switchu.
0- oznacza wyświetlanie głównego menu
1- gra
2- wyjście z gry

while( gra!=2 ) //jezeli gra==2 to wychodzi z programu
{
while(( speed > 0) && ( zycia>0) )
{
switch(gra)
{

case 0:
gmenu(); //wyswietlanie menu
break;

case 1:
//kod gry
break;
}

speed--; // ta dekrementacja zmiennej nie może zawierać się w pętli switch, więc jest poza nią(speed odpowiada za prawidłowy podział ilości klatek na sek)
}
blit( bufor, screen, 0,0,0,0, 800,600);
}

Ten sposób jest oczywiście lepszy dla dalszej rozbudowy programu, a także dla oka :)
W międzyczasie znajdę innąmuzyczkę dla menu.
Pod case 3 wyświetlana pomoc w menu ale o tym w następnym poście.

Menu w grze- błąd pauzy

2010-11-03T16:01:00.000+01:00

Niestety menu nie do końca działa w taki sposób jakbym chciał tzn. "buttony" działają prawidłowo, lecz gdy podczas grania w grę naciśniemy ESC (wyjście do menu) to gra działa dalej...
Akcja gry nie zatrzymuje się i po naciśniećui "powrót do gry" widać inne położenie wrogów i nasza postać ma mniej żyć niż przed zastopowaniem gry...
Główna pętla działa dopóki nie naciśniemy wyjście while(gra==1)- podczas wyjścia do menu(wciśnięty ESC i wartość gra=0) ta pętla nie powinna być wykonywana i niby nie jest bo widzimy na ekranie menu, a nie obraz gry. Myślałem dzisiaj nad tym i niestety nic nie wymyśliłem... Może znajdzie się dobry, mądry człowiek, który mnie oświeci :)

while(gra!=2) //2== menu
{
gmenu();

while(gra==1) //1==gra
{
while( ( speed > 0) && ( zycia>0 && punktacja<992) )
{
if (key[KEY_ESC] )
{
gra=0;
}
}
blit( bufor, screen, 0,0,0,0, 800,600);
}
blit( bufor, screen, 0,0,0,0, 800,600);
}

Mam nadzieję, że usunę ten błąd ale narazie pracuję nad Menu->POMOC. Niczego szczególnego z kodu tam nie będzie. Po wejściu w pomoc będą jakieś "buttony" jak w menu i pod każdym będzie wyświetlana jakaś bitmapa na screen, ot całe menu :p.

Odp Tomkos...
W grze muszą być 2 pętle: 1 główna(wykonuj się dopóki coś tam)
2-ga funkcja steruje prękdością increment_speed()
ale 3-cia faktycznie jest niepotrzebna i faktycznie można zrobićmenu na case. Poprawi to czytelność kodu i ułatwi dalszą rozbudowę menu (bo powoli zaczynam się w tym wszystkim gubić)
Może wtedy pauza będzie działała tak jak powinna... Zobaczymy... Może jutro uda mi się zastosować te zmiany w kodzie...

Menu w grze

2010-10-31T12:12:00.003+01:00

Mając chwilę czasu poczytałem o Allegro GUI i uznałem, że jest trochę zagmatwane i nie ma sensu się tego uczyć. Menu zrobiłem(jeszcze nie dokończone) w Allegro w sprytny sposób... Otóż dzięki tej bibliotece możemy używać także myszy. Pozycje myszy to: mouse_x,mouse_y; mouse_b- oznacza stan myszy tzn zmienna ta przechowuje stan poszczególnego klikniętego przycisku np. lewy przycisk myszy: 1, prawy 2, obydwa naraz to 3 itd...
W grze posłużyłem się tylko przyciskiem lewym, którym będziemy wybierali poszczególną część menu. Obrazować je będą bitmapy wyświetlane na bitmapie startu gry menu : nowa gra, powrót do gry, pomoc i wyjście.
Samo kliknięcie nic nam nie da bez poznania współrzędnych myszy i współrzędnych np. nowa gra
jeżeli mamy już te współrzędne posłużymy się funkcją kolizja. Jeżeli nasz kursor znajduje się w obrębie owej bitmapy i klikniemy lewym przyciskiem myszy to aktywujemy "coś".
Standardowy kursor myszy zastąpiłem innym, ładniejszym :)
Oto funkcja, którą wywołuje się w main()

void gmenu()
{
unscare_mouse();
blit(spacedestroyermenu,bufor,0,0,0,0,spacedestroyermenu->w,spacedestroyermenu->h);
draw_sprite(bufor, nowagra, 200,100);
draw_sprite(bufor, powrotdogry, 200,200);
draw_sprite(bufor, pomoc, 200,300);
draw_sprite(bufor, wyjscie, 200,400);

if ( kolizja(200,200,powrotdogry->w,powrotdogry->h,mouse_x,mouse_y,kursor->w,kursor->h) ) //powrot do gry
{
draw_sprite(bufor, ramka, 191,191); //brązowa ramka, która jest rysowana jeżeli najedziemy myszką na poszczególne pole menu. Taki bajer ;p (aktywowana jest kolizja)
if (mouse_b==1) // lewy przycisk myszy
{
play_sample(klik, 255,255,1000,0); //dzwiek oddajacy klikniecie
gra=1;
}
}

if ( kolizja(200,100,nowagra->w,nowagra->h,mouse_x,mouse_y,kursor->w,kursor->h) ) // nowa gra
{
draw_sprite(bufor, ramka, 191,91);
if (mouse_b==1)
{
play_sample(klik, 255,255,1000,0);
punktacja=0;//nadajemy zmiennym poczatkowe wartosci
zycia=100;
ammo_bazo=100;
ammo_machgun=40;
ammo_laser=0;
ammo_flame=0;
gra=1; //powrot do gry z poczatkowym ustawieniem zmiennych czyli nowa gra :)
}
}

if ( kolizja(200,300,pomoc->w,pomoc->h,mouse_x,mouse_y,kursor->w,kursor->h) ) //pomoc
{
draw_sprite(bufor, ramka, 191,291);
if (mouse_b==1)
{
play_sample(klik, 255,255,1000,0);
}
}

if ( kolizja(200,400,powrotdogry->w,powrotdogry->h,mouse_x,mouse_y,kursor->w,kursor->h) ) //wyjscie
{
draw_sprite(bufor, ramka, 191,391);
if (mouse_b==1)
{
play_sample(klik, 255,255,1000,0);
   gra=2; //jeżeli gra=2 to główna pętla gry zostaje zakończona i wychodzimy z gry
}
}

show_mouse(bufor);
}

W main wywołujemy ją:
// cos tam
while(gra!=2)
{
gmenu();

while(gra==1)
{
while( ( speed > 0) && ( zycia>0 && punktacja<992) )
{
//kod gry
   }
blit( bufor, screen, 0,0,0,0, 800,600); // w grze wszystko rysujemy na buforze, po pełnym obiegu pętli wyświetlamy na screen
   }
blit( bufor, screen, 0,0,0,0, 800,600); //wyświetlamy menu gry
}

oto screen menu: (tło jest tymczasowe dałem tymczasowe aby nie było szarego ekranu)
narazie działa nowa gra, powrót do gry i wyjście. W porownaniu do wersji demo dodane nowe ruchy wgoga v_hard Oczywiście dodaję cały kod i wszystkie pliki potrzebne do uruchomienia gry(ver.1.06)

Menu w grze (prototyp)

2010-10-29T13:35:00.005+02:00

Z braku czasu (CCNA i studia) przez ostatnie 13 dni nic nie napisałem i zrobiłem pierwszą, 2-tygodniową przerwę w pracy nad projektem ... W ten weekend postaram się częściowo napisać menu do gry. Zastanawiam się tylko w czym to zrobić.

ALLEGRO: podstawić bitmapy, które będą reprezentowały "button", który będzie wywoływał jakąś czynność po kliknięciu myszą.

ALLEGRO GUI, którego praktycznie nie znam i na pierwszy rzut oka wydaje się torchę zagmatwane.

Menu będzie wyglądało miej więcej w ten sposób:

Oto ciekawy przypadek o szwindlu nigeryjskim :P (nie związane z projektem!!!)

Na allegro sprzedaję iPhona i dostaję masę propozycji kupna, tyle że w j.ang, co mnie zdziwiło bo do tej pory nigdy nie dostałem oferty kupna z innego kraju, a także allegro nie jest popularne za granicą, a szczególnie w Nigerii :P

Oczywiście na początku myślałem, że to ktoś z UK ale potem się okazało, że "dziwnym trafem" wszyscy adresaci mailów są z Nigerii to o mało nie spadłem z krzesła :)

Oczywiście sprawdziłem IP każdego maila i "odziwo" są identyczne. Spytałem wujka google co wie tym przypadku i naprawdę jest o tym wiele informacji... Chociażby ten artykuł

Piszę o tym bo może ktoś z Was w przyszłości otrzyma podobne propozycje kupna i nie da się oszukać.

ruchy Cwrog_vhard

2010-10-16T11:21:00.003+02:00

Miałem zacząć pracować nad menu gry lecz brakuje mi na to czasu... Zaczął się kurs CISCO CCNA1, a do tego studia i niestety zamiast czytać o allegro GUI czytam o sieciach :p
Ale do rzeczy. W tym poście przedstawię ruchy dla Cwrog_vhard. W poprzednim poście i demo jest klasa tymczasowa dla tego wroga. Nie będę wrzucał kodu bo narazie takowego nie ma :p
Jak przystało na poziom wroga very hard będzie trzelał 3 pociskami na raz, środkowy będzie leciał w dół, a 2 z brzegów na dół po skosie.

Oto rysunek obrazujący (czerwonymi strzałkami)ruchy i (fioletowymi)strzelanie Cwrog_vhard

Kod będzie podobny do Cboss1 czyli 3 tablice na pociski... Wrzucę tylko funkcję odpowiedzialną za strzelanie. Poruszanie jest podobna do pozostałych.

void strzelanie_wroga()
{
for(int i=0; i<3; i++)
{
if ( pozpocwro_y[i]>430)
{
if (czest_poc>=ogranicz_czest_poc)
{
pozpocwro_x[i]=pozwro_x-10;
pozpocwro_y[i]=pozwro_y+20;
pozpocwro_x[i+1]=pozwro_x+10;
pozpocwro_y[i+1]=pozwro_y+20;
pozpocwro_x[i+2]=pozwro_x+30;
pozpocwro_y[i+2]=pozwro_y+20;
czest_poc=0;
}
}
if (pozpocwro_y[i]>430)
{
pozpocwro_y[i]=800;
}
pozpocwro_y[i]=pozpocwro_y[i]+2;
pozpocwro_x[0]=pozpocwro_x[0]-1; // aby pocisk z lewej strony leciał w lewo
pozpocwro_x[2]=pozpocwro_x[2]+1; //aby pocisk z prawej strony leciał w prawo
czest_poc++;
}
}

Space destroyer -wersja DEMO

2010-10-13T11:49:00.001+02:00

Pora na wyczekiwaną wersję DEMO. W tym poście przedstawię tymczasowe bitmapy przedstawiające wrogów , bonusy i amunicję wypadającą z wrogów, "tymczasowe" bo niestety nie znalazłem bitamp w klimacie gry kosmicznej, które można wprawić w ruch. Może ktoś mi podeśle link :)

Oczywiście każdy z wrogów zależnie od jego poziomu ma coraz większą liczbę żyć, strzela innymi pociskami, które tracą coraz więcej żyć, z każdego wroga wypada inna amunicja. Bronie także mają coraz większą moc. W wersji demo jest 10 etapów i ostatni kończy się bossem.

A oto bitmapy przedtsawiające różne obiekty w grze:

WROGOWIE

Cwrog_easy

Cwrog_medium

Cwrog_hard

Cwrog_vhard - nie pisałem o ruchach dla tego rodzaju wroga, ma ruchy podobne do medium ale rusza się szybciej i strzela szybciej od innych.

Cboss1 - tutaj akurat znalazłem na innym blogu(open source tak jak mój blog) 4 bitmapy i jest mini animacja :P

BONUSY

apteczka z życiami(wypada rzadko):

szybkie chodzenie(dopalacz :P)

AMUNICJA

bazooka:

karabin maszynowy:

laser:

miotacz ognia:

Nie będę przedstawiał posisków wystrzelanych przez wrogów i dźwięków. Jak ściągniecie to zobaczycie.

Oto elementy, które zrobię w najbliższym czasie.
- W grze nie ma jeszcze menu(przyjdzie na to czas ;p i zostanie zrobione w Allegro GUI)
- jakieś ładne fonty
- bitmapy, dzięki którym można uzyskać animację
- animację wybuchu po zestrzeleniu wroga
- koniec gry (po zniszczeniu [i przekroczeniu 10 etapu w demo] robota przez wrogów gra się wyłącza :P)

Kilka osób zagrało w wersję demo i mówią, że jest za trudna, doradzili mi żebym naniósłpewne poprawki co do kodu i samej rozgrywki w grze.
I mam prośbę do WAS o wypowiedzi czy podoba się Wam gra, co byście zmienili w kodzie i w samej grze. Każda wiadomość od Was będzie dla mnie pomocna :)

Kod, pliki potrzebne do uruchomienie gry i .dll spakowane i do ściągnięcia pod nazwą space destroyer wersja demo na google.code http://code.google.com/p/spacedestroyer/downloads/list

EDIT: będę konsekwentny i wrzucam screena z gry

Kod w main(), ostatni post przed wersją demo

2010-10-08T20:04:00.001+02:00

Oto moje wypociny zawarte w funkcji odpowiadającej za wroga easy.
W funkcji jest wyswietlenie wroga i jego pocisku, a także wszystkie możliwe kolizje.
Kolizja pociskow z każdej broni z wrogiem, kolizja pocisku wroga z robocikiem,
kolizja robocika z wrogiem i kolizja pocisku flamethrower z pociskiem wroga czyli możliwość obrony dla robota przed pociskami.
Przy każdym wywołaniu kolizji "coś się dzieje". Albo uruchamiamy funkcje odpowiedzialne za LOSOWE wypadanie bonusów, tracimy życia, wypada amunicja, zabijamy wroga

Użyłem Cwrog_easy enemy_e[5]; czyli stowrzyłem 6-elementową tablicę obietków klasy enemy_easy. 6 wrogow tej klasy wystarczy. Liczba wrogich statków uzależniona jest od void etapy() (poprzednie posty).
Napisałem Ostatni post przed wersją demo bo miało być obiektowo, a nie jest do końca. Zastanawiam się aby te kolizje jeszcze upchnąć do klas bo za dużo tu tego ...
Oto kod:

for(int e=0; e<max_easy; e++) //easy
{
if( (frame>=0) && (frame<=80) )
{
draw_sprite(bufor, wrog, enemy_e[e].pozwro_x, enemy_e [e].pozwro_y);
draw_sprite(bufor, pociskwroga, enemy_e[e].pozpocwro_x, enemy_e[e].pozpocwro_y);
}

if( kolizja(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y,wrog->w,wrog->h,strzal_bazooka.pozpoc_x,strzal_bazooka.pozpoc_y,pocisk->w,pocisk->h) )
{
enemy_e[e].odejm_zycia(2);
strzal_bazooka.pozpoc_y=-40;
bazooka_dodaj.bazooka(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y);
zycie_dodaj.aid();
przyspiesz_dodaj.przyspiesz();
}

else if( kolizja(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y,wrog->w,wrog->h,strzal_machinegun.pozpoc_x,strzal_machinegun.pozpoc_y,mach_gun->w,mach_gun->h) )
{
enemy_e[e].odejm_zycia(1);
strzal_machinegun.pozpoc_y=-30;
bazooka_dodaj.bazooka(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y);
zycie_dodaj.aid();
przyspiesz_dodaj.przyspiesz();
}

else if( kolizja(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y,wrog->w,wrog->h,strzal_laser.pozpoc_x,strzal_laser.pozpoc_y,laser->w,laser->h) )
{
enemy_e[e].odejm_zycia(3);
bazooka_dodaj.bazooka(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y);
zycie_dodaj.aid();
przyspiesz_dodaj.przyspiesz();
}

else if( kolizja(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y,wrog->w,wrog->h,strzal_flamethrower.pozpoc_x,strzal_flamethrower.pozpoc_y,flame->w,flame->h) )
{
enemy_e[e].odejm_zycia(5);
enemy_e[e].czest_poc=enemy_e[e].czest_poc-20;
strzal_flamethrower.pozpoc_y=-30;
bazooka_dodaj.bazooka(enemy_e[e].pozwro_x,enemy_e[e].pozwro_y);
zycie_dodaj.aid();
przyspiesz_dodaj.przyspiesz();
}
//kolizja pocisku enemy_e z ludkiem
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy_e[e].pozpocwro_x,enemy_e[e].pozpocwro_y,pociskwroga->w,pociskwroga->h) )
{
enemy_e[e].pozpocwro_x=0;
enemy_e[e].pozpocwro_y=700;
zycia=zycia-2;
}
//kolizja enemy_e z ludkiem
if( kolizja(ludek.pozs_x,ludek.pozs_y,statek->w,statek->h,enemy_e[e].pozwro_x,enemy_e[e].pozwro_y,wrog->w,wrog->h) )
{
enemy_e[e].pozwro_x=rand()%550;
enemy_e[e].pozwro_y=0;
zycia=zycia-4;
}

//kolizja pocisku enemy_e z pociskiem ludka
if( kolizja (strzal_flamethrower.pozpoc_x,strzal_flamethrower.pozpoc_y, flame->w, flame->h,enemy_e[e].pozpocwro_x,enemy_e[e].pozpocwro_y,pociskwroga->w,pociskwroga->h) )
{
enemy_e[e].pozpocwro_y=700;
}
enemy_e[e].strzelanie_wroga();
enemy_e[e].poruszanie_wroga();
}

Jestem przygotowany na krytykę i otwarty na pomysły co do zmian w kodzie :)
Pewnie trochę potrwa (w weekend studia) zanim zrobię kolizje dla innych wrogów ale przy następnym poście dodam kod w code.google.

Ruchome tło w grze

2010-10-05T12:26:00.000+02:00

Krótki post na temat mechanizmu poruszania tłem. Jak na początku napisałem ma to być gra, w której akcja obywa się w kosmosie, więc trzeba pomyśleć na tłem do gry. Nie byłoby trudności z dodaniem bitmapy, która by się nie ruszała ale to by było pójście na łatwiznę... Myślałem trochę nad zrobieniem ruchomego tła i wymyśliłem taką funkcję.
Jest to funkcja składowa klasy Cmenu(odpowiedzialna za menu, interfejs gry).
Funkcja działa w taki sposób:
Po każdym obiegu pętli gry wycina "pasek" z góry ekranu, na jego miejsce przesuwa całą bitmapę czyli o 1 piksel do góry, po przesunięciu bitmapy o 1 piksel w górę zostaje nam pusty pasek u samego dołu i owa funkcja wstawia wycięty pasek na sam dół ekranu.

A oto rysunek pomocniczy, a zarazem skrót mojego kazania :P
S[rzałki obrazują ruch bitmapy. Wycinek o nr 1 wstawiamy na sam dół, i na miejsce 1 wskakuje 2. Po obiegu pętli owa 2 wskakuje na sam dół, a na jej miejsce wskoczy 3 itd.

I króciutka funkcja:

void Cmenu::wyswietl_tlo()
{
blit(tlo,bufor,0,0,0,-pos,tlo->w,tlo->h);
blit(tlo,bufor,0,0,0,tlo->h-pos,tlo->w,pos);

if(pos==tlo->h)
{
pos=0;
}
pos++;
}

Testowałem to i bardzo fajnie wyszło ale niestety nie mam dobrej tekstury (obrazy wziąłem z google) i nie ma dobrego przejścia tzn widać końce bitmapy po podczas przesuwania. Jeżeli chodzi o mnie to ideą pisania gry jest nauka programowania, a nie ładna grafika, choć jeżeli znacie jakieś stronki z teksturami to zapodajcie :)

Etapy w grze

2010-10-03T13:14:00.001+02:00

Przyszedł czas na rozmyślenia jak zrobić w grze etapy. Myślałem nad tym trochę i wymyśliłem taką funkcję, która przyjmuje globalną zmienną zawierającą liczbę punktów zdobytych przez gracza. Wcześniej w jakimś poście wspomiałem o zmiennej punktacja i teraz o niej pomówimy. Liczba punktów będzie odpowiadała poszczególnym etapom.
Gra oczywiście zaczyna się z 0-wym dorobkiem punktów. Po zestrzeleniu "odpowiedniego" wroga dostaniemy "odpowiednią" ilość punktów zależnie od poziomu trudności wroga.
np: Cwrog_easy
if(zycia<=0)
{
punktacja++;
}
dostajemy 1 pkt

Cwrog_medium
if(zycia<=0)
{
punktacja=punktacja+2;
}
dostajemy 2 pkt
itd... Jak wyjdzie demo to wtedy zmodyfikuje się odpowiednie wartości co do życ wroga i punktacji za zabicie go.

Teraz opiszę funkcję etapy.
Pierwszej części nie będę opisywał bo wszystko widać...
Do switcha przesyłamy argument etap zawierający liczbę, która jest równa etapowi. i w case przypisujemy do zmiennych wartości np:

case 1:
max_easy=3; - tylu wrogów Cwrog_easy wystąpi w 1 etapie czyli 3
max_medium=0; - tylu wrogów Cwrog_medium wystąpi w 1 etapie czyli 0
max_hard=0; - tylu wrogów Cwrog_hard wystąpi w 1 etapie
max_vhard=0; - tylu wrogów Cwrog_vhard wystąpi w 1 etapie (narazie go nie ma ale trwwaja prace nad wymyśleniem ruchów dla niego)
max_b1=0; - tylu bossów Cboss1 wystąpi w 1 etapie

void etapy(int pkt)
{
if(pkt<=35) { etap=1; }
else if( (pkt>36) && (pkt<=60) ) { etap=2; }
else if( (pkt>61) && (pkt<=120) ) { etap=3; }
else if( (pkt>121) && (pkt<180) ) { etap=4; }
else if( (pkt>181) && (pkt<280) ) { etap=5; }
else if( (pkt>281) && (pkt<400) ) { etap=6; }
else if( (pkt>441) && (pkt<590) ) { etap=7; }
else if( (pkt>591) && (pkt<740) ) { etap=8; }
else if( (pkt>741) && (pkt<890) ) { etap=9; }
else if( (pkt>891) && (pkt<991) ) { etap=10; }
else if( (pkt>991) && (pkt<1100) ) { etap=11; }

switch(etap)
{

case 1:
max_easy=3;
max_medium=0;
max_hard=0;
max_vhard=0;
max_b1=0;
break;

case 2:
max_easy=1;
max_medium=2;
max_hard=0;
max_vhard=0;
max_b1=0;
break;

case 3:
max_easy=1;
max_medium=1;
max_hard=1;
max_vhard=0;
max_b1=0;
break;

case 4:
max_easy=2;
max_medium=1;
max_hard=1;
max_vhard=0;
max_b1=0;
break;

// itd

case 10:
max_easy=0;
max_medium=0;
max_hard=0;
max_vhard=0;
max_b1=1;
break;

}
}

Od jakiegoś czasu nie piszę o kodzie w main() bo przyjdzie na to czas, więc pokażę co zrobimy z taką zmienną w głównej pętli gry:
for(int e=0; e<max_easy; e++)
{}
for(int m=0; m<max_medium; m++)
{}
Taka pętla wykona się tyle razy ilu mamy wrogów w poszczególnym etapie (funkcja etapy i instrukcja case). Zawarte w niej będą funkcje sprawdzające kolizję z różnymi obiektami i inne ciekawe rzeczy ale o tym w następnym poście :) Myślę, że w ciągu 2 tyg powstanie "wczesna" wersja beta
P.S. Jeżeli znacie strony z bitmapami o tematyce kosmicznej to dajcie link, bardzo mi pomożecie :)

Bonusy cd

2010-09-30T15:26:00.000+02:00

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;
}
}
};

Bonusy w grze

2010-09-28T11:16:00.001+02:00

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 :)

klasa wroga Boss1

2010-09-22T21:01:00.002+02:00

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

Klasa wroga HARD

2010-09-19T12:29:00.001+02:00

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?

Klasa wroga MEDIUM

2010-09-16T11:49:00.004+02:00

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 :)

Klasa bazowa wroga pierwsza wzmianka o dziedziczeniu

2010-09-13T21:05:00.005+02:00

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 :)

Klasa bazowa wroga

2010-09-09T12:54:00.000+02:00

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

Bronie w grze- poziom amunicji

2010-09-05T14:05:00.000+02:00

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:

Bronie w grze Cz.2

2010-09-02T18:07:00.000+02:00

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.

Bronie w grze Cz.1

2010-08-29T11:55:00.000+02:00

W poprzednim poście powierzchownie opisałem 4 rodzaje broni jakimi nasz robocik będzie dysponował. Narazie będzie miał niewyczerpalną amunicję ale z czasem się to zmieni...
Odrazu napiszę, że kody żródłowe z poprzednich wersji troszeczkę się będą różniły od siebie, ponieważ jak zaznaczyłęm na początku uczę się obiektowości i cały czas przerabiam klasy dodając lub przenosząc pola i metody do innych powstających klas.
Kody nie różnią się od siebie diametralnie, lecz różnice są zauważalne. Jak ktoś(o ile komuś się zechce :P) będzie analizował kod i nie będzie czegoś rozumiał lub miał pytania proszę o pytanue w komentarzu pod danym postem to rozwieję wątpliwości :)
Myślałem jak by zrobićklasę odpowiadającą za bronie i wymyśliłem coś takiego:

class Cshots
{
public:
int pozpoc_x, pozpoc_y;

void strzelaniee(int, int);

Cshots::Cshots ()
{
pozpoc_x=0;
pozpoc_y=0;
}
};

void Cshots::strzelaniee(int pozx, int pozy)
{
pozpoc_x=pozx+15;
pozpoc_y=pozy-15;
}

Klasa sama w sobie nic nie robi ustawia tylko początkową pozycję pocisku (x i y) dopiero w main zabawa się zaczyna :P
Tworzymy sobie 4 obiekty użyję 4 różnych kolorów(każdy kolor odpowada za dany obiekt) bo trochę jest tego kodu w main()

Cshots strzal_bazooka;
Cshots strzal_machinegun;
Cshots strzal_laser;
Cshots strzal_flamethrower;

Teraz pokażę jak się będzie zmieniało w grze bronie.
Deklarujemy i definiujemy sobie zmienną: int bron=1;
Liczby od 1 do 4 będą odpowiadały za poszczególne bronie:

1-bazooka
2-karabin maszynowy
3-laser
4-miotacz ognia

I analogicznie na klawiaturze będziemy zmieniali bronie za pomocą klawiszy 1,2,3,4

if(key[KEY_1])
{
bron=1;
}

if(key[KEY_2])
{
bron=2;
}

if(key[KEY_3])
{
bron=3;
}

if(key[KEY_4])
{
bron=4;
}
_________________________________________________________________

Strzelać będziemy spacją

if( key[KEY_SPACE])
{

if(bron==1)
{
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)
{
   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);
}
}

if(bron==3)
{
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);
}
}

if(bron==4)
{
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);
   }
}
}

Wytłumaczę tą część kodu. Strzelanie w grze będzie wyglądało w następujący sposób: po wybraniu broni (1,2,3,4) i naciśnięciu spacji z robocika wyleci pocisk z broni, którą mamy aktywowaną. wystrzelenie pocisku będzie możliwe jeżeli jego pozycja y będzie mniejsza od 0 lub równa 0 tzn jeżeli opuści ekran gry, lub jeżeli trafimy w jakiś cel. Na ekranie będzie mógł się znajdować tylko 1 pocisk z poszczególnej broni, aby wystrzelić kolejny pocisk musi wyjść poza ekran lub musimy w coś trafić...
Widzimy także np:
play_sample(flamethrow, 200,200,1000,0);
tutaj odtwarzamy jakis dźwięk akurat dobrałem takie, które przypominają wystrzały z tych broni.

Omówię jeszcze funkcję z klasy
void Cshots::strzelaniee(int pozx, int pozy)
{
pozpoc_x=pozx+15;
pozpoc_y=pozy-15;
}

Do tej funkcji przesyłamy 2 argumenty pozycję x i y robocika aby pocisk wystrzelony z robocika wyleciał nie ze środka robocika ale z jego "głowy" ładniej to wygląda :P
Tak więc tą funkcją nadajemy pozycję x i y pocisku troszeczkę zmodyfikowaną z pozycji robocika.
i wywołujemy tak:

strzal_flamethrower.strzelaniee(ludek.pozs_x, ludek.pozs_y );
_________________________________________________________________

Dobrze by było gdybyśmy wiedzieli którą broń mamy aktywowaną... Proponuję wrócić do poprzednich 2 postów, tam jest klasa Cmenu i i bitmapy, które teraz wykorzystam.
W prawym dolnym rogu będziemy wyświetlali naszą aktualną broń

if(bron==1)
{
masked_blit( menu_bazooka, bufor, 0,0, 674, 515, menu_bazooka->w, menu_bazooka->h);
}

else if(bron==2)
{
masked_blit( menu_machinegun, bufor, 0,0, 674, 515, menu_machinegun->w, menu_machinegun->h);
}

else if(bron==3)
{
masked_blit( menu_laser, bufor, 0,0, 665, 515, menu_laser->w, menu_laser->h);
}

else if(bron==4)
{
masked_blit( menu_flamethrower, bufor, 0,0, 665, 515, menu_flamethrower->w, menu_flamethrower->h);
}

_________________________________________________________________
musimy jeszcze wyświetlić nasze pociski:

if( (frame>=0) && (frame<=80) )
{
draw_sprite(bufor, mach_gun, strzal_machinegun.pozpoc_x, strzal_machinegun.pozpoc_y);
}

if( (frame>=0) && (frame<=80) )
{
draw_sprite(bufor, pocisk, strzal_bazooka.pozpoc_x, strzal_bazooka.pozpoc_y);
}

if( (frame>=0) && (frame<=80) )
{
draw_sprite(bufor, laser, strzal_laser.pozpoc_x, strzal_laser.pozpoc_y);
}

if( (frame>=0) && (frame<=80) )
{
draw_sprite(bufor, flame, strzal_flamethrower.pozpoc_x, strzal_flamethrower.pozpoc_y);
}

_________________________________________________________________
i wprawić nasze pociski w ruch tj. po każdym obiegu głównej pętli while( !key[KEY_ESC]) zmieniamy współrzędną y o pewną wartość. Im większa wartość tym szybciej będzie leciał pocisk. Uważam, że te wartości jak narazie są odpowiedznie, może z biegiem czasu ulegną zmianie :P

strzal_flamethrower.pozpoc_y=strzal_flamethrower.pozpoc_y-10;
strzal_laser.pozpoc_y=strzal_laser.pozpoc_y-30;
strzal_machinegun.pozpoc_y=strzal_machinegun.pozpoc_y-40;
strzal_bazooka.pozpoc_y=strzal_bazooka.pozpoc_y-5;

W następnym poście zrobię kolizję. Do pobrania kod wraz z plikami potrzebnymi do uruchomienia gry ver.1.02.
Jeżeli macie pytania, propozycje to piszcie w komentarzach, napewno odpowiem :)
Gra na tym etapie wygląda następująco:

wstęp do broni w grze

2010-08-26T15:39:00.000+02:00

Napiszę teraz dlaczego w prawie każdej bitmapie występuje kolor różowy.
Kolor różowy kod RGB(255,0,255) w allegro jest pomijany, tzn jeżeli mamy 2 obrazki:

1. z białym tłem, jeżeli wyświetlimy tą bitmapę w programie to kolor biały(otaczające tło) także zostanie wyświetlony.

2. z różowym tłem, jeżeli wyświetlimy tą bitmapę w programie to zostanie wyświetlona tylko bazooka, bez otaczającego ją różowego tła ponieważ kolor różowy kod RGB(255,0,255) jest pomijany.

Na początku bloga napisałem, że będą 4 rodzaje broni: bazooka, karabin maszynowy, laser i miotacz ognia. oto one:

1) bazooka:

Pocisk wystrzelony z tej broni będzie wyglądał tak:

2) karabin maszynowy:

Pocisk wystrzelony z tej broni będzie wyglądał tak (zwykła kropka w paincie :P):

3) laser:

Pocisk wystrzelony z tej broni będzie wyglądał tak (zwykła kreska w paincie :P):

4) miotacz ognia:

Pocisk wystrzelony z tej broni będzie wyglądał tak :

Oczywiście przy wystrzale z każdej broni będzie odtwarzany dźwięk, każda broń będzie inaczej się zachowywała, traciła mniej lub więcej żyć, a także planuję aby miotacz ognia pozwalał na niszczenie wrogich pocisków... Za jakiś czas wrzucę kod wraz z wszystkimi potrzebnymi plikami i jak zawsze napiszę nowego posta wyjaśniającego wybrane fragmenty kodu.