allegro - inicjalizacja tablicy obiektów, a dalej powstaje jeden obiekt na ekranie

Mam pewien problem z moim programem w C++, przy użyciu biblioteki allegro. Zrobiłem już kilka klas oraz dodałem klasę PociskWroga, której obiekt jest inicjalizowany(w main.cpp)tablicą obiektów i chciałem ,żeby te obiekty były "malowane" na mojej wersji bitmapy, jednakże "namalowany" zostaje tylko jeden obiekt i do momentu, aż on nie "zginie" żaden inny nie zostanie "namalowany". Podejrzewam, że to może być głupi problem, jedn prosiłbym o pomoc lub podpowiedź, abym się dowiedział co i jak. Wiem, że kod jest trochę długi, ale może znajdzie się ktoś pomocny :)

main.cpp

#include<allegro5\allegro5.h>
#include<allegro5\allegro_font.h>
#include<allegro5\allegro_ttf.h>
#include<allegro5\allegro_audio.h>
#include<allegro5\allegro_acodec.h>
#include<iostream>

#include "kometa.h"
#include "statek.h"
#include "pocisk.h"
#include "eksplozja.h"
#include "Cbitmap.h"
#include "wrog.h"
#include "dodatki.h"
#include "PociskWroga.h"
 
//==============================================
//ZMIENNE GLOBALNE
//==============================================
enum KEYS{UP, DOWN, LEFT, RIGHT, SPACE};
bool keys[5] = {false, false, false, false, false};
enum STAN{MENU, GRANIE, PRZEGRANA};
ALLEGRO_SAMPLE_INSTANCE *songInstance = NULL;

//==============================================
//DEFINICJA FUNKCJI
//==============================================
void ZmienStan(int &stan, int nowy_stan);
 
