void play_turn(void)
{
printf("Playing a turn.\n");
//main loop
done = 0;
while (!done)
{
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
printf("Exit request caught, exiting.\n");
exit(1);
break;
case SDL_MOUSEBUTTONUP:
xpos = event.button.x / TAILLE_CASE;
ypos = event.button.y / TAILLE_CASE;
render_map();
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_n: /* go to the next turn */
next_turn(g_ccx);
done = 1;
break;
case SDLK_q:
case SDLK_ESCAPE:
exit(0);
break;
case SDLK_RIGHT:
//moveCam(&camera, CAMERA_MOVE_SIZE, 0);
break;
case SDLK_UP:
//moveCam(&camera, 0, - CAMERA_MOVE_SIZE);
break;
case SDLK_DOWN:
//moveCam(&camera, 0, CAMERA_MOVE_SIZE);
break;
case SDLK_LEFT:
//moveCam(&camera, - CAMERA_MOVE_SIZE, 0);
break;
default: break;
}
// We don't break in order to redraw the map.
case SDL_VIDEOEXPOSE:
render_map();
break;
}
usleep(500); // Don't kill our CPU.
}
}
}
void draw_map(char *filename) {
cairo_surface_t *surface;
cairo_t *cr;
int width;
int height;
int rec_x;
int rec_y;
int rec_width;
int rec_height;
width = 1280;
height = 720;
rec_x = 320;
rec_y = 240;
rec_width = 30;
rec_height = 300;
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cr = cairo_create(surface);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_paint(cr);
render_map(cr);
cairo_surface_write_to_png(surface, filename);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
int loop_hook(t_event *e)
{
if (e->menu == MAIN_MENU)
control_menu(e);
else if (e->menu == GAME)
control_player(e);
else if (e->menu == TEXTURE_EDITOR)
control_edit_tex(e);
clear(e);
if (e->menu == GAME)
{
render_map(e);
render_minimap(e);
}
else if (e->menu == TEXTURE_EDITOR)
render_edit_tex(e);
mlx_put_image_to_window(e->mlx, e->win, e->img.addr, 0, 0);
if (e->menu == GAME)
mlx_string_put(e->mlx, e->win, 5, e->height - 22, 0xffffff,
"Arrow or WASD to move and rotate");
if (e->menu == MAIN_MENU)
render_menu(e);
else if (e->menu == TEXTURE_EDITOR)
render_edit_tex_gui(e);
return (0);
}
void EnvWidget::new_env(Engine::Environment * _e) {
env = _e;
if(env!=nullptr) {
map = env->getMap();
}
render_map();
emit this->map_changed();
}
void MapViewer::render() {
CHECK_NOTNULL(map);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render_map();
render_objects(false);
render_sprites();
render_objects(true);
render_gui();
}
void init_game(void)
{
printf("GUI Initialization...\n");
if (TTF_Init() == -1)
{
fprintf(stderr, "TTF Initlization error: %s\n", TTF_GetError());
exit(1);
}
font_small = TTF_OpenFont(IMG_PREFIX "font.ttf", 10);
font_big = TTF_OpenFont(IMG_PREFIX "font.ttf", 14);
if (!font_small || !font_big)
{
fprintf(stderr, "Unable to open TTF font: %s\n", TTF_GetError());
exit(1);
}
screen = window_init();
if(!screen)
{
fprintf(stderr, "Unable to open display. Aborting.\n");
exit(1);
}
SDL_EnableKeyRepeat(100, 300);
sprites = sprites_init();
if(!sprites)
{
fprintf(stderr, "Unable to initalize sprites. Aborting.\n");
exit(1);
}
color_black = SDL_MapRGB(screen->format, 0, 0, 0);
game_board = MySurfaceCreate(taille_carte_x() * TAILLE_CASE + 2, taille_carte_y() * TAILLE_CASE + 2);
game_background = background_init(taille_carte_x(), taille_carte_y());
if(!game_background)
{
fprintf(stderr, "Unable to load background.\n");
exit(1);
}
init_jeu(&jeu);
sprites = sprites_init();
nouveau_tour(&jeu);
render_map();
}
static void render_queued(WholeSpace *priv) {
int queue_length = get_queue_length(priv);
while (queue_length) {
blk_report_t *cur_rep = blk_rep_read(priv);
update_blocks_info(priv, cur_rep);
queue_length--;
}
render_update_stats(priv);
render_map(priv);
doupdate();
}
void update_camera(int tile_x, int tile_y,
channel_t* temperature_channel,
channel_t* humidity_channel,
channel_t* spirit_channel) {
if (tile_x != last_cx || tile_y != last_cy) {
last_cx = tile_x;
last_cy = tile_y;
render_map(tile_x, tile_y,
temperature_channel,
humidity_channel,
spirit_channel);
}
}
int
main (int argc, char *argv[])
{
QFile *bspfile;
bsp_t *bsp;
image_t *image;
/* Enough args? */
if (argc < 3) {
show_help ();
return 1;
}
/* Setup options */
def_options (&options);
get_options (&options, argc, argv);
show_options (&options);
bspfile = Qopen (options.bspf_name, "rbz");
if (bspfile == NULL) {
fprintf (stderr, "Error opening bsp file %s.\n", options.bspf_name);
return 1;
}
bsp = LoadBSPFile (bspfile, Qfilesize (bspfile));
Qclose (bspfile);
image = render_map (bsp);
BSP_Free (bsp);
/* Write image */
switch (options.outf_type) {
case 0:
write_pcx (image);
break;
case 1:
write_png (image);
break;
}
printf ("File written to %s.\n", options.outf_name);
/* Close, done! */
free (image->image);
free (image);
return 0;
}
/*render the game data*/
void render( struct Game * g)
{
SDL_Texture *map_bmp;
SDL_Rect map_drect;
/*drSDL_Rect map_rect;aw code here*/
map_drect.x = 0;
map_drect.y = 0;
map_drect.w = g->screen_width;
map_drect.h = g->screen_height;
SDL_RenderClear(g->r);
if (!(map_bmp = render_map(g))) {
fatal_error(SDL_GetError());
}
SDL_RenderCopy(g->r, map_bmp, NULL, &map_drect);
SDL_RenderPresent(g->r);
}
int main()
{
// Ressources
unsigned long t_debut, t_fin;
float dt, waitShoot = 0;
BITMAP *buffer;
int fin = 0, v = 200;
Map *map;
DepthList *depthList;
Rect screen_pos, map_pos;
Actor *joueur;
// Initialisation
fprintf(stderr,"Initialisation ...\n");
timeBeginPeriod(1);
set_uformat(U_ASCII);
set_color_depth(32);
allegro_init();
install_keyboard();
install_mouse();
srand(time(NULL));
if(set_gfx_mode(GFX_AUTODETECT_WINDOWED, 1024, 768, 0, 0))
ERREUR("Echec du lancement du mode graphique.");
buffer = create_bitmap(SCREEN_W, SCREEN_H);
resman_loadSprites();
fprintf(stderr,"Chargement des ressources ...\n");
map = new_map("media/map/test1");
map_pos.x = map_pos.y = 0;
map_pos.w = map->w;
map_pos.h = map->h;
actList = new_glist();
root = new_tree(map_pos);
map_addEntities(map, actList, root);
depthList = new_dlist();
screen_pos.w = SCREEN_W;
screen_pos.h = SCREEN_H;
// Ajout du joueur
joueur = actor_addJoueur(actList, root, 500, 500);
// Intro
debut();
// Boucle principale
fprintf(stderr,"Debut !\n");
t_debut = timeGetTime();
while(!fin)
{
// Gestion clavier
if(key[KEY_ESC])
{
fin = 1;
}
if(key[KEY_W])
{
joueur->vit_y = -v;
joueur->direction_regard = HAUT;
joueur->etat = ETAT_MARCHE;
}
else if(key[KEY_S])
{
joueur->vit_y = v;
joueur->direction_regard = BAS;
joueur->etat = ETAT_MARCHE;
}
else
joueur->vit_y = 0;
if(key[KEY_A])
{
joueur->vit_x = -v;
joueur->direction_regard = GAUCHE;
joueur->etat = ETAT_MARCHE;
}
else if(key[KEY_D])
{
joueur->vit_x = v;
joueur->direction_regard = DROITE;
joueur->etat = ETAT_MARCHE;
}
else
joueur->vit_x = 0;
if(joueur->vit_x != 0 && joueur->vit_y != 0)
{
joueur->vit_x /= sqrt(2);
joueur->vit_y /= sqrt(2);
}
if(!key[KEY_W] && !key[KEY_D] && !key[KEY_S] && !key[KEY_A])
joueur->etat = ETAT_REPOS;
if(key[KEY_Q])
{
if(waitShoot <= 0)
{
waitShoot = .1;
actor_addTree(actList, root, mouse_x + screen_pos.x, mouse_y + screen_pos.y);
}
}
waitShoot -= dt;
if(mouse_b&1)
{
float vx, vy, v;
if(waitShoot <= 0)
{
waitShoot = .3;
vx = mouse_x - (joueur->pos_x - screen_pos.x);
vy = mouse_y - (joueur->pos_y - screen_pos.y);
v = sqrt(vx*vx + vy*vy);
vx = vx/v;
vy = vy/v;
actor_addMissile(actList, root, joueur->pos_x + vx*joueur->w*1.5, joueur->pos_y + vy*joueur->h*1.5, vx*300, vy*300);
}
}
if(key[KEY_P])
{
FILE *fd = fopen("arbres.txt", "w+");
Actor *act;
glist_startIter(actList);
while(!glist_endIter(actList))
{
act = glist_getCurrentData(actList);
if(act->type == ACT_TREE)
fprintf(fd, "%d\n%d\n", (int) act->pos_x, (int) act->pos_y);
glist_iter(actList);
}
fclose(fd);
}
// Double buffer
clear_bitmap(buffer);
render_map(buffer, map, screen_pos.x, screen_pos.y);
// Mises à jour
resman_updateSprites(&dt);
actor_spawnMonster(actList, root);
actor_ia(actList, joueur);
// Deplacement
glist_startIter(actList);
while(!glist_endIter(actList))
{
actor_update(glist_getCurrentData(actList), map_pos, map, dt);
if( ((Actor*) glist_getCurrentData(actList))->deleting)
{
glist_remCell(actList, glist_getCurrentId(actList));
}
else
glist_iter(actList);
}
// Cadrage ecran
screen_pos.x = joueur->pos_x - SCREEN_W/2;
screen_pos.y = joueur->pos_y - SCREEN_H/2;
// Collision
tree_collisionDetection(root);
// Affichage
tree_update(root);
dlist_getActorsFromTree(depthList, root, screen_pos);
dlist_update(depthList, screen_pos);
dlist_blit(depthList, buffer, screen_pos);
draw_cursor(buffer);
textprintf_centre_ex(buffer, font, SCREEN_W/2, 5, makecol(0, 0, 0), makecol(255, 0, 0), " Vies restantes : %d | Score : %d ", joueur->vie, score);
// Rafraichissement écran
vsync();
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
// Gestion du temps
t_fin = timeGetTime();
dt = ((float)t_fin - t_debut)/1000;
t_debut = t_fin;
// Test fin de jeu
if(joueur->deleting)
fin = 1;
resman_freeList();
}
// Game over
gameover();
// Fin
timeEndPeriod(1);
delete_map(map);
del_tree(root);
del_dlist(depthList);
del_glist(actList);
destroy_bitmap(buffer);
resman_freeSprites();
allegro_exit();
return 0;
}
void Engine::render() {
render_map();
render_messages();
render_info();
doupdate();
}
int main(int argc, char *argv[])
{
DATAFILE *datf;
BITMAP *scrFlip;
BITMAP *scrMap;
PALETTE pal;
WINDOW *winInfo;
long frames = 0L;
float start_time, end_time;
MAP *map, *overlay;
int x = 0, y = 0;
int old_x = -1, old_y = -1;
int dx = 1, dy = 1;
int view_w, view_h;
int do_idle = 1;
char s[128];
// Default screen resolution to 320x200.
screen_width = 320;
screen_height = 200;
// Read command line args. Set screen size accordingly.
if (argc > 2)
{
screen_width = atoi(argv[1]);
screen_height = atoi(argv[2]);
}
right_size = 0;
bottom_size = 0;
printf("screen: %dX%d\n", screen_width, screen_height);
// Initialize Allegro. Great library!
allegro_init();
install_timer();
install_keyboard();
// Set graphics mode.
if (set_gfx_mode(GFX_AUTODETECT, screen_width, screen_height, 0, 0) == -1)
{
printf("Cannot set video mode to %d, %d.\n", screen_width, screen_height);
return 1;
}
// load comic font from ex4.
datf = load_datafile_object("ex.dat", "comic12");
if (datf == NULL)
{
allegro_exit();
printf("Error loading ex.dat\n");
return 1;
}
text_mode(-1);
// load map
//printf("loading map\n");
map = load_map("tile1.wmp", "tile1.spr", pal);
if (map == NULL)
{
allegro_exit();
printf("Error loading map file.\n");
return 1;
}
// load overlay
//printf("loading overlay\n");
overlay = load_map("tile1ovr.wmp", NULL, NULL);
if (overlay == NULL)
{
allegro_exit();
printf("Error loading overlay file.\n");
return 1;
}
map_settileset(overlay, map->tileset);
// Allocate buffers for our rendering.
//printf("allocating buffers\n");
scrFlip = create_bitmap(SCREEN_W, SCREEN_H);
clear(scrFlip);
scrMap = create_bitmap(SCREEN_W + map->t_width*2, SCREEN_H + map->t_height*2);
// set palette
//printf("setting palette\n");
gui_setpalette(pal);
// Build rgb_table.
text_mode(makecol8(0, 0, 0));
textout_centre(screen, font, "Building RGB table.", SCREEN_W>>1, 10, 100);
create_rgb_table(&rgb_table, pal, rgb_table_callback);
rgb_map = &rgb_table;
// Build lighting table.
text_mode(makecol8(0, 0, 0));
textout_centre(screen, font, "Building lighting table.", SCREEN_W>>1, 10, 100);
create_light_table(&light_table, pal, 64, 64, 64, rgb_table_callback);
// Build translucency table.
text_mode(makecol8(0, 0, 0));
textout_centre(screen, font, "Building translucency table.", SCREEN_W>>1, 10, 100);
create_trans_table(&trans_table, pal, 128, 128, 128, rgb_table_callback);
color_map = &trans_table;
// initialize gui
gui_initialize(&light_table, &trans_table);
// set map and overlay color tables
map_settables(map, &trans_table, &light_table);
map_settables(overlay, &trans_table, &light_table);
// create info window
winInfo = gui_create_window(128, 200, WB_THICK, WD_TRANSLUCENT);
gui_move_window(winInfo, SCREEN_W-winInfo->window.w, 0);
// set up vars.
view_w = scrMap->w/map->t_width;
view_h = scrMap->h/map->t_height;
// setup time_to_blit interrupt.
LOCK_VARIABLE(time_to_blit);
LOCK_FUNCTION(time_to_blit_timer);
install_int_ex(time_to_blit_timer, BPS_TO_TIMER(30));
missed_frames = 0;
// main loop.
start_time = clock();
while (1)
{
idle_time = 0;
if (do_idle)
while (!time_to_blit) idle_proc(); // lock it in at around 30 fps.
time_to_blit = 0;
if (idle_time < lowest_idle)
lowest_idle = idle_time;
if (idle_time > highest_idle)
highest_idle = idle_time;
// render map
if (map_getx_tile(map, x) != old_x || map_gety_tile(map, y) != old_y)
{
render_map(map, scrMap, 0, 0, x, y, view_w, view_h);
render_map(overlay, scrMap, 0, 0, x, y, view_w, view_h);
old_x = map_getx_tile(map, x);
old_y = map_gety_tile(map, y);
}
blit(scrMap, scrFlip, map_getx_offset(map, x), map_gety_offset(map, y), 0, 0, SCREEN_W-right_size, SCREEN_H-bottom_size);
gui_clear_window(winInfo, makecol8(0, 0, 0));
gui_textout_centre_window(winInfo, "Map Demo", 2, makecol8(255, 0, 0), -1);
sprintf(s, "X: %d, Y: %d", x, y);
gui_textout_centre_window(winInfo, s, 14, makecol8(0, 0, 255), -1);
sprintf(s, "DX: %d, DY: %d", dx, dy);
gui_textout_centre_window(winInfo, s, 24, makecol8(0, 0, 255), -1);
sprintf(s, "X Ofs: %d", map_getx_offset(map, x));
gui_textout_centre_window(winInfo, s, 34, makecol8(0, 0, 255), -1);
sprintf(s, "Y Ofs: %d", map_gety_offset(map, y));
gui_textout_centre_window(winInfo, s, 44, makecol8(0, 0, 255), -1);
sprintf(s, "Idle: %d", idle_time);
gui_textout_centre_window(winInfo, s, 64, makecol8(0, 255, 255), -1);
sprintf(s, "Missed: %d", missed_frames);
gui_textout_centre_window(winInfo, s, 74, makecol8(0, 255, 255), -1);
gui_draw_window(winInfo, scrFlip);
// blit it
//vsync();
blit(scrFlip, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
// check keys
if (key[KEY_SPACE])
{
break;
}
if (key[KEY_LSHIFT])
do_idle = 0;
else
do_idle = 1;
if (key[KEY_CONTROL])
gui_set_window_styles(winInfo, -1, WD_BLIT);
else
gui_set_window_styles(winInfo, -1, WD_TRANSLUCENT);
if (key[KEY_PGDN])
{
dx--;
if (dx < 1)
dx = 1;
dy--;
if (dy < 1)
dy = 1;
}
if (key[KEY_PGUP])
{
dx++;
dy++;
}
if (key[KEY_RIGHT])
{
x+=dx;
if (x > (map->w_width-1) - SCREEN_W)
{
x-=dx;
}
}
if (key[KEY_DOWN])
{
y+=dy;
if (y > (map->w_height-1) - SCREEN_H)
{
y-=dy;
}
}
if (key[KEY_LEFT])
{
x-=dx;
if (x < 0)
{
x = 0;
}
}
if (key[KEY_UP])
{
y-=dy;
if (y < 0)
{
y = 0;
}
}
// Increment frame counter.
frames++;
}
end_time = clock();
// Clean up.
unload_datafile_object(datf);
destroy_map(map);
overlay->tileset=NULL;
destroy_map(overlay);
destroy_bitmap(scrFlip);
destroy_bitmap(scrMap);
// Close down allegro.
allegro_exit();
// Report.
printf("Tile Map, Copyright 1997 by Scott Deming.\n");
printf("\nHow'd we do?\n");
printf("===============================================================================\n");
printf(" Time: %3.2f\n", (float) ((end_time-start_time) / 100));
printf("Frames: %lu\n", frames);
printf(" FPS: %3.2f\n", (float) (float) frames / (float) ((end_time-start_time) / 100));
printf("Missed: %d\n", missed_frames);
printf(" Idle: %d (lowest was %d, highest %d)\n", idle_time, lowest_idle, highest_idle);
printf("Screen: %dX%d\n", screen_width, screen_height);
printf("-------------------------------------------------------------------------------\n");
printf("Note: If \"Idle\" starts to get close to zero then things should be done to\n");
printf(" speed things up. When idle proc hits zero, we'll start missing frames\n");
printf(" (indicated by \"Missed\") and things can start to get a bit jerky.\n");
printf(" If \"Missed\" is greater than 0, start optimizing.\n");
printf(" If you turned off the 30 fps timer halt then your lowest idle will be 0.\n");
return 0;
}
void render_shot(struct shot *shot, int s_id)
{
struct player *shoot_pl = dyn_arr_get(&Players, s_id);
center_camera(shoot_pl->pos);
clear();
render_map();
render_tanks();
debug_d(1, "RenderShotX", shoot_pl->pos.x);
debug_d(1, "RenderShotY", shoot_pl->pos.y);
debug_d(1, "RenderShot Angle", shot->angle);
debug_d(1, "RenderShot Power", shot->power);
int input_ch;
struct f_pair init_v = initial_v(shot);
struct f_pair acc = acceleration();
/* position (x,y) must be either double or float */
struct f_pair init_pos = map_pos_to_float(shoot_pl->pos);
timeout(SHOOT_TIMEOUT);
float t=1;
/* this part is duplicated, because it's initial */
struct f_pair b_pos = shot_pos(init_pos, init_v, acc, t);
struct map_position map_pos = round_to_map_pos(b_pos);
draw_bullet(dx, dy, map_pos.x, map_pos.y);
refresh();
/* end */
input_ch = getch();
if (input_ch != ERR)
quit_key(input_ch);
while (loc_player->state) {
/* remove drew bullet */
draw_blank_bullet(dx, dy, map_pos.x, map_pos.y);
debug_d(1, "BulletX", map_pos.x);
debug_d(1, "BulletY", map_pos.y);
t+=(float)SHOOT_TIMEOUT/100;
b_pos = shot_pos(init_pos, init_v, acc, t);
map_pos = round_to_map_pos(b_pos);
/* draw a new one */
switch (draw_bullet(dx, dy, map_pos.x, map_pos.y)) {
case SCR_OK:
break;
case SCR_UP:
case SCR_DOWN:
case SCR_LEFT:
case SCR_RIGHT:
center_camera(map_pos);
clear();
render_map();
render_tanks();
draw_bullet(dx, dy, map_pos.x, map_pos.y);
break;
default:
debug_s(5, "ScreenMove(shot)", "Wrong ScrMove value");
}
refresh();
if (map_pos.x > map_data->length || map_pos.x < 0)
break;
if (t > g_impact_t) {
b_pos = shot_pos(init_pos, init_v, acc, g_impact_t);
map_pos = round_to_map_pos(b_pos);
center_camera(map_pos);
clear();
render_map();
render_tanks();
draw_bullet_explosion(dx, dy, map_pos.x, map_pos.y);
refresh();
break;
}
/* let player see the change */
input_ch = getch();
if (input_ch != ERR)
quit_key(input_ch);
}
input_ch = getch(); // let players
input_ch = getch(); // see the explosion
struct player *c_player = dyn_arr_get(&Players, camera_focus);
center_camera(c_player->pos);
/* SCR_ALL is already in screen update queue by center_camera*/
timeout(DEFAULT_TIMEOUT); //back to original
}
void update_world() {
render_map();
check_collisions();
}
static void button_click(gpointer data)
{
if((size_t)data == ITEM_SIGNAL_OPEN)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".dat", file) == 0)
{
add_buffer();
image_load_map(file);
}
else if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0)
{
GError * err = NULL;
add_buffer();
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox)))
generate_image_dithered(mdata[current_buffer], 128, 128,gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
else
generate_image(mdata[current_buffer], 128, 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
if(err != NULL)
{
information("Error while loading image file!");
printf("%s\n", err->message);
g_error_free(err);
}
set_image();
}
else if(srecmpend(".imtm", file) == 0)
{
add_buffer();
load_raw_map(file, mdata[current_buffer]);
set_image();
}
else
information("File format not supported!");
}
gtk_widget_destroy(dialog);
}
if((size_t)data == ITEM_SIGNAL_OPEN_GRID_IMAGE)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0)
{
GError * err = NULL;
int width = 1, height = 1;
int i, j;
int pi, pj;
{
GtkWidget * dialog = gtk_dialog_new_with_buttons("Split Image",
GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_OK"),
GTK_RESPONSE_ACCEPT, NULL);
GtkWidget * content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget * hbox;
GtkWidget * label;
#ifdef GTK2
hbox = gtk_hbox_new(FALSE, 0);
#else
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
label = gtk_label_new("width");
GtkWidget * width_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(width_entry), "1");
gtk_container_add(GTK_CONTAINER(hbox), width_entry);
gtk_container_add(GTK_CONTAINER(hbox), label);
gtk_container_add(GTK_CONTAINER(content_area), hbox);
#ifdef GTK2
hbox = gtk_hbox_new(FALSE, 0);
#else
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
label = gtk_label_new("height");
GtkWidget * height_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(height_entry), "1");
gtk_container_add(GTK_CONTAINER(hbox), height_entry);
gtk_container_add(GTK_CONTAINER(hbox), label);
gtk_container_add(GTK_CONTAINER(content_area), hbox);
gtk_widget_show_all(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
width = atoi((char *)gtk_entry_get_text(GTK_ENTRY(width_entry)));
height = atoi((char *)gtk_entry_get_text(GTK_ENTRY(height_entry)));
}
gtk_widget_destroy(dialog);
}
unsigned char tmp_buffer[width * height * 128 * 128];
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox)))
generate_image_dithered(tmp_buffer, width * 128, height * 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
else
generate_image(tmp_buffer, width * 128, height * 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
if(err != NULL)
{
information("Error while loading image file!");
printf("%s\n", err->message);
g_error_free(err);
}
for(i = 0; i < width; i++)
for(j = 0; j < height; j++)
{
add_buffer();
for(pi = 0; pi < 128; pi++)
for(pj = 0; pj < 128; pj++)
{
int buffer_i, buffer_j;
buffer_i = i * 128 + pi;
buffer_j = j * 128 + pj;
mdata[current_buffer][pi + pj * 128] =
tmp_buffer[buffer_i + (width * 128) * buffer_j];
}
}
set_image();
}
else
information("File format not supported!");
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_SAVE)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
if(srecmpend(".dat", file) == 0)
{
save_map(file);
sprintf(last_file, "%s", file);
}
}
gtk_widget_destroy(dialog);
printf("bracket cleared\n");
}
else if((size_t)data == ITEM_SIGNAL_SAVE_INCREMENT)
{
int i = 0;
char * tmp = last_file;
char * basename_s, * dirname_s;
if(mdata[current_buffer] == NULL)
return;
basename_s = custom_basename(tmp);
dirname_s = last_file;
if(basename_s != NULL)
{
tmp = basename_s;
if(strncmp("map_", tmp, 4) == 0)
{
tmp += 4;
i = strtol(tmp, &tmp, 10) + 1;
if(strcmp(".dat", tmp) == 0)
{
#ifdef OS_LINUX
sprintf(last_file, "%s/map_%i.dat", dirname_s, i);
#else
sprintf(last_file, "%s\\map_%i.dat", dirname_s, i);
#endif
save_map(last_file);
/* save_map(last_file); */
}
}
}
}
else if((size_t)data == ITEM_SIGNAL_SAVE_ALL)
{
int old_current_buffer = current_buffer;
GtkWidget * dialog;
int i = 0;
char * tmp;
char * basename_s, * dirname_s;
/* Gets first file name */
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat");
if(gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".dat", file) != 0) {
gtk_widget_destroy(dialog);
return;
}
sprintf(last_file, "%s", file);
gtk_widget_destroy(dialog);
/* Gets the directory and the file name */
basename_s = custom_basename(last_file);
dirname_s = malloc(strlen(last_file)+8); /* 8 is a magic number! Naa jk, it is just to make sure we don't overflow */
if (dirname_s == NULL)
return;
strcpy(dirname_s, last_file);
memset(dirname_s+(strlen(dirname_s)-strlen(basename_s)), strlen(basename_s), '\0');
if(basename_s == NULL)
return;
tmp = basename_s;
/* Gets the number in the file name, 10 for 'map_10.dat' */
if(strncmp("map_", tmp, 4) != 0)
return;
tmp += 4;
i = strtol(tmp, &tmp, 10);
/* Saves all the buffers */
for (current_buffer = 0; current_buffer < BUFFER_COUNT; current_buffer++) {
if(mdata[current_buffer] == NULL)
break;
#ifdef OS_LINUX
sprintf(last_file, "%s/map_%i.dat", dirname_s, i);
#else
sprintf(last_file, "%s\\map_%i.dat", dirname_s, i);
#endif
save_map(last_file);
i++;
}
/* Restores the selection to the right buffer and frees the allocated memory */
current_buffer = old_current_buffer;
free(dirname_s);
}
else if((size_t)data == ITEM_SIGNAL_EXPORT_IMAGE)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Export Image of Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.png");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
unsigned char * data = malloc(128 * 128 * 3);
int i;
for(i = 0; i < 128 * 128; i++)
{
if(mdata[current_buffer][i] > 3)
{
data[i * 3] = colors[mdata[current_buffer][i]].r;
data[i * 3 + 1] = colors[mdata[current_buffer][i]].g;
data[i * 3 + 2] = colors[mdata[current_buffer][i]].b;
}
else
{
int x = i % 128, y = i / 128;
x /= 4;
y /= 4;
data[i * 3] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 1] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 2] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
}
}
GdkPixbuf * spixbuf = image_from_data(data, 0);
free(data);
GError * err = NULL;
gdk_pixbuf_save(spixbuf, file, "png", &err, "compression", "9", NULL);
if (err != NULL)
{
/* Report error to user, and free error */
printf("Error while saving: %s\n", err->message);
g_error_free(err);
}
g_object_unref(spixbuf);
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_SAVE_RM)
{
if(mdata == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.imtm");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
save_raw_map(file, mdata[current_buffer]);
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_PALETTE)
{
add_buffer();
generate_palette(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_RANDOM_NOISE)
{
add_buffer();
generate_random_noise(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_MANDELBROT)
{
add_buffer();
generate_mandelbrot(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_JULIA)
{
add_buffer();
generate_julia(mdata[current_buffer], 0.5, 0.5);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD)
{
GtkClipboard * clipboard;
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_image(clipboard, clipboard_callback, NULL);
}
else if((size_t)data == ITEM_SIGNAL_WORLD_RENDER_ITEM)
{
GtkWidget * dialog = gtk_dialog_new_with_buttons("Render World Map",
GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_OK"),
GTK_RESPONSE_ACCEPT,
_("_Cancel"),
GTK_RESPONSE_REJECT, NULL);
GtkWidget * content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget * scale_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(scale_entry), "3");
gtk_container_add(GTK_CONTAINER(content_area), scale_entry);
GtkWidget * xpos_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(xpos_entry), "0");
gtk_container_add(GTK_CONTAINER(content_area), xpos_entry);
GtkWidget * zpos_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(zpos_entry), "0");
gtk_container_add(GTK_CONTAINER(content_area), zpos_entry);
GtkWidget * directory_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(directory_entry), MINECRAFT_PATH);
gtk_container_add(GTK_CONTAINER(content_area), directory_entry);
gtk_widget_show_all(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
int scale = atoi((char *)gtk_entry_get_text(GTK_ENTRY(scale_entry)));
char * path = (char *)gtk_entry_get_text(GTK_ENTRY(directory_entry));
int x = atoi((char *)gtk_entry_get_text(GTK_ENTRY(xpos_entry)));
int z = atoi((char *)gtk_entry_get_text(GTK_ENTRY(zpos_entry)));
int rs = pow(2, scale) * 128;
block_info_t * blocks = read_region_files(path, x - (rs / 2), z - (rs / 2),
rs, rs);
add_buffer();
render_map(blocks, mdata[current_buffer], scale);
free(blocks);
mdata_info[current_buffer].scale = scale;
mdata_info[current_buffer].xpos = x;
mdata_info[current_buffer].zpos = z;
mdata_info[current_buffer].dimension = 0;
set_image();
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_CLEAN)
{
while(mdata[1] != NULL)
{
remove_buffer(0);
}
/* set_image(); */
}
else if((size_t)data == ITEM_SIGNAL_QUIT)
{
kill_window(NULL, NULL, NULL);
}
else
printf("Unhandeled button press: %i\n", (int)(size_t)data);
}
void next_turn_callback(void)
{
nouveau_tour(&jeu);
render_map();
}
