Tworzę grę i przy dodaniu klasy bitmap oraz zainicjalizowaniu 3 bitmap, program sie uruchamia, ale w momencie, gdy gra powinna się zacząć wyskakuje okienko z błędem: "R6010, abort() has benn called
Na konsoli pojawia się komunikat: "Assertion failed: bitmap, file allegro-5.0.x\src\bitmap.c, line 315"
Wszystkie obrazki, które program wczytuje są w odpowiednim katalogu.
Oto kod źródłowy:
klasa Cbitmap.h
#pragma once
#include<allegro5\allegro_primitives.h>
class Cbitmap
{
public:
Cbitmap();
~Cbitmap(void);
private:
float x;
float y;
float velX;
float velY;
int dirX;
int dirY;
int width;
int height;
ALLEGRO_BITMAP *image;
public:
void InitBitmap(float x1, float y1, float velX1, float velY1, int dirX1, int dirY1, int width1, int height1, ALLEGRO_BITMAP *bimage);
void UpdateBackground();
void RysujBackground();
};
Funkcje klasy Cbitmap.cpp:
#include "Cbitmap.h"
#include "globalne.h"
Cbitmap::Cbitmap()
{
}
Cbitmap::~Cbitmap(void)
{
}
void Cbitmap::InitBitmap(float x1, float y1, float velX1, float velY1, int dirX1, int dirY1, int width1, int height1, ALLEGRO_BITMAP *bimage)
{
x = x1;
y = y1;
velX = velX1;
velY = velY1;
dirX = dirX1;
dirY = dirY1;
width = width1;
height = height1;
image = bimage;
}
void Cbitmap::UpdateBackground()
{
x += velX * dirX;
if (x + width <= 0)
{
x = 0;
}
}
void Cbitmap::RysujBackground()
{
al_draw_bitmap(image, x, y, 0);
if (x + width < WIDTH)
{
al_draw_bitmap(image, x + width, y, 0);
}
}
Funckja 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"
//==============================================
//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_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");
mgImage = al_load_bitmap("starMG");
fgImage = al_load_bitmap("starFG");
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, 0, 800, 600, bgImage);
Cbitmap *mg = new Cbitmap;
mg->InitBitmap(0, 0, 3, 0, -1, 0, 1600, 600, mgImage);
Cbitmap *fg = new Cbitmap;
fg->InitBitmap(0, 0, 5, 0, -1, 0, 800, 600, fgImage);
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);
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();
eksplozje->updateEksplozji(eksplozje, NUM_EKSPLOSIONS);
bullets->updatePocisk(bullets, NUM_BULLETS);
comets->startKomety(comets, NUM_COMETS);
comets->updateKomety(comets, NUM_COMETS);
bullets->kolizjaPocisku(bullets, NUM_BULLETS, comets, NUM_COMETS, ship, eksplozje, NUM_EKSPLOSIONS);
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);
}
/*j++;
if (j == 5)
{
j = 0;
}*/
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();
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 objekt", 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 objekty", 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 objektow", ship.zwroc_lives(), ship.zwroc_wynik());
}
}
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;
al_destroy_bitmap(bgImage);
al_destroy_bitmap(mgImage);
al_destroy_bitmap(fgImage);
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)
{
}
}
Oto kod pozostałych funkcji, jakby ktoś potrzebował:
globalne.h
#pragma once
const int WIDTH = 1250;
const int HEIGHT = 650;
const int NUM_BULLETS = 5;
const int NUM_COMETS = 10;
const int NUM_EKSPLOSIONS = 5;
enum IDS{PLAYER, BULLET, ENEMY};
eksplozja.h
#pragma once
#include<allegro5\allegro_primitives.h> // jezeli potrzebny dostep do statku lub bitmapy - usunac
class eksplozja
{
public:
eksplozja(void);
~eksplozja(void);
private:
int x;
int y;
bool live;
int max_frame;
int cur_frame;
int frame_count;
int frame_delay;
int frame_width;
int frame_height;
int animation_columns;
int animation_direction;
ALLEGRO_BITMAP *image;
public:
void ustawObraz(ALLEGRO_BITMAP *eimage);
void rysujEksplozje(eksplozja eksplozje[], int size);
void startEksplozji(eksplozja eksplozje[], int size, int x, int y);
void updateEksplozji(eksplozja eksplozje[], int size);
void ResetujEksplozje(eksplozja eskplozje[], int size);
};
eksplozja.cpp
#include "eksplozja.h"
eksplozja::eksplozja(void)
{
live = false;
max_frame = 31;
cur_frame = 0;
frame_count = 0;
frame_delay = 1;
frame_width = 128;
frame_height = 128;
animation_columns = 8;
animation_direction = 1;
}
eksplozja::~eksplozja(void)
{
}
void eksplozja::ustawObraz(ALLEGRO_BITMAP *eimage)
{
image = eimage;
}
void eksplozja::rysujEksplozje(eksplozja eksplozje[], int size)
{
for (int i = 0; i < size; i++)
{
if (eksplozje[i].live)
{
int fx = (eksplozje[i].cur_frame % eksplozje[i].animation_columns) * eksplozje[i].frame_width;
int fy = (eksplozje[i].cur_frame / eksplozje[i].animation_columns) * eksplozje[i].frame_height;
al_draw_bitmap_region(eksplozje[i].image, fx, fy, eksplozje[i].frame_width,
eksplozje[i].frame_height, eksplozje[i].x - eksplozje[i].frame_width / 2, eksplozje[i].y - eksplozje[i].frame_height / 2, 0);
}
}
}
void eksplozja::startEksplozji(eksplozja eksplozje[], int size, int x, int y)
{
for (int i = 0; i < size; i++)
{
if (!eksplozje[i].live)
{
eksplozje[i].live = true;
eksplozje[i].x = x;
eksplozje[i].y = y;
break;
}
}
}
void eksplozja::updateEksplozji(eksplozja eksplozje[], int size)
{
for (int i = 0; i < size; i++)
{
if (eksplozje[i].live)
{
if(++eksplozje[i].frame_count >= eksplozje[i].frame_delay)
{
eksplozje[i].cur_frame += eksplozje[i].animation_direction;
if (eksplozje[i].cur_frame >= eksplozje[i].max_frame)
{
eksplozje[i].cur_frame = 0;
eksplozje[i].live = false;
}
eksplozje[i].frame_count = 0;
}
}
}
}
void eksplozja::ResetujEksplozje(eksplozja eksplozje[], int size)
{
for (int i = 0; i < size; i++)
{
eksplozje[i].live = false;
}
}
kometa.h
#pragma once
#include "statek.h"
#include "eksplozja.h"
#include<allegro5\allegro_image.h>
class kometa
{
public:
kometa();
~kometa(void);
private:
int ID;
int x;
int y;
bool live;
int speed;
int boundy;
int boundx;
int max_frame;
int cur_frame;
int frame_count;
int frame_delay;
int frame_width;
int frame_height;
int animation_columns;
int animation_direction;
ALLEGRO_BITMAP *image;
public:
void ustawObraz(ALLEGRO_BITMAP *kimage);
void startKomety(kometa kometa[], int size);
void rysujKomete(kometa kometa[], int size);
void updateKomety(kometa kometa[], int size);
void kolizjaKomety(kometa kometa[], int kSize, statek &ship, eksplozja eksplozja[], int eSize);
int zwroc_x(void);
int zwroc_y(void);
int zwroc_boundx(void);
int zwroc_boundy(void);
bool zwroc_live(void);
void zmienBool(void);
void ResetujKomete(kometa komety[], int size);
};
kometa.cpp
#include "kometa.h"
kometa::kometa()
{
ID = ENEMY;
live = false;
speed = 5;
boundx = 35;
boundy = 38;
max_frame = 143;
cur_frame = 0;
frame_count = 0;
frame_delay = 2;
frame_width = 96;
frame_height = 96;
animation_columns = 21;
if (rand() % 2)
{
animation_direction = 1;
}
else
{
animation_direction = -1;
}
}
kometa::~kometa(void)
{
}
void kometa::ustawObraz(ALLEGRO_BITMAP *kimage)
{
image = kimage;
}
void kometa::startKomety(kometa kometa[], int size)
{
for (int i = 0; i < size; i++)
{
if (!kometa[i].live)
{
if (rand() % 500 == 0)
{
kometa[i].live = true;
kometa[i].x = WIDTH;
kometa[i].y = 30 + rand() % (HEIGHT - 60);
break;
}
}
}
}
void kometa::rysujKomete(kometa kometa[], int size)
{
for (int i = 0; i < size; i++)
{
if (kometa[i].live)
{
int fx = (kometa[i].cur_frame % kometa[i].animation_columns) * kometa[i].frame_width;
int fy = (kometa[i].cur_frame / kometa[i].animation_columns) * kometa[i].frame_height;
al_draw_bitmap_region(kometa[i].image, fx, fy, kometa[i].frame_width,
kometa[i].frame_height, kometa[i].x - kometa[i].frame_width / 2, kometa[i].y - kometa[i].frame_height / 2, 0);
/*al_draw_filled_rectangle(kometa[i].x - kometa[i].boundx, kometa[i].y - kometa[i].boundy,
kometa[i].x + kometa[i].boundx, kometa[i].y + kometa[i].boundy, al_map_rgba(255, 0, 255, 100));*/
}
}
/*for (int i = 0; i < size; i++)
{
if (kometa[i].live)
{
al_draw_filled_circle(kometa[i].x, kometa[i].y, 20, al_map_rgb(255, 0, 0));
}
}*/
}
void kometa::updateKomety(kometa kometa[], int size)
{
for (int i = 0; i < size; i++)
{
if (kometa[i].live)
{
if (++kometa[i].frame_count >= kometa[i].frame_delay)
{
kometa[i].cur_frame += kometa[i].animation_direction;
if (kometa[i].cur_frame >= kometa[i].max_frame)
{
kometa[i].cur_frame = 0;
}
else if (kometa[i].cur_frame <=0)
{
kometa[i].cur_frame = kometa[i].max_frame - 1;
}
kometa[i].frame_count = 0;
}
kometa[i].x -= kometa[i].speed;
}
}
}
void kometa::kolizjaKomety(kometa kometa[], int kSize, statek &ship, eksplozja eksplozja[], int eSize)
{
for (int i = 0; i < kSize; i++)
{
if (kometa[i].live)
{
if (kometa[i].x - kometa[i].boundx < ship.zwroc_x() + ship.zwroc_boundx() &&
kometa[i].x + kometa[i].boundx > ship.zwroc_x() - ship.zwroc_boundx() &&
kometa[i].y - kometa[i].boundy < ship.zwroc_y() + ship.zwroc_boundy() &&
kometa[i].y + kometa[i].boundy > ship.zwroc_y() - ship.zwroc_boundy())
{
ship.zmniejsz_zycie();
kometa[i].live = false;
eksplozja->startEksplozji(eksplozja, eSize, ship.zwroc_x(), ship.zwroc_y());
}
else if (kometa[i].x < 0)
{
kometa[i].live = false;
ship.zmniejsz_zycie();
}
}
}
}
int kometa::zwroc_x(void)
{
return x;
}
int kometa::zwroc_y(void)
{
return y;
}
int kometa::zwroc_boundx(void)
{
return boundx;
}
int kometa::zwroc_boundy(void)
{
return boundy;
}
bool kometa::zwroc_live(void)
{
return live;
}
void kometa::zmienBool(void)
{
if (live = true)
{
live = false;
}
else
{
live = true;
}
}
void kometa::ResetujKomete(kometa komety[], int size)
{
for (int i = 0; i < size; i++)
{
komety[i].live = false;
}
}
pocisk.h
#pragma once
#include "kometa.h"
#include "eksplozja.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);
void ResetujPocisk();
};
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)
{
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);
}
}
}
}
}
}
void pocisk::ResetujPocisk()
{
ID = BULLET;
speed = 10;
live = false;
}
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 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);
void zwiekszWynik(void);
void zmniejsz_zycie(void);
void ResetujZycia(statek &statek);
};
statek.cpp
#include "statek.h"
statek::statek(ALLEGRO_BITMAP *simage)
{
x = 20;
y = HEIGHT / 2;
ID = PLAYER;
lives = 3;
speed = 7;
boundx = 6;
boundy = 7;
score = 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);
/*al_draw_filled_rectangle(x, y - 9, x + 10, y - 7, al_map_rgb(255, 0, 0));
al_draw_filled_rectangle(x, y + 9, x + 10, y + 7, al_map_rgb(255, 0, 0));
al_draw_filled_triangle(x - 12, y - 17, x + 12, y, x - 12, y + 17, al_map_rgb(0, 255, 0));
al_draw_filled_rectangle(x - 12, y - 2, x +15, y + 2, al_map_rgb(0, 0, 255));*/
}
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;
}
void statek::zwiekszWynik()
{
score++;
}
void statek::zmniejsz_zycie(void)
{
lives--;
}
void statek::ResetujZycia(statek &statek)
{
x = 20;
y = HEIGHT / 2;
ID = PLAYER;
lives = 3;
speed = 7;
boundx = 6;
boundy = 7;
score = 0;
}
Bez wczytywania bitmapy działa wszystko dobrze.