int main()
{
	//==============================================
	//ZMIENNE ALLEGRO
	//==============================================
	ALLEGRO_DISPLAY *display = NULL;
	ALLEGRO_EVENT_QUEUE *event_queue = NULL;
	ALLEGRO_TIMER *timer = NULL;
	ALLEGRO_FONT *font18 = NULL;
	ALLEGRO_BITMAP *shipImage = NULL;
	ALLEGRO_BITMAP *kometaImage = NULL;
	ALLEGRO_BITMAP *eksplozjaImage = NULL;
	ALLEGRO_BITMAP *bgImage = NULL;
	ALLEGRO_BITMAP *mgImage = NULL;
	ALLEGRO_BITMAP *fgImage = NULL;
	ALLEGRO_BITMAP *wrogImage = NULL;
	ALLEGRO_BITMAP *dodatekImage = NULL;
	ALLEGRO_SAMPLE *song = NULL;
 
	//==============================================
	//ZMIENNE PROJEKTOWE
	//==============================================
	bool done = false;
	bool redraw = true;
	const int FPS = 60;
	int stan = -1;
 
	//==============================================
	//FUNKCJE INICJALIZACYJNE ALLEGRO
	//==============================================
	if(!al_init()) //inicjalizacja allegro
	{
		return -1;
	}
 
	display = al_create_display(WIDTH, HEIGHT); //stworzenie objektu wyswiettlającego
 
	if(!display) //testowanie obiektu wyświetlającego
	{
		return -1;
	}
 
	//==============================================
	//ADDON INSTALL ?
	//==============================================
	al_init_primitives_addon();
	al_install_keyboard();
	al_init_font_addon();
	al_init_ttf_addon();
	al_init_image_addon();
	al_install_audio();
	al_init_acodec_addon();

	//==============================================
	//INICJALIZACJA ZMIENNYCH
	//==============================================
	font18 = al_load_font("arial.ttf", 18, 0);
	al_reserve_samples(10);

	shipImage = al_load_bitmap("statek.png");
	al_convert_mask_to_alpha(shipImage, al_map_rgb(255, 0, 255));

	kometaImage = al_load_bitmap("kometa.png");
	
	eksplozjaImage = al_load_bitmap("eksplozja.png");

	bgImage = al_load_bitmap("starBG.png");
	mgImage = al_load_bitmap("starMG.png");
	fgImage = al_load_bitmap("starFG.png");

	wrogImage = al_load_bitmap("wrog.png");
	al_convert_mask_to_alpha(wrogImage, al_map_rgb(255, 0, 255));

	dodatekImage = al_load_bitmap("dodatek.png");

	song = al_load_sample("hdab.ogg");

	songInstance = al_create_sample_instance(song);
	al_set_sample_instance_playmode(songInstance, ALLEGRO_PLAYMODE_LOOP);
	al_attach_sample_instance_to_mixer(songInstance, al_get_default_mixer());

	ZmienStan(stan, MENU);
	
 	srand(time(NULL));
	//==============================================
	//ZMIENNE OBIEKTOWE
	//==============================================
	statek ship(shipImage);        
	pocisk bullets[NUM_BULLETS];
	kometa comets[NUM_COMETS];
	eksplozja eksplozje[NUM_EKSPLOSIONS];
	Cbitmap *bg = new Cbitmap;
	bg->InitBitmap(0, 0, 1, 0, -1, 1, 800, 600, bgImage);
	Cbitmap *mg = new Cbitmap;
	mg->InitBitmap(0, 0, 3, 0, -1, 1, 1600, 600, mgImage);
	Cbitmap *fg = new Cbitmap;
	fg->InitBitmap(0, 0, 5, 0, -1, 1, 800, 600, fgImage);
	wrog *wrog1 = new wrog;
	wrog1->InitWrog(3, wrogImage);
	dodatki *dod = new dodatki;
	dod->UstawObraz(dodatekImage);
	PociskWroga *w_pocisk = new PociskWroga[NUM_ENEMY_BULLETS];
	for (int i = 0; i < NUM_ENEMY_BULLETS; i++)
	{
		w_pocisk[i].InitPociskWrog(wrog1, w_pocisk, NUM_ENEMY_BULLETS);
	}


	for (int i = 0; i < NUM_COMETS; i++)
	{
		comets[i].ustawObraz(kometaImage);
	}

	for (int i = 0; i < NUM_EKSPLOSIONS; i++)
	{
		eksplozje[i].ustawObraz(eksplozjaImage);
	}

	//==============================================
	//INICJALIZACJA TIMERA I START
	//==============================================
	event_queue = al_create_event_queue();
	timer = al_create_timer(1.0 / FPS);

	al_register_event_source(event_queue, al_get_keyboard_event_source());
	al_register_event_source(event_queue, al_get_timer_event_source(timer));
	al_register_event_source(event_queue, al_get_display_event_source(display));

	al_start_timer(timer);
	int j = 0;
	while (!done)
	{
		ALLEGRO_EVENT ev;
		al_wait_for_event(event_queue, &ev);
 
		//==============================================
		//GAME UPDATE
		//==============================================
		if (ev.type == ALLEGRO_EVENT_TIMER)
		{
			redraw = true;
			if (keys[UP])
			{
				ship.moveShipUP();
			}
			else if (keys[DOWN])
			{
				ship.moveShipDOWN();
			}
			else
			{
				ship.resetShipAnimation(ship, 1);
			}
			if (keys[LEFT])
			{
				ship.moveShipLEFT();
			}
			else if (keys[RIGHT])
			{
				ship.moveShipRIGHT();
			}
			else
			{
				ship.resetShipAnimation(ship, 2);
			}

			if (stan == MENU)
			{
			}
			else if (stan == GRANIE)
			{
				bg->UpdateBackground();
				mg->UpdateBackground();
				fg->UpdateBackground();
				wrog1->UpdateWrog();
				w_pocisk->UpdatePociskuWrog(w_pocisk, NUM_ENEMY_BULLETS);
				wrog1->ZmienLive();
				w_pocisk->OdpalPociskWroga(wrog1, w_pocisk, NUM_ENEMY_BULLETS);
				dod->UpdateDodatku();
				eksplozje->updateEksplozji(eksplozje, NUM_EKSPLOSIONS);
				bullets->updatePocisk(bullets, NUM_BULLETS);
				w_pocisk->UpdatePociskuWrog(w_pocisk, NUM_ENEMY_BULLETS);
				comets->startKomety(comets, NUM_COMETS);
				comets->updateKomety(comets, NUM_COMETS);
				dod->KolizjaDodatku(ship);
				wrog1->KolizjaWroga(ship, eksplozje, NUM_EKSPLOSIONS);
				w_pocisk->KolizjaPociskuWroga(ship, eksplozje, NUM_EKSPLOSIONS, w_pocisk, NUM_ENEMY_BULLETS);
				bullets->kolizjaPocisku(bullets, NUM_BULLETS, comets, NUM_COMETS, ship, eksplozje, NUM_EKSPLOSIONS, wrog1, dod);
				comets->kolizjaKomety(comets, NUM_COMETS, ship, eksplozje, NUM_EKSPLOSIONS);
				if (ship.zwroc_lives() <=0)
				{
					ZmienStan(stan, PRZEGRANA);
				}
			}
			else if (stan == PRZEGRANA)
			{
			}
		}
		else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
		{
			done = true;
		}
		//==============================================
		//INPUT
		//==============================================
		else if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
		{
			switch (ev.keyboard.keycode)
			{
			case ALLEGRO_KEY_ESCAPE:
				done = true;
				break;
			case ALLEGRO_KEY_UP:
				keys[UP] = true;
				break;
			case ALLEGRO_KEY_DOWN:
				keys[DOWN] = true;
				break;
			case ALLEGRO_KEY_LEFT:
				keys[LEFT] = true;
				break;
			case ALLEGRO_KEY_RIGHT:
				keys[RIGHT] = true;
				break;
			case ALLEGRO_KEY_SPACE:
				keys[SPACE] = true;
				if (stan == MENU)
				{
					ZmienStan(stan, GRANIE);
				}
				else if (stan == GRANIE)
				{
					bullets->odpalPocisk(bullets, NUM_BULLETS, ship);
				}
				else if (stan == PRZEGRANA)
				{
					ZmienStan(stan, GRANIE);
					ship.ResetujZycia(ship);
					bullets->ResetujPocisk();
					comets->ResetujKomete(comets, NUM_COMETS);
					eksplozje->ResetujEksplozje(eksplozje, NUM_EKSPLOSIONS);
					wrog1->ResetWrog();
					w_pocisk->ResetPociskWroga(w_pocisk, NUM_ENEMY_BULLETS);
					dod->ResetujDodatek();
				}
				break;
			}
		}
		else if (ev.type == ALLEGRO_EVENT_KEY_UP)
		{
			switch (ev.keyboard.keycode)
			{
			case ALLEGRO_KEY_ESCAPE:
				done = true;
				break;
			case ALLEGRO_KEY_UP:
				keys[UP] = false;
				break;
			case ALLEGRO_KEY_DOWN:
				keys[DOWN] = false;
				break;
			case ALLEGRO_KEY_LEFT:
				keys[LEFT] = false;
				break;
			case ALLEGRO_KEY_RIGHT:
				keys[RIGHT] = false;
				break;
			case ALLEGRO_KEY_SPACE:
				keys[SPACE] = false;
				break;
			}
		}
		//==============================================
		//REDRAW
		//==============================================
		if (redraw && al_is_event_queue_empty(event_queue))
		{
			redraw = false;
 
			if (stan == MENU)
			{
			}
			else if (stan == GRANIE)
			{
				bg->RysujBackground();
				mg->RysujBackground();
				fg->RysujBackground();
				ship.drawShip();
				wrog1->RysujWrog();
				w_pocisk->RysujPociskWroga(w_pocisk, NUM_ENEMY_BULLETS);
				dod->RysujDodatek();
				bullets->rysujPocisk(bullets, NUM_BULLETS);
				comets->rysujKomete(comets, NUM_COMETS);
				eksplozje->rysujEksplozje(eksplozje, NUM_EKSPLOSIONS);

				if (ship.zwroc_wynik() == 1)
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 5, 5, 0, "Gracz posiada %i zycia. Zniszczyles %i komete oraz", ship.zwroc_lives(), ship.zwroc_wynik());
				}
				else if (ship.zwroc_wynik() > 1 && ship.zwroc_wynik() < 5)
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 5, 5, 0, "Gracz posiada %i zycia. Zniszczyles %i komety oraz", ship.zwroc_lives(), ship.zwroc_wynik());
				}
				else
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 5, 5, 0, "Gracz posiada %i zycia. Zniszczyles %i komet oraz", ship.zwroc_lives(), ship.zwroc_wynik());
				}

				if (ship.zwrocWynik2() == 1)
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 400, 5, 0, "%i statek", ship.zwrocWynik2());
				}
				else if (ship.zwrocWynik2() > 1 && ship.zwrocWynik2() < 5)
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 400, 5, 0, "%i statki", ship.zwrocWynik2());
				}
				else
				{
					al_draw_textf(font18, al_map_rgb(255, 0, 255), 400, 5, 0, "%i statkow", ship.zwrocWynik2());
				}
			}
			else if (stan == PRZEGRANA)
			{
				al_draw_textf(font18, al_map_rgb(0, 255, 255), WIDTH / 2, HEIGHT / 2, ALLEGRO_ALIGN_CENTRE, "KONIEC GRY! WYNIK KONCZOWY: %i", ship.zwroc_wynik());
			}
 
			al_flip_display();
			al_clear_to_color(al_map_rgb(0, 0, 0));
		}
	}

	delete bg;
	delete mg;
	delete fg;
	delete wrog1;
	delete dod;
	delete [] w_pocisk;

	al_destroy_bitmap(dodatekImage); // zniszczeni obrazu dodatku
	al_destroy_bitmap(wrogImage); // zniszczeni obrazu wroga
	al_destroy_bitmap(bgImage); // zniszczeni obrazu bg
	al_destroy_bitmap(mgImage); // zniszczeni obrazu mg
	al_destroy_bitmap(fgImage); // zniszczeni obrazu fg
	al_destroy_sample(song); // zniszczenie muzyki "song"
	al_destroy_bitmap(shipImage); // znieszczenie obrazu statku
	al_destroy_bitmap(kometaImage); // zniszczenie obrazu komety
	al_destroy_bitmap(eksplozjaImage); // zniszczenie obrazu eksplozji
	al_destroy_event_queue(event_queue); // znieszczenie kolejki
	al_destroy_timer(timer); // znieszczenie timera
	al_destroy_display(display); //znieszczenie obiektu wyświetlającegoa
 
	return 0;
}

