void Map::draw(Torbit& target) { const bool z = zoom; int less_x = 0; int less_y = 0; // how much is the screen larger than the map? if (!get_torus_x() && get_xl() * (z+1) < screen_xl) less_x = screen_xl - get_xl() * (z+1); if (!get_torus_y() && get_yl() * (z+1) < screen_yl) less_y = screen_yl - get_yl() * (z+1); for (int x = less_x/2; x < screen_xl-less_x/2; x += get_xl()*(z+1)) { for (int y = less_y; y < screen_yl; y += get_yl()*(z+1)) { draw_at(target, x, y); if (less_y != 0) break; } if (less_x != 0) break; } // Draw the screen border const int c = useR->screen_border_colored ? color[COL_SCREEN_BORDER] : 0; if (less_x) { rectfill(target.get_al_bitmap(), 0, 0, less_x/2 - 1, screen_yl - 1, c); rectfill(target.get_al_bitmap(), screen_xl - less_x/2, 0, screen_xl - 1, screen_yl - 1, c); } if (less_y) rectfill(target.get_al_bitmap(), less_x/2, 0, screen_xl - less_x/2 - 1, less_y - 1, c); }
void Map::load_masked_screen_rectangle(Torbit& src) { if (get_xl() != src.get_xl() || get_yl() != src.get_yl()) return; const int& x = screen_x; const int& y = screen_y; const int& xl = get_xl(); const int& yl = get_yl(); const bool& tx = get_torus_x(); const bool& ty = get_torus_y(); const int min_w = screen_xl; const int min_h = screen_yl; BITMAP* s = src.get_al_bitmap(); BITMAP* b = get_al_bitmap(); masked_blit(s, b, x, y, x, y, min_w, min_h); if (tx) masked_blit(s, b, x-xl, y, x-xl, y, min_w, min_h); if (ty) masked_blit(s, b, x, y-yl, x, y-yl, min_w, min_h); if (tx&&ty) masked_blit(s, b, x-xl, y-yl, x-xl, y-yl, min_w, min_h); }
void Map::draw_at( Torbit& target, const int offx, // start this much away from the screen's upper left edge const int offy ) { const int& mapxl = get_xl(); const int& mapyl = get_yl(); const int scrx = !zoom ? screen_x: Help::mod(screen_x+screen_xl/4, mapxl); const int scry = !zoom ? screen_y: Help::mod(screen_y+screen_yl/4, mapyl); const int lx = std::min(!zoom ? screen_xl : screen_xl / 2, mapxl); const int ly = std::min(!zoom ? screen_yl : screen_yl / 2, mapyl); const bool short_x = scrx + lx > mapxl; const bool short_y = scry + ly > mapyl; const int shoby_x = short_x ? scrx + lx - mapxl : 0; const int shoby_y = short_y ? scry + ly - mapyl : 0; if (! zoom) { masked_blit(get_al_bitmap(), target.get_al_bitmap(), scrx, scry, // source x/y start offx, offy, // target x/y start short_x ? mapxl - scrx : lx, // x-length and y-length of area to copy short_y ? mapyl - scry : ly); if (short_x && get_torus_x()) { masked_blit(get_al_bitmap(), target.get_al_bitmap(), 0, scry, offx + mapxl - scrx, offy, scrx + lx - mapxl, short_y ? mapyl - scry : ly); } if (short_y && get_torus_y()) { masked_blit(get_al_bitmap(), target.get_al_bitmap(), scrx, 0, offx, offy + mapyl - scry, short_x ? mapxl - scrx : lx, scry + ly - mapyl); } if (short_x && short_y && get_torus_x() && get_torus_y()) { masked_blit(get_al_bitmap(), target.get_al_bitmap(), 0, 0, offx + mapxl - scrx, offy + mapyl - scry, scrx + lx - mapxl, scry + ly - mapyl); } } else { // This is the above code copied, but with zoom things hacked in blit_double(get_al_bitmap(), target.get_al_bitmap(), scrx, scry, // source x/y start short_x ? mapxl - scrx : lx, // x-length and y-length of the source short_y ? mapyl - scry : ly, offx, // target x/y start offy); if (short_x && get_torus_x()) { blit_double(get_al_bitmap(), target.get_al_bitmap(), 0, scry, shoby_x, short_y ? mapyl - scry : ly, offx + 2 * (mapxl - scrx), offy); } if (short_y && get_torus_y()) { blit_double(get_al_bitmap(), target.get_al_bitmap(), scrx, 0, short_x ? mapxl - scrx : lx, shoby_y, offx, offy + 2 * (mapyl - scry)); } if (short_x && short_y && get_torus_x() && get_torus_y()) { blit_double(get_al_bitmap(), target.get_al_bitmap(), 0, 0, shoby_x, shoby_y, offx + 2 * (mapxl - scrx), offy + 2 * (mapyl - scry)); } } // end if/else zoom }
void draw_shadow_centered_text( Torbit& bmp, FONT* f, const char* s, int x, int y, int c, int sc) { textout_centre_ex(bmp.get_al_bitmap(), f, s, x+1, y+1, sc, -1); textout_centre_ex(bmp.get_al_bitmap(), f, s, x , y , c, -1); }
void draw_shaded_text(Torbit& bmp, FONT* f, const char* s, int x, int y, int r, int g, int b) { textout_ex(bmp.get_al_bitmap(), f, s, x+2, y+2, makecol(r/4, g/4, b/4),-1); textout_ex(bmp.get_al_bitmap(), f, s, x+1, y+1, makecol(r/2, g/2, b/2),-1); textout_ex(bmp.get_al_bitmap(), f, s, x , y , makecol(r , g , b ),-1); }
void Cutbit::draw( Torbit& target_torbit, const int x, const int y, const int fx, const int fy, const bool mirr, const double rot, const double scal, const Mode mode) const { BITMAP* target = target_torbit.get_al_bitmap(); if (bitmap && fx >= 0 && fy >= 0 && fx < x_frames && fy < y_frames) { // Schneide zunaechst ein Subbitmap aus unter Beachtung der Framewahl // Hat das Bild keine Frames, entfaellt +1 fuer den aeusseren Rahmen. BITMAP* sprite; if (x_frames == 1 && y_frames == 1) sprite = create_sub_bitmap(bitmap, 0, 0, xl, yl); else sprite = create_sub_bitmap(bitmap, fx * (xl+1) + 1, fy * (yl+1) + 1, xl, yl); if (mode == NORMAL) { target_torbit.draw_from(sprite, x, y, mirr, rot, scal); } else { const int PINK = color[COL_PINK]; const int BLACK = color[COL_BLACK]; const int GREY = color[COL_EDITOR_DARK]; const int size = xl > yl ? xl : yl; Torbit excerpt(size, size); excerpt.clear_to_color(PINK); excerpt.draw_from(sprite, 0, 0, mirr, rot, scal); if (mode == NOOW) { target_torbit.draw (excerpt.get_al_bitmap(), x, y); target_torbit.draw_from(excerpt.get_al_bitmap(), x, y); } else if (mode == NOOW_EDITOR) { for (int ix = 0; ix < size; ++ix) for (int iy = 0; iy < size; ++iy) { const int c = target_torbit.get_pixel(x + ix, y + iy); const int e = excerpt .get_pixel( ix, iy); if ((c == BLACK || c == PINK || c == GREY) && e != BLACK && e != PINK) target_torbit.set_pixel(x + ix, y + iy, e); } } else if (mode == DARK || mode == DARK_EDITOR) { for (int ix = 0; ix < size; ++ix) for (int iy = 0; iy < size; ++iy) if (excerpt.get_pixel(ix, iy) != PINK) target_torbit.set_pixel(x+ix, y+iy, mode==DARK ? PINK : GREY); } } // Fertig destroy_bitmap(sprite); } // Keine gueltige Frame-Angabe else { int col_text = makecol(255, 255, 255); int col_back = makecol( 64, 64, 64); if (!bitmap) col_back = makecol(255, 64, 64); std::ostringstream str; str << "( " << fx << " | " << fy << " )"; textout_ex(target, font, "Frame?!?!", x, y, col_text, col_back); textout_ex(target, font, str.str().c_str(), x, y+8,col_text, col_back); } }