void m_draw_scaled_target(MBITMAP *src, int sx, int sy, int sw, int sh,
int dx, int dy, int dw, int dh, MBITMAP *dst)
{
ALLEGRO_BITMAP *old_target = al_get_target_bitmap();
m_set_target_bitmap(dst);
al_draw_scaled_bitmap(src->bitmap, sx, sy, sw, sh, dx, dy, dw, dh, 0);
al_set_target_bitmap(old_target);
}
animation::animation(ALLEGRO_BITMAP * spriteSheet,ALLEGRO_BITMAP * bottomSpriteSheet, int xOffset,int yOffset,int width, int height, int xBottomOffset, int yBottomOffset,int bottomWidth, int bottomHeight,int speedTemp)
:speed_(speedTemp),xOffset_(xOffset),yOffset_(yOffset),oneThrough_(false),xBottomOffset_(xBottomOffset),yBottomOffset_(yBottomOffset),split_(true)
{
int bitmapWidth = al_get_bitmap_width(spriteSheet);
int bitmapHeight = al_get_bitmap_height(spriteSheet);
if(bitmapHeight % height != 0 or bitmapWidth % width != 0)
{
//Malformed settings.ini or malformed sprite sheet
fprintf(stderr, "NIGGERFAGGOT?\n");
}else
{
for(int i = 0; i < bitmapWidth / width; ++i)
{
for(int j = 0; j < bitmapHeight / height; ++j)
{
ALLEGRO_BITMAP * tempBitmap = al_create_bitmap(width,height);
al_set_target_bitmap(tempBitmap);
al_clear_to_color(al_map_rgba(100,100,99,0));
al_draw_bitmap_region(spriteSheet,i*width, j*height, width, height, 0, 0, 0);
frames_.push_back(tempBitmap);
}
}
}
int bottomSheetWidth = al_get_bitmap_width(bottomSpriteSheet);
int bottomSheetHeight = al_get_bitmap_height(bottomSpriteSheet);
if(bottomSheetHeight % bottomHeight != 0 or bottomSheetWidth % bottomWidth != 0)
{
//Malformed settings.ini or malformed sprite sheet
fprintf(stderr, "tehfuckrlysdf? %i\n", bottomSheetWidth);
exit(1);
}else if(bottomSpriteSheet != NULL)
{
for(int j = 0; j < bottomSheetHeight / bottomHeight; ++j)
{
for(int i = 0; i < bottomSheetWidth / bottomWidth; ++i)
{
ALLEGRO_BITMAP * tempBitmap = al_create_bitmap(bottomWidth,bottomHeight);
al_set_target_bitmap(tempBitmap);
al_clear_to_color(al_map_rgba(100,100,99,0));
al_draw_bitmap_region(bottomSpriteSheet,i*bottomWidth, j*bottomHeight, bottomWidth, bottomHeight, 0, 0, 0);
bottomFrames_.push_back(tempBitmap);
}
}
}
}
/* Function: al_destroy_bitmap
*/
void al_destroy_bitmap(ALLEGRO_BITMAP *bitmap)
{
if (!bitmap) {
return;
}
/* As a convenience, implicitly untarget the bitmap on the calling thread
* before it is destroyed, but maintain the current display.
*/
if (bitmap == al_get_target_bitmap()) {
ALLEGRO_DISPLAY *display = al_get_current_display();
if (display)
al_set_target_bitmap(al_get_backbuffer(display));
else
al_set_target_bitmap(NULL);
}
_al_set_bitmap_shader_field(bitmap, NULL);
_al_unregister_destructor(_al_dtor_list, bitmap);
if (!al_is_sub_bitmap(bitmap)) {
ALLEGRO_DISPLAY* disp = _al_get_bitmap_display(bitmap);
if (al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {
destroy_memory_bitmap(bitmap);
return;
}
/* Else it's a display bitmap */
if (bitmap->locked)
al_unlock_bitmap(bitmap);
if (bitmap->vt)
bitmap->vt->destroy_bitmap(bitmap);
if (disp)
_al_vector_find_and_delete(&disp->bitmaps, &bitmap);
if (bitmap->memory)
al_free(bitmap->memory);
}
al_free(bitmap);
}
ALLEGRO_BITMAP bouncer(ALLEGRO_BITMAP)
{
ALLEGRO_BITMAP *bouncer = NULL;
bouncer = al_create_bitmap(squareSize, squareSize);
if(!bouncer) {
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
done = true;
}
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(255, 0, 255));
al_set_target_bitmap(al_get_backbuffer(display));
}
void MapScreen::render()
{
al_clear_to_color(al_map_rgb(210,210,210));
al_set_target_bitmap(al_get_backbuffer(m_game->display()));
m_game->m_camera1.bind();
m_mapRenderer->render();
m_player->render();
}
void Canvas::drawTextureRegion(Texture* texture, Rectangle* srcRect, float x, float y, bool flipped)
{
if(al_get_target_bitmap() != this->buffer)
al_set_target_bitmap(this->buffer);
Graphics::DrawRegion(texture, srcRect->x, srcRect->y, srcRect->width, srcRect->height, x, y, alpha, flipped);
TF::engine->resetRenderingBuffer();
}
void RenderTarget::setAsCurrent(bool force) {
if (bindRenderTarget != 0 && !force) {
if (bindRenderTarget->bitmap == this->bitmap) {
return;
}
}
al_set_target_bitmap(this->bitmap);
bindRenderTarget = this;
}
void Canvas::fill(Rectangle* rect, byte r, byte g, byte b)
{
if(al_get_target_bitmap() != this->buffer)
al_set_target_bitmap(this->buffer);
al_draw_filled_rectangle(rect->x, rect->y, rect->x + rect->width, rect->y + rect->height, al_map_rgb(r,g,b) );
TF::engine->resetRenderingBuffer();
}
void Canvas::drawRect(Rectangle* rect, byte r, byte g, byte b, float thickness)
{
if(al_get_target_bitmap() != this->buffer)
al_set_target_bitmap(this->buffer);
al_draw_rectangle(rect->x, rect->y, rect->x + rect->width, rect->y + rect->height, al_map_rgb(r,g,b), thickness);
TF::engine->resetRenderingBuffer();
}
void PeacemakerBullet::render(Renderer *renderer, Gamestate *state)
{
std::string mainsprite = getsprite(state, false);
ALLEGRO_BITMAP *sprite = renderer->spriteloader.requestsprite(mainsprite);
double direction = std::atan2(vspeed, hspeed);
al_set_target_bitmap(renderer->background);
al_draw_rotated_bitmap(sprite, 0, 0, x - renderer->cam_x, y - renderer->cam_y, direction, 0);
}
void create_font_symbols(Board *b){
ALLEGRO_BITMAP *bmp = NULL, *currbuf = al_get_target_bitmap();
ALLEGRO_FONT *newfont=NULL;
int i, j;
int texth = al_get_font_line_height(b->text_font);
int bitmap_w, bitmap_h;
int bw = al_get_bitmap_width(b->clue_unit_bmp[0][0]);
int bh = al_get_bitmap_height(b->clue_unit_bmp[0][0]);
int nbw, nbh;
int range[2];
al_set_target_bitmap(NULL);
nbw = bw*(float)texth/bh;
nbh = texth;
bitmap_w = 4 + b->n*(2+nbw); // extra column for buttons, n>=4
bitmap_h = 4 + (b->h+1)*(2+nbh);
bmp = al_create_bitmap(bitmap_w, bitmap_h);
al_set_target_bitmap(bmp);
al_clear_to_color(NULL_COLOR);
for(j=0; j<b->h; j++){
for(i=0; i<b->n; i++){
// the rectangle is to guarantee the right height for al_grab_font
al_draw_scaled_bitmap(b->clue_unit_bmp[j][i], 0, 0, bw, bh, 2+i*(2+nbw), 2+ j*(2+nbh), nbw, nbh, 0);
al_draw_rectangle( 2+i*(2+nbw)+0.5, 2+ j*(2+nbh) + 0.5, 2+i*(2+nbw) + nbw -0.5, 2+j*(2+nbh) + nbh- 0.5, al_map_rgba(1,1,1,1),1);
}
}
// draw the buttons. now j= b->h
for(i=0;i<b->n;i++){
bw=al_get_bitmap_width(b->button_bmp[i%4]);
bh=al_get_bitmap_height(b->button_bmp[i%4]);
al_draw_scaled_bitmap(b->button_bmp[i%4], 0, 0, bw, bh, 2+i*(2+nbw), 2+ j*(2+nbh), nbw, nbh, 0);
al_draw_rectangle( 2+i*(2+nbw)+0.5, 2+ j*(2+nbh) + 0.5, 2+i*(2+nbw) + nbw -0.5, 2+j*(2+nbh) + nbh- 0.5, al_map_rgba(1,1,1,1),1);
}
range[0] = BF_CODEPOINT_START;
range[1] = BF_CODEPOINT_START + b->n*b->h-1 + 4;
newfont = al_grab_font_from_bitmap(bmp, 1, range);
al_set_fallback_font(b->text_font, newfont);
al_set_target_bitmap(currbuf);
al_destroy_bitmap(bmp);
}
/* Draw our example scene. */
static void draw(void)
{
float xs, ys, a;
double dt = 0;
double t = al_current_time();
if (last_time > 0) {
dt = t - last_time;
}
last_time = t;
al_set_target_bitmap(target);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA,
al_map_rgba_f(1, 1, 1, 1));
al_draw_filled_rectangle(x, y, x + RW, y + RH, al_map_rgba_f(1, 0, 0, 1));
al_draw_filled_rectangle(0, 0, W, H, al_map_rgba_f(1, 1, 0, 0.1));
x += dx * dt;
if (x < 0) {
x = 0;
dx = -dx;
}
if (x + RW > W) {
x = W - RW;
dx = -dx;
}
y += dy * dt;
if (y < 0) {
y = 0;
dy = -dy;
}
if (y + RH > H) {
y = H - RH;
dy = -dy;
}
al_set_target_bitmap(al_get_backbuffer());
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO, al_map_rgba_f(1, 1, 1, 1));
al_clear_to_color(al_map_rgba_f(0, 0, 1, 1));
xs = 1 + 0.2 * sin(t * ALLEGRO_PI * 2);
ys = 1 + 0.2 * sin(t * ALLEGRO_PI * 2);
a = t * ALLEGRO_PI * 2 / 3;
al_draw_rotated_scaled_bitmap(target, W / 2, H / 2, 320, 240, xs, ys, a, 0);
}
void escribirmensaje(ALLEGRO_EVENT_QUEUE* eventos,ALLEGRO_DISPLAY* display,ALLEGRO_BITMAP* pantalla,int*pestado,int* pestadomensaje,INFOPANTALLA* mipantalla){
ALLEGRO_FONT* fuente=NULL;
ALLEGRO_BITMAP* fondo=NULL;
fondo=al_create_bitmap(250,300); al_set_target_bitmap(fondo); al_clear_to_color(al_map_rgb(255,255,255));
fuente=crearfuente(PEQUENA); if(fuente==NULL){fprintf(stderr,"Fallo al cargar la fuente en escribirmensaje()\n"); exit -1;}
cambiopantalla(display,pantalla);
al_draw_bitmap(fondo,0,15,0);
al_destroy_bitmap(fondo);
al_draw_text(fuente,al_map_rgb(0,0,0),0,15,ALLEGRO_ALIGN_LEFT,"Escriba su SMS:");
fuente=crearfuente(MEDIA);
al_draw_text(fuente,al_map_rgb(0,0,0),0,270,ALLEGRO_ALIGN_LEFT,"Enviar");
cambiopantalla(display,pantalla);
if(mipantalla->tipoescritura==MODOLIBRE){
tecladoCLASSIC3(eventos,pantalla,display,mipantalla,pestado);
} else if(mipantalla->tipoescritura==TECLADOANALOGO){
cambiopantalla(display,pantalla);
al_draw_text(fuente,al_map_rgb(255,0,10),0,100,ALLEGRO_ALIGN_LEFT,"SU MENSAJE ESTA");
al_draw_text(fuente,al_map_rgb(255,0,10),0,125,ALLEGRO_ALIGN_LEFT,"SIENDO INTRODUCI-");
al_draw_text(fuente,al_map_rgb(255,0,10),0,150,ALLEGRO_ALIGN_LEFT,"DO MEDIANTE EL TE-");
al_draw_text(fuente,al_map_rgb(255,0,10),0,175,ALLEGRO_ALIGN_LEFT,"CLADO ANALOGO. (se");
al_draw_text(fuente,al_map_rgb(255,0,10),0,200,ALLEGRO_ALIGN_LEFT,"actualizara solo)");
cambiopantalla(display,pantalla);
printf("\nINGRESE SU MENSAJE AQUI Y SERA CARGADO EN EL CELULAR\n");
printf("\nRECUERDE QUE ESTA INGRESANDO EL MENSAJE PERSONAL\n");
char personalmessage[140];
unsigned int i=0;
while(i<140){
personalmessage[i]=getchar();
if(personalmessage[i]=='\n'){
personalmessage[i]=0;
break;
}
++i;
}
strcpy(mipantalla->mensajepersonal,personalmessage);
cambiopantalla(display,pantalla);
al_draw_bitmap(fondo,0,15,0);
cambiopantalla(display,pantalla);
} else if(mipantalla->tipoescritura==T9){
tecladoT9(eventos,pantalla,display);
}
*pestado=PANTALLAPRINCIPAL;
al_destroy_font(fuente);
}
GridFillAnimater::GridFillAnimater(int x, int y, int x0, int y0, int size, ALLEGRO_COLOR color)
{
ALLEGRO_BITMAP* tmp;
this->setFrameDur(30);
_x = x;
_y = y;
for (int i = 3; i >= 0; i--)
{
tmp = al_create_bitmap(GRID_SIZE + 6, GRID_SIZE + 6);
al_set_target_bitmap(tmp);
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_filled_rectangle(3 - i, 3 - i, GRID_SIZE + 3 + i, GRID_SIZE + 3 + i, color);
al_convert_mask_to_alpha(tmp, al_map_rgb(0, 0, 0));
this->addFrame(tmp);
}
al_set_target_bitmap(al_get_backbuffer(al_get_current_display()));
}
void init_error_bitmap() {
// Error bitmap.
int bmp_error_w, bmp_error_h;
al_get_text_dimensions(al_create_builtin_font(), "ERROR", NULL, NULL, &bmp_error_w, &bmp_error_h);
bmp_error = al_create_bitmap(bmp_error_w, bmp_error_h);
al_set_target_bitmap(bmp_error); {
al_clear_to_color(al_map_rgba(64, 0, 0, 128));
al_draw_text(al_create_builtin_font(), al_map_rgb(255, 0, 0), 0, 0, 0, "ERROR");
} al_set_target_backbuffer(display);
}
Overlay::~Overlay()
{
{
CoreSuspender suspend;
df::global::enabler->renderer = parent;
}
al_destroy_mutex(front_mutex);
al_destroy_bitmap(front);
al_destroy_bitmap(back);
front = back = NULL;
if(al_get_current_display() == NULL){
al_set_target_bitmap(NULL);
} else {
al_set_target_bitmap(al_get_backbuffer(al_get_current_display()));
}
}
/* Run the FPS test. */
static void run(void)
{
ALLEGRO_EVENT event;
int frames = 0;
double start;
target = al_create_bitmap(W, H);
al_set_target_bitmap(target);
al_clear_to_color(al_map_rgba_f(1, 1, 0, 1));
al_set_target_backbuffer(display);
dx = 81;
dy = 63;
start = al_get_time();
while (true) {
/* Check for ESC key or close button event and quit in either case. */
if (!al_is_event_queue_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
quit = true;
goto done;
}
if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
goto done;
}
break;
}
}
}
draw();
print(0, 0, "FPS: %.1f", frames / (al_get_time() - start));
if (al_get_new_bitmap_flags() & ALLEGRO_FORCE_LOCKING) {
print(0, al_get_font_line_height(myfont), "using forced bitmap locking");
}
else {
print(0, al_get_font_line_height(myfont), "drawing directly to bitmap");
}
print(0, al_get_font_line_height(myfont) * 2,
"Press SPACE to toggle drawing method.");
al_flip_display();
frames++;
}
done:
al_destroy_bitmap(target);
}
BigBitmap::BigBitmap(std::string bitmap_to_load, float sector_width, float sector_height) : region_size_w(sector_width), region_size_h(sector_height)
{
ALLEGRO_BITMAP *restoreto =al_get_target_bitmap();
orig_flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR);
big_bitmap = al_load_bitmap(bitmap_to_load.c_str());
if(big_bitmap == nullptr)
{
al_show_native_message_box(NULL, "Error", "Failed to load Image", bitmap_to_load.c_str(), NULL, ALLEGRO_MESSAGEBOX_ERROR);
}
orig_width = width = al_get_bitmap_width(big_bitmap);
orig_height = height = al_get_bitmap_height(big_bitmap);
w_regions = ceil(orig_width / region_size_w);
h_regions = ceil(orig_height / region_size_h);
float vector_size = w_regions+1 + h_regions+1;
bitmaps.reserve(vector_size);
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR);
for(int h = 0; h < h_regions; h++)
{
for(int w = 0; w < w_regions; w++)
{
bitmaps.push_back(al_create_bitmap(region_size_w, region_size_h));
al_set_target_bitmap(bitmaps[bitmaps.size()-1]);
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_bitmap_region(big_bitmap, w*region_size_w, h*region_size_h, region_size_w, region_size_h, 0, 0, 0);
#ifdef _BBDEBUG
std::string cont = "["+ std::to_string(h) +","+ std::to_string(w) +"]";
al_draw_text(dgbf, al_map_rgb(255,0,0),region_size_w/2,region_size_h/2,ALLEGRO_ALIGN_CENTRE,cont.c_str());
al_draw_rectangle(0,0,region_size_w, region_size_h, al_map_rgb(255,0,0),0);
#endif // _BBDEBUG
}
}
al_set_new_bitmap_flags(orig_flags);
al_set_target_bitmap(restoreto);
}
void AnimacionSprite::IniciarAnimacion(ALLEGRO_BITMAP *base, int col, int lin, int escala){
int width=al_get_bitmap_width(base);
int height=al_get_bitmap_height(base);
int spriteW=(int)(width/col);
int spriteH=(int)(height/lin);
no_frames=col*lin;
int ncol=0;
int mlin=0;
tick=0;
counter=2;
//*bases=new ALLEGRO_BITMAP[no_frames];
ALLEGRO_BITMAP *bases_[no_frames];
int count=0;
for(int i=0;i<lin;i++){
for(int j=0;j<col;j++){
ALLEGRO_BITMAP *tmp=al_create_bitmap(spriteW, spriteH);
al_set_target_bitmap (tmp);
al_draw_bitmap(base,ncol,mlin,0);
v.push_back(tmp);
ncol-=spriteW;
}
ncol=0;
mlin-=spriteH;
count++;
}
v.push_back(v.at(0));
//cout<<v.size()<<endl;
frame=0;
bases=bases_;
x=200;
y=200;
}
void m_draw_scaled_backbuffer(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, MBITMAP *dest)
{
ALLEGRO_BITMAP *old_target = al_get_target_bitmap();
int old_format = al_get_new_bitmap_format();
al_set_new_bitmap_format(al_get_bitmap_format(al_get_backbuffer(display)));
MBITMAP *tmp = m_create_bitmap(sw, sh);
int scr_w = al_get_display_width(display);
int scr_h = al_get_display_height(display);
if (sx+sw > scr_w) {
sw = scr_w-sx;
}
else if (sx < 0) {
sw -= sx;
sx = 0;
}
if (sy+sh > scr_h) {
sh = scr_h-sy;
}
else if (sy < 0) {
sh -= sy;
sy = 0;
}
#if defined ALLEGRO_RASPBERRYPI || defined ALLEGRO_IPHONE || defined ALLEGRO_ANDROID
ALLEGRO_LOCKED_REGION *lr1 = al_lock_bitmap(tmp->bitmap, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY);
ALLEGRO_LOCKED_REGION *lr2 = al_lock_bitmap_region(
al_get_backbuffer(display),
sx, sy, sw, sh,
ALLEGRO_PIXEL_FORMAT_ANY,
ALLEGRO_LOCK_READONLY
);
int pixel_size = al_get_pixel_size(al_get_bitmap_format(al_get_backbuffer(display)));
for (int y = 0; y < sh; y++) {
uint8_t *d1 = (uint8_t *)lr1->data + lr1->pitch * y;
uint8_t *d2 = (uint8_t *)lr2->data + lr2->pitch * y;
memcpy(d1, d2, pixel_size*sw);
}
al_unlock_bitmap(tmp->bitmap);
al_unlock_bitmap(al_get_backbuffer(display));
#else
m_set_target_bitmap(tmp);
al_draw_bitmap_region(al_get_backbuffer(display), sx, sy, sw, sh, 0, 0, 0);
#endif
m_set_target_bitmap(dest);
al_draw_scaled_bitmap(
tmp->bitmap,
0, 0, sw, sh,
dx, dy, dw, dh,
0
);
m_destroy_bitmap(tmp);
al_set_target_bitmap(old_target);
al_set_new_bitmap_format(old_format);
}
// unused
void convert_grayscale(ALLEGRO_BITMAP *bmp) {
ALLEGRO_BITMAP *dispbuf = al_get_target_bitmap();
int x, y, w, h, lum;
unsigned char r, g, b;
w = al_get_bitmap_width(bmp);
h = al_get_bitmap_height(bmp);
al_set_target_bitmap(bmp);
al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ABGR_8888, ALLEGRO_LOCK_READWRITE);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
al_unmap_rgb(al_get_pixel(bmp, x, y), &r, &g, &b);
lum = (0.299*r + 0.587*g + 0.114*b)/2; // dividing by two makes it darker, default should be not dividing
al_put_pixel(x, y, al_map_rgb(lum, lum, lum)); // RGB to grayscale
}
}
al_unlock_bitmap(bmp);
al_set_target_bitmap(dispbuf);
}
void iniciar(struct Nave nave[N]){
for (int i=0; i<N; i++){
nave[i].x = random;
nave[i].vx = random;
nave[i].width = 32;
nave[i].height = 32;
nave[i].img = al_create_bitmap(nave[i].width, nave[i].height);
al_set_target_bitmap(nave[i].img);
al_clear_to_color(al_map_rgb(rand() % 256, rand() % 256, rand() % 256));
}
}
void Gamestate_Draw(struct Game *game, struct GamestateResources* data) {
if (!data->fadeout) {
char t[255] = "";
strcpy(t, data->text);
if (data->underscore) {
strncat(t, "_", 1);
} else {
strncat(t, " ", 1);
}
al_set_target_bitmap(data->bitmap);
al_clear_to_color(al_map_rgba(0,0,0,0));
al_draw_text(data->font, al_map_rgba(255,255,255,10), game->viewport.width/2,
game->viewport.height*0.4167, ALLEGRO_ALIGN_CENTRE, t);
double tg = tan(-data->tan/384.0 * ALLEGRO_PI - ALLEGRO_PI/2);
int fade = data->fadeout ? 255 : data->fade;
al_set_target_bitmap(data->pixelator);
al_clear_to_color(al_map_rgb(35, 31, 32));
al_draw_tinted_scaled_bitmap(data->bitmap, al_map_rgba(fade, fade, fade, fade), 0, 0,
al_get_bitmap_width(data->bitmap), al_get_bitmap_height(data->bitmap),
-tg*al_get_bitmap_width(data->bitmap)*0.05,
-tg*al_get_bitmap_height(data->bitmap)*0.05,
al_get_bitmap_width(data->bitmap)+tg*0.1*al_get_bitmap_width(data->bitmap),
al_get_bitmap_height(data->bitmap)+tg*0.1*al_get_bitmap_height(data->bitmap),
0);
al_draw_bitmap(data->checkerboard, 0, 0, 0);
al_set_target_backbuffer(game->display);
al_draw_bitmap(data->pixelator, 0, 0, 0);
}
}
ALLEGRO_BITMAP* Map::Render(float startx, float starty, float width, float height, ALLEGRO_DISPLAY* d) {
if (lastsx == startx && lastsy == starty && lastw == width && lasth == height)
return cache_area;
if (cache_area)
al_destroy_bitmap(cache_area);
cache_area = al_create_bitmap(width, height);
al_set_target_bitmap(cache_area);
al_draw_bitmap_region(cache_map, startx*TILE_SIZE, starty*TILE_SIZE, width, height,
0, 0, 0);
al_set_target_bitmap(al_get_backbuffer(d));
lastsx = startx; lastsy = starty; lastw = width; lasth = height;
return cache_area;
}
ALLEGRO_BITMAP *generate_interpolator_graph_bitmap(float(* interpolator_func)(float), float size, ALLEGRO_COLOR col, float thickness, float padding)
{
// setup the drawing surface
ALLEGRO_BITMAP *surface = al_create_bitmap(size, size);
ALLEGRO_STATE state;
al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP);
al_set_target_bitmap(surface);
al_clear_to_color(color::transparent);
//
// start drawing the graph
//
float line_width = thickness;
float w = size;
float h = size;
float x = padding;
float y = padding;
w += padding*2;
h += padding*2;
//y *= -1;
h *= -1;
int num_points = 50;
vec2d previous_point(0, 1);
for (int i=0; i<=(num_points-1); i++)
{
float point_x = (float)i/(num_points-1);
float point_y = interpolator_func(point_x);
point_x *= (size-padding*2);
point_y *= -(size-padding*2);
point_x += x;
point_y += y+(size-padding*2);
al_draw_filled_circle(point_x, point_y, line_width*1.3, col);
}
// restore things to the way they were
al_restore_state(&state);
// return the created image
return surface;
}
//==================================================== DRAW_MENU ========================================================//
void Menu_Draw(struct Game *game) {
//RYSOWANIE TŁA Z MENU//
al_draw_bitmap(game->menu.menu_bitmap,0,0,0);
al_set_target_bitmap(al_get_backbuffer(game->display));
al_draw_bitmap_region(game->menu.mills, 0,game->menu.mills_y, 82,85, 799,485, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,0, 231,64, game->menu.cldpos1*1.2+300,0, 231,64, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,64, 213,44, game->menu.cldpos1+53,95, 213,44, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,108, 245,54, game->menu.cldpos1*1.5+723,24, 245,54, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,162, 190,41, game->menu.cldpos1*0.8+665,138, 190,41, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,0, 231,64, game->menu.cldpos2+475,175, 231*0.7,64*0.7, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,64, 213,44, game->menu.cldpos2*1.15+250,70, 213*0.9,44*0.9, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,108, 245,54, game->menu.cldpos2*1.1+22,220, 245*0.8,54*0.8, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,162, 190,41, game->menu.cldpos3+885,275, 190*0.7,41*0.7, 0);
al_draw_scaled_bitmap(game->menu.cloud, 0,64, 213,44, game->menu.cldpos3*0.7+520,290, 213*0.4,44*0.4, 0);
al_draw_bitmap(game->menu.smok,0,95,0);
//PRZYCISKI//
if(game->gamestate==0){
al_draw_bitmap_region(game->menu.buttons, 0,0, 195,43, 635,41, 0); //new game
if(game->play.dragon_lives>0)
al_draw_bitmap_region(game->menu.buttons, 0,43, 195,43, 635,119, 0); //resume game
else
al_draw_bitmap_region(game->menu.buttons, 0,215, 195,43, 635,119, 0); //resume game przygaszony
al_draw_bitmap_region(game->menu.buttons, 0,86, 195,43, 635,197, 0); //options
al_draw_bitmap_region(game->menu.buttons, 0,129, 195,43, 635,275, 0); //quit
}
//WYNIKI I INSTRUKCJA GRY//
if(game->gamestate==2){
al_draw_bitmap_region(game->menu.buttons, 195,0, 132,211, 698,41, 0); //tablica wyników
al_draw_bitmap_region(game->menu.buttons, 0,258, 498,211, 118,41, 0); //tablica informacji o grze
al_draw_bitmap_region(game->menu.buttons, 0,172, 195,43, 635,275, 0); //przycisk 'menu'
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,84, ALLEGRO_ALIGN_LEFT, "1. %i", game->table[0]); // stara poprawiona wysokość = 77 i co 20
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,104, ALLEGRO_ALIGN_LEFT, "2. %i", game->table[1]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,124, ALLEGRO_ALIGN_LEFT, "3. %i", game->table[2]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,144, ALLEGRO_ALIGN_LEFT, "4. %i", game->table[3]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,164, ALLEGRO_ALIGN_LEFT, "5. %i", game->table[4]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,184, ALLEGRO_ALIGN_LEFT, "6. %i", game->table[5]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,204, ALLEGRO_ALIGN_LEFT, "7. %i", game->table[6]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 737,224, ALLEGRO_ALIGN_LEFT, "8. %i", game->table[7]);
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,61, ALLEGRO_ALIGN_LEFT, "Press or to move up and or to move down.");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,81, ALLEGRO_ALIGN_LEFT, "Press or right click mouse to fire a fiery bullet!");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,101, ALLEGRO_ALIGN_LEFT, "To pause game or enter menu press .");
//al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,121, ALLEGRO_ALIGN_LEFT, "");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,141, ALLEGRO_ALIGN_LEFT, "You've got three lives.");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,161, ALLEGRO_ALIGN_LEFT, "Avoid thrown pitchforks - they will kill you!");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,181, ALLEGRO_ALIGN_LEFT, "Flying into a cloud of flour disables you for a while.");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,201, ALLEGRO_ALIGN_LEFT, "Do not fly too low - you will fall and die.");
al_draw_textf(game->sfont, al_map_rgb(70,64,58), 138,221, ALLEGRO_ALIGN_LEFT, "Shepherd boys fire exploding sheep defragmentators!");
}
//BITMAPA KURSORA//
al_draw_bitmap(game->menu.cursor,game->pos_x, game->pos_y, 0);
}
void MenuScreen::render()
{
m_game->m_camera2.bind();
al_clear_to_color(al_map_rgb(63,63,116));
al_set_target_bitmap(al_get_backbuffer(m_game->display()));
al_draw_text(m_game->m_fontBig, al_map_rgb(203, 219, 252), 15, 11, 0, "Pheee");
al_draw_text(m_game->m_fontBig, al_map_rgb(203, 219, 252), 15, 31, 0, "Strew");
al_draw_text(m_game->m_fontBig, al_map_rgb(203, 219, 252), 15, 51, 0, "Quest");
}
ALLEGRO_BITMAP * t3f_resize_bitmap(ALLEGRO_BITMAP * bp, int w, int h)
{
ALLEGRO_BITMAP * rbp = NULL;
int start_w = al_get_bitmap_width(bp);
int start_h = al_get_bitmap_height(bp);
int x, y;
float pixx, pixx_f, pixy, pixy_f;
ALLEGRO_COLOR a, b, c, d, ab, cd, result;
ALLEGRO_STATE old_state;
/* don't resize if size is already correct */
if(w == start_w && h == start_h)
{
return al_clone_bitmap(bp);
}
/* scale with software filtering */
rbp = al_create_bitmap(w, h);
if(!rbp)
{
printf("failed to create return bitmap\n");
return NULL;
}
al_lock_bitmap(rbp, ALLEGRO_LOCK_READWRITE, ALLEGRO_PIXEL_FORMAT_ANY);
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP);
al_set_target_bitmap(rbp);
for(y = 0; y < h; y++)
{
pixy = ((float)y / h) * ((float)start_h - 1);
pixy_f = floor(pixy);
for(x = 0; x < w; x++)
{
pixx = ((float)x / w) * ((float)start_w - 1);
pixx_f = floor(pixx);
a = al_get_pixel(bp, pixx_f, pixy_f);
b = al_get_pixel(bp, pixx_f + 1, pixy_f);
c = al_get_pixel(bp, pixx_f, pixy_f + 1);
d = al_get_pixel(bp, pixx_f + 1, pixy_f + 1);
ab = interpolate(a, b, pixx - pixx_f);
cd = interpolate(c, d, pixx - pixx_f);
result = interpolate(ab, cd, pixy - pixy_f);
al_put_pixel(x, y, result);
}
}
al_unlock_bitmap(rbp);
al_restore_state(&old_state);
return rbp;
}
/* Function: al_restore_state
*/
void al_restore_state(ALLEGRO_STATE const *state)
{
thread_local_state *tls;
INTERNAL_STATE *stored;
int flags;
if ((tls = tls_get()) == NULL)
return;
stored = (void *)state;
flags = stored->flags;
if (flags & ALLEGRO_STATE_NEW_DISPLAY_PARAMETERS) {
_STORE(new_display_flags);
_STORE(new_display_refresh_rate);
_STORE(new_display_adapter);
_STORE(new_window_x);
_STORE(new_window_y);
_STORE(new_display_settings);
}
if (flags & ALLEGRO_STATE_NEW_BITMAP_PARAMETERS) {
_STORE(new_bitmap_format);
_STORE(new_bitmap_flags);
}
if (flags & ALLEGRO_STATE_DISPLAY) {
_STORE(current_display);
_al_set_current_display_only(tls->current_display);
}
if (flags & ALLEGRO_STATE_TARGET_BITMAP) {
_STORE(target_bitmap);
al_set_target_bitmap(tls->target_bitmap);
}
if (flags & ALLEGRO_STATE_BLENDER) {
tls->current_blender = stored->stored_blender;
}
if (flags & ALLEGRO_STATE_NEW_FILE_INTERFACE) {
_STORE(new_file_interface);
_STORE(fs_interface);
}
if (flags & ALLEGRO_STATE_TRANSFORM) {
ALLEGRO_BITMAP *bitmap = al_get_target_bitmap();
if (bitmap)
al_use_transform(&stored->stored_transform);
}
}
bool TGlasses::CollidedWith(TObject &obj)
{
if (&obj == &GLOBALS::player)
{
const unsigned int atlasWidth_tiles = al_get_bitmap_width(GLOBALS::tileAtlas_unscaled) / TILE_WIDTH_PIXELS_UNSCALED;
unsigned int tileY, tileX;
signed int tileID, tileIndex;
al_set_target_bitmap(GLOBALS::background_scaled);
// turn on the invisible platforms
for (tileIndex = 0; tileIndex < (LEVEL_HEIGHT_TILES * LEVEL_WIDTH_TILES); ++tileIndex)
{
if (level1MapData.codes[tileIndex] == eCODE_INVISIBLE_PLATFORM)
{
level1MapData.codes[tileIndex] = 0;
tileID = 53;
level1MapData.bounds[tileIndex] = SOLID_TOP;
level1MapData.midTiles[tileIndex] = tileID;
tileY = tileIndex / LEVEL_WIDTH_TILES;
tileX = tileIndex % LEVEL_WIDTH_TILES;
al_draw_scaled_bitmap(GLOBALS::tileAtlas_unscaled,
(tileID % atlasWidth_tiles) * TILE_WIDTH_PIXELS_UNSCALED, (tileID / atlasWidth_tiles) * TILE_HEIGHT_PIXELS_UNSCALED,
TILE_WIDTH_PIXELS_UNSCALED, TILE_HEIGHT_PIXELS_UNSCALED,
(TILE_WIDTH_PIXELS_UNSCALED * SCALE_FACTOR) * tileX, (TILE_HEIGHT_PIXELS_UNSCALED * SCALE_FACTOR) * tileY,
TILE_WIDTH_PIXELS_UNSCALED * SCALE_FACTOR, TILE_HEIGHT_PIXELS_UNSCALED * SCALE_FACTOR,
0);
}
}
// paint over glasses graphic in background image
tileY = m_y/TILE_HEIGHT_PIXELS_UNSCALED;
tileX = m_x/TILE_WIDTH_PIXELS_UNSCALED;
/*
tileID = level1MapData.backTiles[(tileY*LEVEL_WIDTH_TILES)+tileX];
al_draw_scaled_bitmap(GLOBALS::tileAtlas_unscaled,
(tileID % atlasWidth_tiles) * TILE_WIDTH_PIXELS_UNSCALED, (tileID / atlasWidth_tiles) * TILE_HEIGHT_PIXELS_UNSCALED,
TILE_WIDTH_PIXELS_UNSCALED, TILE_HEIGHT_PIXELS_UNSCALED,
(TILE_WIDTH_PIXELS_UNSCALED * SCALE_FACTOR) * tileX, (TILE_HEIGHT_PIXELS_UNSCALED * SCALE_FACTOR) * tileY,
TILE_WIDTH_PIXELS_UNSCALED * SCALE_FACTOR, TILE_HEIGHT_PIXELS_UNSCALED * SCALE_FACTOR,
0);
*/
return true;
}
return false;
}