void ZmienStan(int &stan, int nowy_stan)
{
	if (stan == MENU)
	{
	}
	else if (stan == GRANIE)
	{
		al_stop_sample_instance(songInstance);
	}
	else if (stan == PRZEGRANA)
	{
	}

	stan = nowy_stan;

	if (stan == MENU)
	{
	}
	else if (stan == GRANIE)
	{
		al_play_sample_instance(songInstance);
	}
	else if (stan == PRZEGRANA)
	{
	}
} 

Klasa wrog.h

 #pragma once

#include "statek.h"
#include "eksplozja.h"
#include "dodatki.h"

class wrog
{
public:
	wrog(void);
	~wrog(void);
private:
	int ID;
	int x;
	int y;
	int bound_x;
	int bound_y;
	int lives;
	int speed;
	bool live;
	bool gora;
	bool dol;

	ALLEGRO_BITMAP *image;
public:
	void InitWrog(int w_lives, ALLEGRO_BITMAP *w_image);
	void RysujWrog(void);
	void KolizjaWroga(statek &ship, eksplozja eksplozja[], int eSize);
	void UpdateWrog(void);
	void ResetWrog(void);
	void ZmniejszZycie(statek &statek, dodatki *dodatek);
	void ZmienLive(void);
	bool ZwrocLive(void);
	int ZwrocX(void);
	int ZwrocY(void);
	int ZwrocBoundX(void);
	int ZwrocBoundY(void);
};

