int main(int argc, char **argv)
{
al_init();
al_init_image_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
ALLEGRO_BITMAP *tm = al_load_bitmap("tilemap.png");
int w = al_get_bitmap_width(tm);
int h = al_get_bitmap_height(tm);
int wt = w / 16;
int ht = h / 16;
ALLEGRO_BITMAP *b = al_create_bitmap(16, 16);
al_set_target_bitmap(b);
for (int y = 0; y < ht; y++) {
for (int x = 0; x < wt; x++) {
al_clear_to_color(al_map_rgba_f(0, 0, 0, 0));
al_draw_bitmap_region(tm, x*16, y*16, 16, 16, 0, 0, 0);
char name[200];
sprintf(name, "out/%d-%d.png", x, y);
al_save_bitmap(name, b);
}
}
}
int main()
{
al_init();
al_init_image_addon();
ALLEGRO_BITMAP *logo = al_load_bitmap("logo_no_alpha.png");
ALLEGRO_BITMAP *shine = al_load_bitmap("shine.png");
int w = al_get_bitmap_width(logo);
int h = al_get_bitmap_height(logo);
ALLEGRO_BITMAP *buf = al_create_bitmap(w, h);
for (int i = 0; i < 20; i++) {
char filename[100];
sprintf(filename, "frame%02d.png", i);
al_set_target_bitmap(buf);
al_clear_to_color(al_map_rgb(0x22, 0x22, 0x22));
float f = (rand() % 1000) / 1000.0 / 2.0;
if (rand() % 2) {
f = f + 0.5;
al_draw_tinted_bitmap(shine, al_map_rgba_f(f, f, f, f), 0, 0, 0);
}
else {
al_draw_bitmap(shine, 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
al_draw_tinted_bitmap(shine, al_map_rgba_f(f, f, f, f), 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
}
al_draw_bitmap(logo, 0, 0, 0);
al_save_bitmap(filename, buf);
}
}
void
save_bitmap (char *filename, ALLEGRO_BITMAP *bitmap)
{
if (! al_save_bitmap (filename, bitmap))
error (0, 0, "%s: cannot save bitmap file '%s'",
__func__, filename);
}
std::string gphandle::generate_back() {
int grass_sprites_size = 9;
std::string grass_loc = search_for("grass", "dirs.txt");
ALLEGRO_BITMAP *grass_img = al_load_bitmap(grass_loc.c_str());
std::vector<ALLEGRO_BITMAP *> grasses(grass_sprites_size);
for(int i=0; i<grass_sprites_size; i++) {
grasses[i] = al_create_sub_bitmap(grass_img, i*32, 0, (i+1)*32, 32);
}
ALLEGRO_BITMAP *new_back = al_create_bitmap(1024, 768);
al_set_target_bitmap(new_back);
srand(time(NULL));
for(int i=0; i<24; i++){
for(int j=0; j<32; j++) {
int random = rand()%grass_sprites_size;
al_draw_bitmap(grasses[random], 32.0 * j, 32.0 * i,0);
}
}
std::string location = "tmps/background.png";
al_save_bitmap(location.c_str(), new_back);
return location;
}
static int allua_Bitmap_save(lua_State * L)
{
ALLUA_bitmap bitmap;
const char *filename;
bitmap = allua_check_bitmap(L, 1);
filename = luaL_checkstring(L, 2);
lua_pushboolean(L, al_save_bitmap(filename, bitmap));
return 1;
}
static mrb_value
bitmap_save(mrb_state *mrb, mrb_value self)
{
ALLEGRO_BITMAP *b;
char *s;
Check_Destroyed(mrb, self, bitmap, b);
mrb_get_args(mrb, "z", &s);
if (!al_save_bitmap(s, b)) {
mrb_raise(mrb, E_ALLEGRO_ERROR, "saving bitmap failed");
}
return mrb_nil_value();
}
void take_screenshot(SCREENSHOT * ss)
{
char buf[64];
ALLEGRO_BITMAP *bmp2 = NULL;
snprintf(buf, sizeof(buf), "%s%04d.%s", ss->name, ss->counter, ss->ext);
bmp2 = al_create_bitmap(screen_width, screen_height);
al_set_target_bitmap(bmp2);
al_draw_bitmap(al_get_backbuffer(screen), 0, 0, 0);
al_set_target_backbuffer(screen);
al_save_bitmap(buf, bmp2);
al_destroy_bitmap(bmp2);
next_screenshot(ss);
}
int main(int argc, char **argv)
{
ALLEGRO_BITMAP *bitmap;
double t0;
double t1;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
if (argc < 3) {
log_printf("This example needs to be run from the command line.\n");
log_printf("Usage: %s <infile> <outfile>\n", argv[0]);
log_printf("\tPossible file types: BMP PCX PNG TGA\n");
goto done;
}
al_init_image_addon();
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP
| ALLEGRO_NO_PREMULTIPLIED_ALPHA);
bitmap = al_load_bitmap(argv[1]);
if (!bitmap) {
log_printf("Error loading input file\n");
goto done;
}
t0 = al_get_time();
if (!al_save_bitmap(argv[2], bitmap)) {
log_printf("Error saving bitmap\n");
goto done;
}
t1 = al_get_time();
log_printf("Saving took %.4f seconds\n", t1 - t0);
al_destroy_bitmap(bitmap);
done:
close_log(true);
return 0;
}
int main(int argc, char **argv)
{
const char *if_name = argv[1];
const char *of_name = argv[2];
al_init();
al_init_image_addon();
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ANY_32_WITH_ALPHA);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
ALLEGRO_BITMAP *i_bmp = al_load_bitmap(if_name);
int w, h;
w = al_get_bitmap_width(i_bmp);
h = al_get_bitmap_height(i_bmp);
ALLEGRO_BITMAP *o_bmp = al_create_bitmap(w, h);
al_set_target_bitmap(o_bmp);
al_clear_to_color(al_map_rgb(255, 0, 255));
int nanims = h/SUBH;
int nframes = w/SUBW;
for (int anim = 0; anim < nanims; anim++) {
int f = SUBW-1;
for (int i = 0; i < 4; i++) {
ALLEGRO_BITMAP *sub = al_create_sub_bitmap(i_bmp,
i*SUBW, anim*SUBH, SUBW, SUBH);
int thisf = furthest_left(sub);
if (thisf < SUBW-1 && thisf < f)
f = thisf;
al_destroy_bitmap(sub);
}
for (int i = 0; i < 4; i++) {
ALLEGRO_BITMAP *sub = al_create_sub_bitmap(i_bmp,
i*SUBW, anim*SUBH, SUBW, SUBH);
al_draw_bitmap(sub,
i*SUBW-(f/2),
anim*SUBH, 0);
al_destroy_bitmap(sub);
}
}
al_save_bitmap(of_name, o_bmp);
}
int main(int argc, char **argv)
{
ALLEGRO_BITMAP *bitmap;
double t0;
double t1;
if (argc < 3) {
fprintf(stderr, "Usage: exnew_convert <infile> <outfile>\n");
fprintf(stderr, "\tPossible file types: BMP PCX PNG TGA\n");
return 1;
}
if (!al_init()) {
fprintf(stderr, "Could not init Allegro.\n");
return 1;
}
al_init_image_addon();
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP
| ALLEGRO_NO_PREMULTIPLIED_ALPHA);
bitmap = al_load_bitmap(argv[1]);
if (!bitmap) {
fprintf(stderr, "Error loading input file\n");
return 1;
}
t0 = al_get_time();
if (!al_save_bitmap(argv[2], bitmap)) {
fprintf(stderr, "Error saving bitmap\n");
return 1;
}
t1 = al_get_time();
printf("Saving took %.4f seconds\n", t1 - t0);
al_destroy_bitmap(bitmap);
return 0;
}
/**
* Save the generation of circles.
*
* This always saves generation[0] since that is the generation
* that is used to compare at the end of the loop whether we have
* reached the perfect score.
*
* This will save 2 files for a generation:
* - generation-X.png: The bitmap image
* - generation-X.svg: The circle layout
*/
void _save_generation(
struct ia_circles **generation,
uint64_t counter
)
{
if(!generation) {
printfe("No generation struct provided");
return;
}
struct ia_circles *gen = NULL;
char img_path[64];
console_print("Saving generation %lu", counter);
gen = generation[0];
// Save the image
snprintf(img_path, sizeof(img_path),
"%s/generation-%lu.png",
OUTPUT_PATH, counter);
al_save_bitmap(img_path, gen->img->bmp);
// Save the circle layout
snprintf(img_path, sizeof(img_path),
"%s/generation-%lu.svg",
OUTPUT_PATH, counter);
_save_generation_svg(gen, img_path);
}
bool LL_SHARED save_bitmap(std::string bitmap_file_name,ALLEGRO_BITMAP* bitmap)
{
return al_save_bitmap(bitmap_file_name.c_str(),bitmap);
}
/* the main game function */
static int play_game()
{
ALLEGRO_TIMER *inc_counter;
int gameover = 0;
int cyclenum = 0;
/* init */
score = 0;
init_view();
init_player();
init_badguys();
init_bullets();
init_explode();
init_message();
#define TIMER_SPEED ALLEGRO_BPS_TO_SECS(30*(cyclenum+2))
inc_counter = al_create_timer(TIMER_SPEED);
al_start_timer(inc_counter);
while (!gameover) {
/* move everyone */
while ((al_get_timer_count(inc_counter) > 0) && (!gameover)) {
update_view();
update_bullets();
update_explode();
update_message();
if (update_badguys()) {
if (advance_view()) {
cyclenum++;
al_set_timer_count(inc_counter, 0);
lay_attack_wave(TRUE);
advance_player(TRUE);
}
else {
lay_attack_wave(FALSE);
advance_player(FALSE);
}
}
gameover = update_player();
al_set_timer_count(inc_counter, al_get_timer_count(inc_counter)-1);
}
/* take a screenshot? */
if (key[ALLEGRO_KEY_PRINTSCREEN]) {
static int ss_count = 0;
char fname[80];
sprintf(fname, "speed%03d.tga", ++ss_count);
al_save_bitmap(fname, al_get_backbuffer(screen));
while (key[ALLEGRO_KEY_PRINTSCREEN])
poll_input_wait();
al_set_timer_count(inc_counter, 0);
}
/* toggle fullscreen window */
if (key[ALLEGRO_KEY_F]) {
int flags = al_get_display_flags(screen);
al_set_display_flag(screen, ALLEGRO_FULLSCREEN_WINDOW,
!(flags & ALLEGRO_FULLSCREEN_WINDOW));
while (key[ALLEGRO_KEY_F])
poll_input_wait();
}
/* draw everyone */
draw_view();
}
/* cleanup */
al_destroy_timer(inc_counter);
shutdown_view();
shutdown_player();
shutdown_badguys();
shutdown_bullets();
shutdown_explode();
shutdown_message();
if (gameover < 0) {
sfx_ping(1);
return FALSE;
}
return TRUE;
}
int main(int argc, char **argv)
{
if (argc < 3) {
printf("Usage: infile.png outfile.png\n");
return 0;
}
al_init();
al_init_image_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888);
ALLEGRO_BITMAP *inbmp = al_load_bitmap(argv[1]);
al_set_target_bitmap(inbmp);
int x, y;
for (y = 0; y < al_get_bitmap_height(inbmp);) {
for (x = 0; x < al_get_bitmap_width(inbmp); x++) {
ALLEGRO_COLOR pixel = al_get_pixel(inbmp, x, y);
if (pixel.a == 0) {
int h = 1;
do {
ALLEGRO_COLOR p = al_get_pixel(inbmp, x, y+h);
if (p.a == 0 || (p.r == 1 && p.g == 1 && p.b == 1))
h++;
else
break;
} while (1);
printf("h=%d\n", h);
for (int r = 0; r < h; r++) {
ALLEGRO_COLOR c;
if (r < h/2) {
float p = (float)r / (h/2);
int diff = MIDDLE-TOP;
int v = diff*p + TOP;
c = al_map_rgb(v, v, v);
printf("v=%d\n", v);
}
else {
float p = 1 - ((float)(r-h/2) / (h/2));
int diff = MIDDLE-TOP;
int v = diff*p + TOP;
c = al_map_rgb(v, v, v);
printf("v=%d\n", v);
}
for (int xx = 0; xx < al_get_bitmap_width(inbmp); xx++) {
ALLEGRO_COLOR p = al_get_pixel(inbmp, xx, y+r);
if (p.r == 1 && p.g == 1 && p.b == 1 && p.a == 1) {
al_put_pixel(xx, y+r, c);
}
}
}
y += h+1;
goto loop;
}
}
y++;
loop:;
}
al_save_bitmap(argv[2], inbmp);
}
/**
Saves a bitmap.
@param filename filename.
@return true on success.
*/
bool save(const char *filename) const {
return al_save_bitmap(filename, get());
}
static void save(void)
{
al_save_bitmap("logo.png", logo);
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *bmp, *tmp;
ALLEGRO_SHADER *horz_shader;
ALLEGRO_SHADER *vert_shader;
al_init();
al_install_keyboard();
al_init_image_addon();
display = al_create_display(480, 320);
bmp = al_load_bitmap("glow.png");
ALLEGRO_BITMAP *bg = al_load_bitmap("bg.png");
tmp = al_create_bitmap(
al_get_bitmap_width(bmp),
al_get_bitmap_height(bmp)
);
horz_shader = al_create_shader(ALLEGRO_SHADER_GLSL);
vert_shader = al_create_shader(ALLEGRO_SHADER_GLSL);
al_attach_shader_source(
horz_shader,
ALLEGRO_VERTEX_SHADER,
glsl_vertex_source
);
al_attach_shader_source(
horz_shader,
ALLEGRO_PIXEL_SHADER,
glsl_pixel_source_horz
);
al_link_shader(horz_shader);
al_attach_shader_source(
vert_shader,
ALLEGRO_VERTEX_SHADER,
glsl_vertex_source
);
al_attach_shader_source(
vert_shader,
ALLEGRO_PIXEL_SHADER,
glsl_pixel_source_vert
);
al_link_shader(vert_shader);
ALLEGRO_COLOR white = al_map_rgb(255, 255, 255);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA, white);
ALLEGRO_VERTEX *v;
v = new ALLEGRO_VERTEX[6*4];
v[0].x = 0;
v[0].y = 320;
v[0].z = 0;
v[0].u = 0;
v[0].v = 0;
v[0].color = white;
v[1].x = 0;
v[1].y = 0;
v[1].z = 0;
v[1].u = 0;
v[1].v = 1;
v[1].color = white;
v[2].x = 480;
v[2].y = 0;
v[2].z = 0;
v[2].u = 1;
v[2].v = 1;
v[2].color = white;
v[3].x = 0;
v[3].y = 320;
v[3].z = 0;
v[3].u = 0;
v[3].v = 0;
v[3].color = white;
v[4].x = 480;
v[4].y = 0;
v[4].z = 0;
v[4].u = 1;
v[4].v = 1;
v[4].color = white;
v[5].x = 480;
v[5].y = 320;
v[5].z = 0;
v[5].u = 1;
v[5].v = 0;
v[5].color = white;
al_set_shader_vertex_array(horz_shader, &v[0].x, sizeof(ALLEGRO_VERTEX));
al_set_shader_color_array(horz_shader, (unsigned char *)&v[0].color, sizeof(ALLEGRO_VERTEX));
al_set_shader_texcoord_array(horz_shader, &v[0].u, sizeof(ALLEGRO_VERTEX));
al_set_shader_vertex_array(vert_shader, &v[0].x, sizeof(ALLEGRO_VERTEX));
al_set_shader_color_array(vert_shader, (unsigned char *)&v[0].color, sizeof(ALLEGRO_VERTEX));
al_set_shader_texcoord_array(vert_shader, &v[0].u, sizeof(ALLEGRO_VERTEX));
float radius = 1;
float rinc = 4;
while (1) {
al_set_target_bitmap(tmp);
al_clear_to_color(al_map_rgba(0, 0, 0,0));
ALLEGRO_KEYBOARD_STATE s;
al_get_keyboard_state(&s);
if (al_key_down(&s, ALLEGRO_KEY_ESCAPE))
break;
radius += rinc;
if (rinc > 0 && radius >= 25) {
rinc = -rinc;
}
else if (rinc < 0 && radius < 1) {
rinc = -rinc;
}
al_set_shader_sampler(horz_shader, "t", bmp, 0);
al_set_shader_float(horz_shader, "img_width", al_get_bitmap_width(bmp));
al_set_shader_float(horz_shader, "radius", radius);
al_use_shader(horz_shader, true);
al_draw_bitmap(bmp, 0, 0, 0);
al_use_shader(horz_shader, false);
al_set_target_bitmap(al_get_backbuffer());
al_draw_bitmap(bg, 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE, white);
al_set_shader_sampler(vert_shader, "t", tmp, 0);
al_set_shader_float(vert_shader, "img_height", al_get_bitmap_height(bmp));
al_set_shader_float(vert_shader, "radius", radius);
al_use_shader(vert_shader, true);
al_draw_bitmap(tmp, 0, 0, 0);
al_use_shader(vert_shader, false);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA, white);
al_draw_bitmap(bmp, 0, 0, 0);
al_flip_display();
al_rest(0.016);
}
al_save_bitmap("bgxx.png", bg);
al_save_bitmap("tmpxx.png", tmp);
return 0;
}
int main(void)
{
int X_ROOMS=13;
int Y_ROOMS=16;
int X_ROOM_SIZE=256;
int Y_ROOM_SIZE=128;
int SCALE_FACTOR=4;
int X_TILE_SIZE=8;
int Y_TILE_SIZE=8;
int LAST_OBJECT=0;
int actid=0;
int error=0;
ALLEGRO_CONFIG *cfg;
ALLEGRO_BITMAP *bmp,*virt,*tmp=NULL;
ALLEGRO_DISPLAY *display;
ALLEGRO_KEYBOARD_STATE key;
ALLEGRO_FONT *font;
signed int xcursor=0;
signed int ycursor=0;
signed char x=0;
signed char y=0;
signed char finex=0;
signed char finey=0;
char finish=0;
ALLEGRO_COLOR black,white,red,color;
int scale_cursor_x=0;
int scale_cursor_y=0;
int i=0;
int a=0;
unsigned char r,g,b=0;
char pngfilename[20];
char *tmpbuf;
char buf[5];
char buf2[5];
/* Iniciar el rollo */
tmpbuf=(char *)malloc(sizeof(char)*X_ROOM_SIZE*Y_ROOM_SIZE);
memset(tmpbuf,0,sizeof(char)*X_ROOM_SIZE*Y_ROOM_SIZE);
al_init();
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
cfg=al_load_config_file("sacagraf.cfg");
if (cfg==NULL)
{
cfg=al_create_config();
al_add_config_section(cfg,"Ajustes");
al_add_config_section(cfg,"Objetos");
al_set_config_value(cfg,"Ajustes","Habitaciones en horizontal","13");
al_set_config_value(cfg,"Ajustes","Habitaciones en vertical","16");
al_set_config_value(cfg,"Ajustes","Ancho de la habitacion original en pixels","256");
al_set_config_value(cfg,"Ajustes","Alto de la habitacion original en pixels","128");
al_set_config_value(cfg,"Ajustes","Ancho minimo del caracter original","8");
al_set_config_value(cfg,"Ajustes","Alto minimo del caracter original","8");
al_set_config_value(cfg,"Ajustes","Factor de escalado","4");
al_set_config_value(cfg,"Objetos","Ultimo","0");
al_save_config_file("sacagraf.cfg",cfg);
}
X_ROOMS=atoi(al_get_config_value(cfg,"Ajustes","Habitaciones en horizontal"));
Y_ROOMS=atoi(al_get_config_value(cfg,"Ajustes","Habitaciones en vertical"));
X_ROOM_SIZE=atoi(al_get_config_value(cfg,"Ajustes","Ancho de la habitacion original en pixels"));
Y_ROOM_SIZE=atoi(al_get_config_value(cfg,"Ajustes","Alto de la habitacion original en pixels"));
SCALE_FACTOR=atoi(al_get_config_value(cfg,"Ajustes","Factor de escalado"));
X_TILE_SIZE=atoi(al_get_config_value(cfg,"Ajustes","Alto minimo del caracter original"));
Y_TILE_SIZE=atoi(al_get_config_value(cfg,"Ajustes","Ancho minimo del caracter original"));
LAST_OBJECT=atoi(al_get_config_value(cfg,"Objetos","Ultimo"));
actid=LAST_OBJECT;
al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_WINDOWED);
display=al_create_display(X_ROOM_SIZE*SCALE_FACTOR,192*SCALE_FACTOR);
bmp=al_load_bitmap("map.png");
virt=al_create_bitmap(X_ROOM_SIZE*SCALE_FACTOR,Y_ROOM_SIZE*SCALE_FACTOR);
font=al_load_ttf_font("proggy.ttf",6*SCALE_FACTOR,0);
al_install_keyboard();
black=al_map_rgb(0,0,0);
white=al_map_rgba_f(1,1,1,1);
red=al_map_rgba_f(1,0,0,0.7);
/* Que empiece la fiesta */
while(!finish)
{
al_get_keyboard_state(&key);
if (al_key_down(&key,ALLEGRO_KEY_ESCAPE))
{
finish=1;
}
if (al_key_down(&key,ALLEGRO_KEY_LCTRL))
{
finex=0;
finey=0;
if (al_key_down(&key,ALLEGRO_KEY_RIGHT))
{
x++;
if (x==X_ROOMS) x=X_ROOMS-1;
}
if (al_key_down(&key,ALLEGRO_KEY_LEFT))
{
x--;
if (x<0) x=0;
}
if (al_key_down(&key,ALLEGRO_KEY_UP))
{
y--;
if (y<0) y=0;
}
if (al_key_down(&key,ALLEGRO_KEY_DOWN))
{
y++;
if (y>Y_ROOMS-1) y=Y_ROOMS-1;
}
}
else if (al_key_down(&key,ALLEGRO_KEY_LSHIFT))
{
if (al_key_down(&key,ALLEGRO_KEY_RIGHT))
{
finex++;
if (finex>X_TILE_SIZE) finex=X_TILE_SIZE;
}
if (al_key_down(&key,ALLEGRO_KEY_LEFT))
{
finex--;
if (finex<-X_TILE_SIZE) finex=-X_TILE_SIZE;
}
if (al_key_down(&key,ALLEGRO_KEY_UP))
{
finey--;
if (finey<-Y_TILE_SIZE) finey=-Y_TILE_SIZE;
}
if (al_key_down(&key,ALLEGRO_KEY_DOWN))
{
finey++;
if (finey>Y_TILE_SIZE) finey=Y_TILE_SIZE;
}
}
else if (al_key_down(&key,ALLEGRO_KEY_ALT))
{
if (al_key_down(&key,ALLEGRO_KEY_RIGHT))
{
scale_cursor_x++;
//if (finex>8) finex=8;
}
if (al_key_down(&key,ALLEGRO_KEY_LEFT))
{
scale_cursor_x--;
//if (finex<0) finex=0;
}
if (al_key_down(&key,ALLEGRO_KEY_UP))
{
scale_cursor_y--;
//if (finey<0) finey=0;
}
if (al_key_down(&key,ALLEGRO_KEY_DOWN))
{
scale_cursor_y++;
//if (finey>8) finey=8;
}
}
else
{
if (al_key_down(&key,ALLEGRO_KEY_RIGHT))
{
xcursor+=X_TILE_SIZE*SCALE_FACTOR;
}
if (al_key_down(&key,ALLEGRO_KEY_LEFT))
{
xcursor-=X_TILE_SIZE*SCALE_FACTOR;
}
if (al_key_down(&key,ALLEGRO_KEY_UP))
{
ycursor-=Y_TILE_SIZE*SCALE_FACTOR;
}
if (al_key_down(&key,ALLEGRO_KEY_DOWN))
{
ycursor+=Y_TILE_SIZE*SCALE_FACTOR;
}
}
al_clear_to_color(black);
al_set_target_bitmap(virt);
//al_set_blender(ALLEGRO_ALPHA,ALLEGRO_INVERSE_ALPHA,white);
al_draw_bitmap_region(bmp,0+(x*X_ROOM_SIZE)+finex,0+(y*Y_ROOM_SIZE)+finey,X_ROOM_SIZE,Y_ROOM_SIZE,0,0,0);
al_set_target_bitmap(al_get_backbuffer(display));
al_draw_scaled_bitmap(virt,0,0,X_ROOM_SIZE,Y_ROOM_SIZE,0,0,X_ROOM_SIZE*SCALE_FACTOR,Y_ROOM_SIZE*SCALE_FACTOR,0);
al_draw_line(0,512,1024,512,white,0);
al_draw_textf(font,al_map_rgba(200,200,200,200),0,520,0,"mapa x: %d mapa y: %d habitacion nº: %d ajuste fino x: %d ajuste fijo y: %d",x,y,x+(y*13),finex,finey);
if (error)
{
al_draw_textf(font,al_map_rgba(200,200,200,200),0,540,0,"Patron repetido");
al_flip_display();
al_rest(1);
error=0;
}
if (al_key_down(&key,ALLEGRO_KEY_ENTER))
{
tmp=al_create_bitmap((X_TILE_SIZE*SCALE_FACTOR)+(X_TILE_SIZE*SCALE_FACTOR*scale_cursor_x),(Y_TILE_SIZE*SCALE_FACTOR)+(Y_TILE_SIZE*SCALE_FACTOR*scale_cursor_y));
al_set_target_bitmap(tmp);
al_draw_bitmap_region(al_get_backbuffer(display),xcursor,ycursor,(X_TILE_SIZE*SCALE_FACTOR*scale_cursor_x)+(X_TILE_SIZE*SCALE_FACTOR),(Y_TILE_SIZE*SCALE_FACTOR*scale_cursor_y)+(Y_TILE_SIZE*SCALE_FACTOR),0,0,0);
memset(tmpbuf,0,sizeof(char)*X_ROOM_SIZE*Y_ROOM_SIZE);
memset(buf,0,5);
for (i=0;i<(Y_TILE_SIZE*scale_cursor_y*SCALE_FACTOR)+(Y_TILE_SIZE*SCALE_FACTOR);i+=SCALE_FACTOR)
{
for (a=0;a<(X_TILE_SIZE*scale_cursor_x*SCALE_FACTOR)+(X_TILE_SIZE*SCALE_FACTOR);a+=SCALE_FACTOR)
{
color=al_get_pixel(tmp,a,i);
al_unmap_rgb(color,&r,&g,&b);
if (!r && !g && !b)
{
strcat(tmpbuf,"0");
}
else
{
strcat(tmpbuf,"1");
}
}
}
/* Ya está la secuencia del gráfico en tmpbuf, examinamos todas las secuencias anteriores */
error=0;
for (i=0;i<actid;i++)
{
memset(buf2,0,5);
sprintf(buf2,"%d",i);
if (!strcmp(al_get_config_value(cfg,"Objetos",buf2),tmpbuf))
{
error=i;
}
}
/* Si no hay secuencias repetidas lo grabamos */
if (!error)
{
sprintf(buf,"%d",actid);
al_set_config_value(cfg,"Objetos",buf,tmpbuf);
memset(pngfilename,0,20);
sprintf(pngfilename,"dec%d.png",actid);
al_save_bitmap(pngfilename,tmp);
actid++;
}
al_destroy_bitmap(tmp);
}
al_set_target_bitmap(al_get_backbuffer(display));
//al_set_blender(ALLEGRO_ALPHA,ALLEGRO_INVERSE_ALPHA,red);
al_draw_filled_rectangle(xcursor,ycursor,xcursor+((X_TILE_SIZE*SCALE_FACTOR)+(X_TILE_SIZE*SCALE_FACTOR*scale_cursor_x)),ycursor+((Y_TILE_SIZE*SCALE_FACTOR)+(Y_TILE_SIZE*SCALE_FACTOR*scale_cursor_y)),red);
al_flip_display();
al_rest(0.1);
}
memset(buf,0,5);
sprintf(buf,"%d",actid);
al_set_config_value(cfg,"Objetos","Ultimo",buf);
al_save_config_file("sacagraf.cfg",cfg);
al_destroy_font(font);
al_uninstall_keyboard();
al_destroy_bitmap(bmp);
al_destroy_bitmap(virt);
al_destroy_display(display);
al_destroy_config(cfg);
al_shutdown_ttf_addon();
al_shutdown_font_addon();
al_shutdown_image_addon();
al_shutdown_primitives_addon();
free(tmpbuf);
return 0;
}
int main(int argc, char **argv)
{
al_init();
al_init_image_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
ALLEGRO_BITMAP *tilemap = al_load_bitmap(argv[1]);
ALLEGRO_BITMAP *result = al_create_bitmap(1024, 1024);
al_set_target_bitmap(result);
al_clear_to_color(al_map_rgba(0, 0, 0, 0));
int tx = 0, ty = 0;
int mx = 0, my = 0;
int mapping[(512/16)*(2048/16)];
memset(mapping, 0, sizeof(mapping));
int i = 0;
mapping[i++] = 0;
mx = 16;
for (int y = 0; y < 2048/16; y++) {
int x;
if (y == 0) x = 1;
else x = 0;
for (; x < 512/16; x++) { // 1 == skip first alpha img
int ox = x * 16;
int oy = y * 16;
bool all_alpha = true;
// FIXME: tile index 96 is all alpha and still in the packed.png. keep for legacy reasons.
if (i == 96) {
all_alpha = false;
}
else {
for (int py = 0; py < 16; py++) {
for (int px = 0; px < 16; px++) {
ALLEGRO_COLOR pix = al_get_pixel(tilemap, px+ox, py+oy);
unsigned char r, g, b, a;
al_unmap_rgba(pix, &r, &g, &b, &a);
if (!(a == 0)) {
all_alpha = false;
break;
}
}
if (!all_alpha) break;
}
}
if (!all_alpha) {
mapping[(y*32)+x] = i++;
if (ox == 0 && oy == (3*16)) {
}
else {
al_draw_bitmap_region(tilemap, ox, oy,
16, 16, mx, my, 0);
}
mx += 16;
if (mx == 1024) {
mx = 0;
my += 16;
}
}
}
}
printf("int mapping[4096] = {\n\t");
for (int i = 0; i < 4096; i++) {
if ((i % 10) == 0)
printf(",\n\t");
else
printf(", ");
printf("%4d", mapping[i]);
}
printf("\n};\n");
al_save_bitmap("packed.png", result);
}