metody klasy wrog, wrog.cpp

#include "wrog.h"
#include "PociskWroga.h"

wrog::wrog(void)
{
}


wrog::~wrog(void)
{
}

void wrog::InitWrog(int w_lives, ALLEGRO_BITMAP *w_image)
{
	ID = ENEMY;
	x = WIDTH - 15;
    y = HEIGHT / 2;
    bound_x = 25;
    bound_y = 24;
    lives = w_lives;
    speed = 4;
	live = true;
	gora = true;
	dol = false;
 
    image = w_image;
}

void wrog::RysujWrog(void)
{
	if (live)
	{
		al_draw_bitmap(image, x - 25, y - 24, 0);
	}
}

void wrog::KolizjaWroga(statek &ship, eksplozja eksplozja[], int eSize)
{
	if (live)
		{
			if (x - bound_x < ship.zwroc_x() + ship.zwroc_boundx() &&
				x + bound_x > ship.zwroc_x() - ship.zwroc_boundx() &&
				y - bound_y < ship.zwroc_y() + ship.zwroc_boundy() &&
				y + bound_y > ship.zwroc_y() - ship.zwroc_boundy())
			{
				ship.zmniejsz_zycie();
				ResetWrog();
				eksplozja->startEksplozji(eksplozja, eSize, ship.zwroc_x(), ship.zwroc_y());
			}
			else if (x <= 0)
			{
				ResetWrog();
			}
		}
}

void wrog::UpdateWrog(void)
{
	if (live)
	{
		x -= speed * 0.2;
		if (gora)
		{
			y -= speed;
			if (y <= 10)
			{
				gora = false;
				dol = true;
			}
		}
		else
		{
			y += speed;
			if (y >= HEIGHT - 10)
			{
				gora = true;
				dol = false;
			}
		}
		if (x < 0)
		{

			live = false;
		}
	}
}

void wrog::ResetWrog(void)
{
	live = false;
	x = WIDTH - 15;
    y = HEIGHT / 2;
	lives = 3;
}

void wrog::ZmniejszZycie(statek &statek, dodatki *dodatek)
{
	lives--;
	if (lives <= 0)
	{
		statek.zwiekszWynik2();
		if (rand() % 2 == 0)
		{
			dodatek->StartDodatku(ZwrocX(), ZwrocY());
		}
		ResetWrog();
	}
}

void wrog::ZmienLive(void)
{
	if (!live)
	{
		if (rand() % 10 == 0)
		{
			live = true;
		}
	}
}

bool wrog::ZwrocLive(void)
{
	return live;
}

int wrog::ZwrocX(void)
{
	return x;
}

int wrog::ZwrocY(void)
{
	return y;
}

int wrog::ZwrocBoundX(void)
{
	return bound_x;
}

int wrog::ZwrocBoundY(void)
{
	return bound_y;
} 

klasa PociskWroga.h

#pragma once
#include <allegro5\allegro_primitives.h>
#include "wrog.h"

class PociskWroga
{
public:
	PociskWroga(void);
	~PociskWroga(void);
private:
	int fire_x;
	int fire_y;
	int fire_bound_x;
	int fire_bound_y;
	int fire_speed;
	bool fire_live;

	//ALLEGRO_BITMAP *image;
public:
	void InitPociskWrog(wrog *wrog1, PociskWroga pocisk[], int pSize);
	void UpdatePociskuWrog(PociskWroga pocisk[], int pSize);
	void OdpalPociskWroga(wrog *wrog1, PociskWroga pocisk[], int pSize);
	void KolizjaPociskuWroga(statek &ship, eksplozja eksplozja[], int eSize, PociskWroga pocisk[], int pSize);
	void RysujPociskWroga(PociskWroga pocisk[], int pSize);
	void ResetPociskWroga(PociskWroga pocisk[], int pSize);
	void ZmienZycie(void);
};

 

Metody klasy PociskWroga, PociskWroga.cpp

 #include "PociskWroga.h"


PociskWroga::PociskWroga(void)
{
}


PociskWroga::~PociskWroga(void)
{
}

void PociskWroga::InitPociskWrog(wrog *wrog1, PociskWroga pocisk[], int pSize)
{
	for (int i = 0; i < pSize; i++)
	{
		//pocisk[i].fire_x = wrog1->ZwrocX() - 17;
		//pocisk[i].fire_y = wrog1->ZwrocY();
		pocisk[i].fire_bound_x = 20;
		pocisk[i].fire_bound_y = 20;
		pocisk[i].fire_speed = 6;
		pocisk[i].fire_live = false;
	}
}

void PociskWroga::UpdatePociskuWrog(PociskWroga pocisk[], int pSize)
{
	for (int i = 0; i < pSize; i++)
	{
		if (pocisk[i].fire_live)
		{
			pocisk[i].fire_x -= pocisk[i].fire_speed;
			//RysujPociskWroga();
			if (pocisk[i].fire_x < 0)
			{
				//ZmienBool2();
				pocisk[i].fire_live = false;
			}
		}
	}
}

void PociskWroga::OdpalPociskWroga(wrog *wrog1, PociskWroga pocisk[], int pSize)
{
	for (int i = 0; i < pSize; i++)
	{
		if (wrog1->ZwrocLive() && pocisk[i].fire_live == false)
		{
			//if (rand() % 2 == 0)
			//{
			pocisk[i].fire_x = wrog1->ZwrocX() - 15;
			pocisk[i].fire_y = wrog1->ZwrocY();
			pocisk[i].fire_live = true;
			break;
			//}
		}
	}
}

void PociskWroga::KolizjaPociskuWroga(statek &ship, eksplozja eksplozja[], int eSize, PociskWroga pocisk[], int pSize)
{
	for (int i = 0; i <pSize; i++)
	{
		if (fire_live)
		{
			if (fire_x - fire_bound_x < ship.zwroc_x() + ship.zwroc_boundx() &&
				fire_x + fire_bound_x > ship.zwroc_x() - ship.zwroc_boundx() &&
				fire_y - fire_bound_y < ship.zwroc_y() + ship.zwroc_boundy() &&
				fire_y + fire_bound_y > ship.zwroc_y() - ship.zwroc_boundy())
			{
				ship.zmniejsz_zycie();
				ResetPociskWroga(pocisk, pSize);
				eksplozja->startEksplozji(eksplozja, eSize, ship.zwroc_x(), ship.zwroc_y());
			}
			else if (fire_x <= 10)
			{
				ResetPociskWroga(pocisk, pSize);
				//ship.zmniejsz_zycie();
			}
		}
	}
}

void PociskWroga::RysujPociskWroga(PociskWroga pocisk[], int pSize)
{
	if (fire_live)
	{
		al_draw_filled_circle(fire_x - 20, fire_y, 5, al_map_rgb(255, 111, 255));
	}
}

void PociskWroga::ResetPociskWroga(PociskWroga pocisk[], int pSize)
{
	for (int i = 0; i < pSize; i++)
	{
		pocisk[i].fire_live = false;
		pocisk[i].fire_x = 10;//x;
		pocisk[i].fire_y = 10;//y;
	}
}

void PociskWroga::ZmienZycie(void)
{
	if (fire_live)
	{
		fire_live = false;
	}
	else
	{
		fire_live = true;
	}
}

klasa statek.h

 #pragma once
#include<allegro5\allegro_primitives.h>
#include "globalne.h"

class statek
{
public:
	statek(ALLEGRO_BITMAP *simage);
	~statek(void);
private:
	int ID;
	int x;
	int y;
	int lives;
	int speed;
	int boundx;
	int boundy;
	int score;
	int score2;

	int max_frame;
	int cur_frame;
	int frame_count;
	int frame_delay;
	int frame_width;
	int frame_height;
	int animation_columns;
	int animation_direction;
	int animation_row;

	ALLEGRO_BITMAP *image;
public:
	void resetShipAnimation(statek &statek, int pozycja);
	void moveShipUP(void);
	void moveShipDOWN(void);
	void moveShipLEFT(void);
	void moveShipRIGHT(void);
	void drawShip(void);
	int zwroc_x(void);
	int zwroc_y(void);
	int zwroc_boundx(void);
	int zwroc_boundy(void);
	int zwroc_lives(void);
	int zwroc_wynik(void);
	int zwrocWynik2(void);
	void zwiekszWynik(void);
	void zwiekszWynik2(void);
	void zmniejsz_zycie(void);
	void ZwiekszZycie(void);
	void ResetujZycia(statek &statek);
};

metody klasy statek, statek.cpp

 #include "statek.h"


statek::statek(ALLEGRO_BITMAP *simage)
{
        x = 20;
        y = HEIGHT / 2;
        ID = PLAYER;
        lives = 10;
        speed = 7;
        boundx = 6;
        boundy = 7;
        score = 0;
		score2 = 0;
 
        max_frame = 3;
        cur_frame = 0;
        frame_count = 0;
        frame_delay = 50;
        frame_width = 46;
        frame_height = 41;
        animation_columns = 3;
        animation_direction = 1;
        animation_row = 1;
 
        image = simage;
}


statek::~statek(void)
{
}


void statek::resetShipAnimation(statek &statek, int pozycja)
{
	if (pozycja == 1)
	{
		animation_row = 1;
	}
	else
	{
		cur_frame = 0;
	}
}


void statek::moveShipUP(void)
{
	animation_row = 0;
	y -= speed;
	if (y < 0)
	{
		y = 0;
	}
}

void statek::moveShipDOWN(void)
{
	animation_row = 2;
	y += speed;
	if (y > 650)
	{
		y = 650;
	}
}

void statek::moveShipLEFT(void)
{
	cur_frame = 2;
	x -= speed;
	if (x < 12)
	{
		x = 12;
	}
}

void statek::moveShipRIGHT(void)
{
	cur_frame = 1;
	x += speed;
	if (x > 450)
	{
		x = 450;
	}
}

void statek::drawShip(void)
{
	int fx = (cur_frame % animation_columns) * frame_width;
	int fy = animation_row * frame_height;

	al_draw_bitmap_region(image, fx, fy, frame_width, frame_height, x - frame_width / 2, y - frame_height / 2, 0);
}

int statek::zwroc_x(void)
{
	return x;
}

int statek::zwroc_y(void)
{
	return y;
}

int statek::zwroc_boundx(void)
{
	return boundx;
}

int statek::zwroc_boundy(void)
{
	return boundy;
}

int statek::zwroc_lives(void)
{
	return lives;
}

int statek::zwroc_wynik(void)
{
	return score;
}

int statek::zwrocWynik2(void)
{
	return score2;
}

void statek::zwiekszWynik()
{
	score++;
}

void statek::zwiekszWynik2(void)
{
	score2++;
}

void statek::zmniejsz_zycie(void)
{
	lives--;
}

void statek::ZwiekszZycie(void)
{
	lives++;
}

void statek::ResetujZycia(statek &statek)
{
	x = 20;
    y = HEIGHT / 2;
    ID = PLAYER;
    lives = 10;
    speed = 7;
    boundx = 6;
    boundy = 7;
    score = 0;
}

klasa pocisk.h

 #pragma once
#include "kometa.h"
#include "eksplozja.h"
#include "wrog.h"

class pocisk
{
public:
	pocisk(void);
	~pocisk(void);
private:
	int ID;
	int x;
	int y;
	bool live;
	int speed;
public:
	void rysujPocisk(pocisk pocisk[], int size);
	void odpalPocisk(pocisk pociski[], int size, statek ship);
	void updatePocisk(pocisk pocisk[], int size);
	void kolizjaPocisku(pocisk pocisk[], int pSize, kometa kometa[], int kSize, statek &statek, eksplozja eksplozja[], int eSize, wrog *wrog1, dodatki *dod);
	void ResetujPocisk();
};

metody klasy pocisk, pocisk.cpp

#include "pocisk.h"
//#include "globalne.h"

pocisk::pocisk(void)
{
	ID = BULLET;
	speed = 10;
	live = false;
}


pocisk::~pocisk(void)
{
}

void pocisk::rysujPocisk(pocisk pocisk[], int size)
{
	for (int i = 0; i < size; i++)
	{
		if (pocisk[i].live)
		{
			al_draw_filled_circle(pocisk[i].x, pocisk[i].y, 2, al_map_rgb(255, 255, 255));
		}
	}
}

void pocisk::odpalPocisk(pocisk pociski[], int size, statek ship)
{
	for (int i = 0; i < size; i++)
	{
		if (!pociski[i].live)
		{
			pociski[i].x = ship.zwroc_x() + 17;
			pociski[i].y = ship.zwroc_y();
			pociski[i].live = true;
			break;
		}
	}
}

void pocisk::updatePocisk(pocisk pocisk[], int size)
{
	for (int i = 0; i < size; i++)
	{
		if (pocisk[i].live)
		{
			pocisk[i].x += pocisk[i].speed;
			if (pocisk[i].x > WIDTH)
			{
				pocisk[i].live = false;
			}
		}
	}
}

void pocisk::kolizjaPocisku(pocisk pocisk[], int pSize, kometa kometa[], int kSize, statek &statek, eksplozja eksplozja[], int eSize, wrog *wrog1, dodatki *dod)
{
	for (int i = 0; i < pSize; i++)
	{
		if (pocisk[i].live)
		{
			for (int j = 0; j < kSize; j++)
			{
				if (kometa[j].zwroc_live())
				{
					if (pocisk[i].x > (kometa[j].zwroc_x() - kometa[j].zwroc_boundx()) &&
						pocisk[i].x < (kometa[j].zwroc_x() + kometa[j].zwroc_boundx()) &&
						pocisk[i].y > (kometa[j].zwroc_y() - kometa[j].zwroc_boundy()) &&
						pocisk[i].y < (kometa[j].zwroc_y() + kometa[j].zwroc_boundy()))
					{
						pocisk[i].live = false;
						kometa[j].zmienBool();
						statek.zwiekszWynik();

						eksplozja->startEksplozji(eksplozja, eSize, pocisk[i].x, pocisk[i].y);
					}
				}
			}
			if (wrog1->ZwrocLive())
			{
				if (pocisk[i].x > (wrog1->ZwrocX() - wrog1->ZwrocBoundX()) &&
					pocisk[i].x < (wrog1->ZwrocX() + wrog1->ZwrocBoundX()) &&
					pocisk[i].y > (wrog1->ZwrocY() - wrog1->ZwrocBoundY()) &&
					pocisk[i].y < (wrog1->ZwrocY() + wrog1->ZwrocBoundY()))
				{
					pocisk[i].live = false;
					wrog1->ZmniejszZycie(statek, dod);
					eksplozja->startEksplozji(eksplozja, eSize, pocisk[i].x, pocisk[i].y);
				}
			}
		}
	}
}

void pocisk::ResetujPocisk()
{
	ID = BULLET;
	speed = 10;
	live = false;
} 

Są jeszcze klasy bitmapy, eksplozji, komety oraz dodatku, ale one w tym przypadku nie odgrywają żadnej roli. Jeżeli ktoś domyśli się, badź wie jaki błąd popełniłem, proszę o pomoc :)