void add_change(){
num_changes++;
if(num_changes==NEEDED_CHANGES){
num_changes=0;
save_map(map_file_name);
}
}
int _uniquePaths(int m, int n, vector<vector<int> > &obstacleGrid) {
if (0 == m || 0 == n) {
return 0;
}
vector<vector<int> > save_map(n, vector<int>(m, -1));
return _index_path(0, 0, m, n, save_map, obstacleGrid);
}
int main(int argc, char **argv)
{
char *lines;
t_board c;
t_piece p;
t_player t;
int i = 0;
int fd;
t_test result;
fd = open("text", O_WRONLY | O_APPEND);
while (ft_get_next_line(0, &lines) > 0)
{
if (ft_strcmp("Plateau", lines))
{
ft_get_next_line(0, &lines);
c.map = save_map(&lines, &c);
}
if (ft_strcmp("Piece", lines))
p.piece = save_piece(&lines, &p);
ft_search(c.map, &t, &c);
i++;
}
place_piece(p, c, t);
close (fd);
}
void save_map_file()
{
OPENFILENAME ofn;
char szFileName[MAX_PATH], temp[MAX_PATH];
ZeroMemory (&ofn, sizeof (ofn));
szFileName[0] = 0;
ofn.lStructSize = sizeof (ofn);
ofn.hwndOwner = 0;
ofn.lpstrFile = szFileName;
ofn.nMaxFile = MAX_PATH;
#ifdef LIBZW
ofn.lpstrFilter = "Compressed Map (*.elm.gz)\0*.elm.gz\0\0";
ofn.lpstrDefExt = "elm.gz";
#else //LIBZW
ofn.lpstrFilter = "Eternal Lands Map (*.elm)\0*.elm\0\0";
ofn.lpstrDefExt = "elm";
#endif //LIBZW
strcpy(temp,exec_path);
strcat(temp,"\\maps\\");
ofn.lpstrInitialDir = temp;
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY |
OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR;
if (GetSaveFileName (&ofn))
{
char proper_path[128];
get_proper_path ( szFileName, exec_path, proper_path, sizeof (proper_path) );
save_map(proper_path);
}
}
int minPathSum(vector<vector<int> > &grid) {
if (0 == grid.size() || 0 == grid.at(0).size()) {
return 0;
}
vector<vector<int> > save_map(grid.size(), vector<int>(grid.at(0).size(), -1));
return _minPathSum(0, 0, grid, save_map);
}
int save_all_map(void)
{
int x,y,z;
char info[160];
char *txt;
if ((z=check_map(&x,&y))!=0)
{
WINDOW *w;
unselect_map();
if ((w=find_window(tool_bar))!=NULL) close_window(w);
tool_sel=30;
create_map_win(-1);
open_sector_win();
jdi_na_sektor(x);
}
sprintf(info,"Chyba %02d na pozici %d:%d",-z,x,y);
switch (z)
{
case -1:msg_box(info,'\01',"Chyb� definice st�ny!","OK",NULL);break;
case -2:msg_box(info,'\01',"Chodba vede do neexistuj�c�ho sektoru!","OK",NULL);break;
case -3:msg_box(info,'\01',"Schody jsou �patn� spojen� se sousedn�m� sektory!","OK",NULL);break;
case -4:msg_box(info,'\01',"Ud�lost v neexistuj�c�m sektoru!","OK",NULL);break;
}
if (!backup)
{
create_backup(filename);
create_backup(SHOP_NAME);
create_backup(ITEMS_DAT);
create_backup(MOB_FILE);
create_backup(MOB_SOUND);
backup=1;
}
if (save_map(filename))
{
sprintf(info,"Nedok��u ulo�it soubor %s.",filename);
msg_box("Chyba I/O",'\01',info,"!Panika!",NULL);
}
else txt=pripona(filename,TXT);
save_items();
if (_access(txt,0)!=0)
{
FILE *f;
f=fopen(txt,"w");
if (f) {
fputs("-1\n",f);
fclose(f);
}
}
if (!mglob.local_monsters)
{
save_mobs();
save_sound_map();
}
save_all_shops();
validate_sound_map();
return z;
}
int save( char map[MAP_HSIZE][MAP_WSIZE], int nlevel ){
char file[30];
sprintf( file, "data/levels/%02i", nlevel );
if( save_map( file, map ) ){
curs_set( FALSE );
msgbox( "Saved successfully!" );
curs_set( TRUE );
return 1;
} else {
curs_set( FALSE );
msgbox( "ERROR: Unable to open file for writing!" );
curs_set( TRUE );
return 0;
}
}
int output_map(const char *name, const char *prefix, const char *suffix, enum map type) {
char *filename;
int ret;
filename = malloc((strlen(prefix) + 1 + strlen(suffix) + 1) * sizeof(char));
if (filename == NULL) return -ENOMEM;
if (sprintf(filename, "%s.%s", prefix, suffix) <= 0) {
free(filename);
BUG();
}
ret = save_map(name, type, filename);
free(filename);
return ret;
}
int
ntk_save_maps(void)
{
debug(DBG_NORMAL, "Saving the internal map");
save_map(me.int_map, me.cur_node, server_opt.int_map_file);
#ifdef DEBUG
debug(DBG_NORMAL, "Saving the border nodes map");
save_bmap(me.bnode_map, me.bmap_nodes, me.ext_map, me.cur_quadg,
server_opt.bnode_map_file);
#endif
debug(DBG_NORMAL, "Saving the external map");
save_extmap(me.ext_map, MAXGROUPNODE, &me.cur_quadg,
server_opt.ext_map_file);
return 0;
}
void
process_input (void)
{
SDL_Event event;
int key;
SDLMod mod;
while (SDL_PollEvent (&event)) {
key = event.key.keysym.sym;
mod = event.key.keysym.mod;
switch (event.type) {
case SDL_QUIT:
exit (0);
case SDL_KEYUP:
if (key == SDLK_ESCAPE || key == 'q') {
if (remove (mapname) != 0) {
printf ("error deleting file\n");
}
exit (0);
}
case SDL_KEYDOWN:
switch (key) {
case 's':
if (mod & KMOD_CTRL) {
save_map ();
exit (1);
}
}
break;
case SDL_MOUSEBUTTONDOWN:
mousebutton[event.button.button] = 1;
break;
case SDL_MOUSEBUTTONUP:
mousebutton[event.button.button] = 0;
break;
case SDL_MOUSEMOTION:
mouse_x = event.button.x;
mouse_y = event.button.y;
break;
}
}
}
static void recursive_solver(t_env *e, int cur_tetri)
{
TETRI_Y(cur_tetri) = -1;
while (MAP_SIZE_SAVED != 0 && ++TETRI_Y(cur_tetri) < MAP_WIDTH)
{
TETRI_X(cur_tetri) = -1;
while (MAP_SIZE_SAVED != 0 && ++TETRI_X(cur_tetri) < MAP_WIDTH)
{
if (add_tetri_in_map(e, cur_tetri))
continue ;
if (cur_tetri + 1 == NB_TETRI)
{
save_map(e);
return ;
}
else
recursive_solver(e, cur_tetri + 1);
sharp_to_letter(e, cur_tetri, 0);
}
}
}
void process_message_from_server(unsigned char *in_data, int data_lenght)
{
//see what kind of data we got
switch (in_data[PROTOCOL])
{
case RAW_TEXT:
{
// do filtering and ignoring
data_lenght=filter_or_ignore_text(&in_data[3],data_lenght-3)+3;
if(data_lenght > 3)
{
//how to display it
if(interface_mode!=interface_opening)
put_text_in_buffer(&in_data[3],data_lenght-3,0);
else put_text_in_buffer(&in_data[3],data_lenght-3,54);
//lets log it
write_to_log(&in_data[3],data_lenght-3);
}
}
break;
case SMALL_WINDOW_TEXT:
{
add_text_to_small_text_buffer(in_data+3, data_lenght-3);
display_small_text_window();
}
break;
case ADD_NEW_ACTOR:
{
add_actor_from_server(&in_data[3]);
}
break;
case ADD_NEW_ENHANCED_ACTOR:
{
add_enhanced_actor_from_server(&in_data[3]);
}
break;
case ADD_ACTOR_COMMAND:
{
add_command_to_actor(*((short *)(in_data+3)),in_data[5]);
}
break;
case REMOVE_ACTOR:
{
destroy_actor(*((short *)(in_data+3)));
}
break;
case KILL_ALL_ACTORS:
{
destroy_all_actors();
}
break;
case NEW_MINUTE:
{
game_minute=*((short *)(in_data+3));
new_minute();
}
break;
case LOG_IN_OK:
{
interface_mode=interface_game;
previously_logged_in=1;
}
break;
case HERE_YOUR_STATS:
{
get_the_stats((Sint16 *)(in_data+3));
}
break;
case SEND_PARTIAL_STAT:
{
get_partial_stat(*((Uint8 *)(in_data+3)),*((Sint32 *)(in_data+4)));
}
break;
case GET_KNOWLEDGE_LIST:
{
get_knowledge_list(*(Uint16 *)(in_data+1)-1, in_data+3);
}
break;
case GET_NEW_KNOWLEDGE:
{
get_new_knowledge(*(Uint16 *)(in_data+3));
}
break;
case HERE_YOUR_INVENTORY:
{
get_your_items(in_data+3);
}
break;
case GET_NEW_INVENTORY_ITEM:
{
get_new_inventory_item(in_data+3);
}
break;
case REMOVE_ITEM_FROM_INVENTORY:
{
remove_item_from_inventory(*((Uint8 *)(in_data+3)));
}
break;
case INVENTORY_ITEM_TEXT:
{
put_small_text_in_box(&in_data[3],data_lenght-3,6*51+100,items_string);
if(!(get_show_window(items_win)||get_show_window(trade_win)))
{
put_text_in_buffer(&in_data[3],data_lenght-3,0);
}
}
break;
case GET_KNOWLEDGE_TEXT:
{
put_small_text_in_box(&in_data[3],data_lenght-3,6*51+150,knowledge_string);
}
break;
case CHANGE_MAP:
{
current_sector=-1;
if(map_file_name[0]!=0)
save_map(map_file_name);
object_under_mouse=-1;//to prevent a nasty crash, while looking for bags, when we change the map
close_dialogue(); // close the dialogue window if open
destroy_all_particles();
if(!load_map(&in_data[4])){ // creating map if it does not exist
int size=(in_data[3]&0x1f)<<4;
new_map(size,size);
dungeon=(in_data[3]&0x20)?1:0;
strcpy(map_file_name,&in_data[4]);
save_map(map_file_name);
}
kill_local_sounds();
#ifndef NO_MUSIC
playing_music=0;
#endif //NO_MUSIC
get_map_playlist();
have_a_map=1;
//also, stop the rain
seconds_till_rain_starts=-1;
seconds_till_rain_stops=-1;
is_raining=0;
rain_sound=0;//kill local sounds also kills the rain sound
weather_light_offset=0;
rain_light_offset=0;
}
break;
case GET_TELEPORTERS_LIST:
{
add_teleporters_from_list(&in_data[3]);
}
break;
case PLAY_MUSIC:
{
if(!no_sound)play_music(*((short *)(in_data+3)));
}
break;
case PLAY_SOUND:
{
if(!no_sound)add_sound_object(*((short *)(in_data+3)),*((short *)(in_data+5)),*((short *)(in_data+7)),*((char *)(in_data+9)),*((short *)(in_data+10)));
}
break;
case TELEPORT_OUT:
{
add_particle_sys_at_tile("./particles/teleport_in.part",*((short *)(in_data+3)),*((short *)(in_data+5)));
if(!no_sound)add_sound_object(snd_tele_out,*((short *)(in_data+3)),*((short *)(in_data+5)),1,0);
}
break;
case TELEPORT_IN:
{
add_particle_sys_at_tile("./particles/teleport_in.part",*((short *)(in_data+3)),*((short *)(in_data+5)));
if(!no_sound)add_sound_object(snd_tele_in,*((short *)(in_data+3)),*((short *)(in_data+5)),1,0);
}
break;
case LOG_IN_NOT_OK:
{
sprintf(log_in_error_str,"%s: %s",reg_error_str,invalid_pass);
}
break;
case REDEFINE_YOUR_COLORS:
{
strcpy(log_in_error_str,redefine_your_colours);
}
break;
case YOU_DONT_EXIST:
{
sprintf(log_in_error_str,"%s: %s",reg_error_str,char_dont_exist);
}
break;
case CREATE_CHAR_NOT_OK:
{
sprintf(create_char_error_str,"%s: %s",reg_error_str,char_name_in_use);
return;
}
break;
case CREATE_CHAR_OK:
{
login_from_new_char();
}
break;
case YOU_ARE:
{
yourself=*((short *)(in_data+3));
}
break;
case START_RAIN:
{
seconds_till_rain_starts=*((Uint8 *)(in_data+3));
seconds_till_rain_stops=-1;
}
break;
case STOP_RAIN:
{
seconds_till_rain_stops=*((Uint8 *)(in_data+3));
seconds_till_rain_starts=-1;
}
break;
case THUNDER:
{
add_thunder(rand()%5,*((Uint8 *)(in_data+3)));
}
break;
case SYNC_CLOCK:
{
server_time_stamp=*((int *)(in_data+3));
client_time_stamp=SDL_GetTicks();
client_server_delta_time=server_time_stamp-client_time_stamp;
}
break;
case PONG:
{
Uint8 str[160];
sprintf(str,"%s: %i MS",server_latency, SDL_GetTicks()-*((Uint32 *)(in_data+3)));
log_to_console(c_green1,str);
}
break;
case UPGRADE_NEW_VERSION:
{
log_to_console(c_red1,update_your_client);
log_to_console(c_red1,(char*)web_update_address);
}
break;
case UPGRADE_TOO_OLD:
{
log_to_console(c_red1,client_ver_not_supported);
log_to_console(c_red1,(char*)web_update_address);
this_version_is_invalid=1;
}
break;
case GET_NEW_BAG:
{
put_bag_on_ground(*((Uint16 *)(in_data+3)),*((Uint16 *)(in_data+5)),*((Uint8 *)(in_data+7)));
}
break;
case GET_BAGS_LIST:
{
add_bags_from_list(&in_data[3]);
}
break;
case SPAWN_BAG_PARTICLES:
{
add_particle_sys_at_tile("./particles/bag_in.part",*((Uint16 *)(in_data+3)),*((Uint16 *)(in_data+5)));
}
break;
case GET_NEW_GROUND_ITEM:
{
get_bag_item(in_data+3);
}
break;
case HERE_YOUR_GROUND_ITEMS:
{
get_bags_items_list(&in_data[3]);
}
break;
case CLOSE_BAG:
{
hide_window(ground_items_win);
}
break;
case REMOVE_ITEM_FROM_GROUND:
{
remove_item_from_ground(in_data[3]);
}
break;
case DESTROY_BAG:
{
remove_bag(in_data[3]);
}
break;
case NPC_TEXT:
{
put_small_text_in_box(&in_data[3],data_lenght-3,dialogue_menu_x_len-70,dialogue_string);
display_dialogue();
if(in_data[3]>=127 && in_data[4]>=127)
{
add_questlog(&in_data[4],data_lenght-4);
}
}
break;
case SEND_NPC_INFO:
{
my_strcp(npc_name,&in_data[3]);
cur_portrait=in_data[23];
}
break;
case NPC_OPTIONS_LIST:
{
build_response_entries(&in_data[3],*((Uint16 *)(in_data+1)));
}
break;
case GET_TRADE_ACCEPT:
{
if(!in_data[3])trade_you_accepted=1;
else
trade_other_accepted=1;
}
break;
case GET_TRADE_REJECT:
{
if(!in_data[3])trade_you_accepted=0;
else
trade_other_accepted=0;
}
break;
case GET_TRADE_EXIT:
{
hide_window(trade_win);
}
break;
case GET_YOUR_TRADEOBJECTS:
{
get_your_trade_objects(in_data+3);
}
break;
case GET_TRADE_OBJECT:
{
put_item_on_trade(in_data+3);
}
break;
case REMOVE_TRADE_OBJECT:
{
remove_item_from_trade(in_data+3);
}
break;
case GET_TRADE_PARTNER_NAME:
{
get_trade_partner_name(&in_data[3],*((Uint16 *)(in_data+1))-1);
}
break;
case GET_ACTOR_DAMAGE:
{
get_actor_damage(*((Uint16 *)(in_data+3)),in_data[5]);
}
break;
case GET_ACTOR_HEAL:
{
get_actor_heal(*((Uint16 *)(in_data+3)),in_data[5]);
}
break;
case ACTOR_UNWEAR_ITEM:
{
unwear_item_from_actor(*((Uint16 *)(in_data+3)),in_data[5]);
}
break;
case ACTOR_WEAR_ITEM:
{
actor_wear_item(*((Uint16 *)(in_data+3)),in_data[5],in_data[6]);
}
break;
case NPC_SAY_OVERTEXT:
{
add_displayed_text_to_actor(
get_actor_ptr_from_id( *((Uint16 *)(in_data+3)) ), in_data+5 );
}
break;
case BUDDY_EVENT:
{
if(in_data[3]==1)
add_buddy(&in_data[5],in_data[4],data_lenght-5);
else if(in_data[3]==0)
del_buddy(&in_data[4],data_lenght-4);
}
break;
// BARREN MOON NEW MESSAGES
case THIS_IS_ACTIVE_SECTOR:
active_sector=*((Uint16 *)(in_data+3));
break;
case GET_TILE_DATA:
get_tile_data(in_data+3);
break;
case GET_3D_OBJECTS:
get_3d_objects(in_data+3);
break;
case GET_2D_OBJECTS:
get_2d_objects(in_data+3);
break;
case GET_LIGHT_OBJECTS:
get_light_objects(in_data+3);
break;
case GET_PARTICLE_OBJECTS:
get_particle_objects(in_data+3);
break;
case GET_3D_OBJECTS_FULL_ROTATION:
get_3d_objects_full_rotation(in_data+3);
break;
case GET_CHECKSUMS:
{
actor *actor=pf_get_our_actor();
get_checksums(in_data+3, sector_get(actor->x_pos,actor->y_pos));
break;
}
case ADD_3D_OBJECT:
add_3d_object(in_data+3);
break;
case ADD_3D_OBJECT_FULL_ROTATION:
add_3d_object_fullrotation(in_data+3);
break;
case DELETE_3D_OBJECT:
delete_3d_object(in_data+3);
break;
case REPLACE_3D_OBJECT:
replace_3d_object(in_data+3);
break;
case ADD_2D_OBJECT:
add_2d_object(in_data+3);
break;
case DELETE_2D_OBJECT:
delete_2d_object(in_data+3);
break;
case REPLACE_2D_OBJECT:
replace_2d_object(in_data+3);
break;
case ADD_LIGHT:
add_lights(in_data+3);
break;
case DELETE_LIGHT:
delete_light(in_data+3);
break;
case ADD_PARTICLE:
add_particle(in_data+3);
break;
case DELETE_PARTICLE:
delete_particle(in_data+3);
break;
case REPLACE_PARTICLE:
replace_particle(in_data+3);
break;
default:
{
/* Unknown data type?? */;
}
break;
}
}
bool command_executor::execute_command(const hotkey_command& cmd, int /*index*/, bool press)
{
// hotkey release handling
if (!press) {
switch(cmd.id) {
// release a scroll key, un-apply scrolling in the given direction
case HOTKEY_SCROLL_UP:
scroll_up(false);
break;
case HOTKEY_SCROLL_DOWN:
scroll_down(false);
break;
case HOTKEY_SCROLL_LEFT:
scroll_left(false);
break;
case HOTKEY_SCROLL_RIGHT:
scroll_right(false);
break;
default:
return false; // nothing else handles a hotkey release
}
return true;
}
// hotkey press handling
switch(cmd.id) {
case HOTKEY_SCROLL_UP:
scroll_up(true);
break;
case HOTKEY_SCROLL_DOWN:
scroll_down(true);
break;
case HOTKEY_SCROLL_LEFT:
scroll_left(true);
break;
case HOTKEY_SCROLL_RIGHT:
scroll_right(true);
break;
case HOTKEY_CYCLE_UNITS:
cycle_units();
break;
case HOTKEY_CYCLE_BACK_UNITS:
cycle_back_units();
break;
case HOTKEY_ENDTURN:
end_turn();
break;
case HOTKEY_UNIT_HOLD_POSITION:
unit_hold_position();
break;
case HOTKEY_END_UNIT_TURN:
end_unit_turn();
break;
case HOTKEY_LEADER:
goto_leader();
break;
case HOTKEY_UNDO:
undo();
break;
case HOTKEY_REDO:
redo();
break;
case HOTKEY_TERRAIN_DESCRIPTION:
terrain_description();
break;
case HOTKEY_UNIT_DESCRIPTION:
unit_description();
break;
case HOTKEY_RENAME_UNIT:
rename_unit();
break;
case HOTKEY_SAVE_GAME:
save_game();
break;
case HOTKEY_SAVE_REPLAY:
save_replay();
break;
case HOTKEY_SAVE_MAP:
save_map();
break;
case HOTKEY_LOAD_GAME:
load_game();
break;
case HOTKEY_TOGGLE_ELLIPSES:
toggle_ellipses();
break;
case HOTKEY_TOGGLE_GRID:
toggle_grid();
break;
case HOTKEY_STATUS_TABLE:
status_table();
break;
case HOTKEY_RECALL:
recall();
break;
case HOTKEY_LABEL_SETTINGS:
label_settings();
break;
case HOTKEY_RECRUIT:
recruit();
break;
case hotkey::HOTKEY_REPEAT_RECRUIT:
repeat_recruit();
break;
case HOTKEY_SPEAK:
speak();
break;
case HOTKEY_SPEAK_ALLY:
whisper();
break;
case HOTKEY_SPEAK_ALL:
shout();
break;
case HOTKEY_CREATE_UNIT:
create_unit();
break;
case HOTKEY_CHANGE_SIDE:
change_side();
break;
case HOTKEY_KILL_UNIT:
kill_unit();
break;
case HOTKEY_PREFERENCES:
preferences();
break;
case HOTKEY_OBJECTIVES:
objectives();
break;
case HOTKEY_UNIT_LIST:
unit_list();
break;
case HOTKEY_STATISTICS:
show_statistics();
break;
case HOTKEY_STOP_NETWORK:
stop_network();
break;
case HOTKEY_START_NETWORK:
start_network();
break;
case HOTKEY_LABEL_TEAM_TERRAIN:
label_terrain(true);
break;
case HOTKEY_LABEL_TERRAIN:
label_terrain(false);
break;
case HOTKEY_CLEAR_LABELS:
clear_labels();
break;
case HOTKEY_SHOW_ENEMY_MOVES:
show_enemy_moves(false);
break;
case HOTKEY_BEST_ENEMY_MOVES:
show_enemy_moves(true);
break;
case HOTKEY_DELAY_SHROUD:
toggle_shroud_updates();
break;
case HOTKEY_UPDATE_SHROUD:
update_shroud_now();
break;
case HOTKEY_CONTINUE_MOVE:
continue_move();
break;
case HOTKEY_SEARCH:
search();
break;
case HOTKEY_HELP:
show_help();
break;
case HOTKEY_CHAT_LOG:
show_chat_log();
break;
case HOTKEY_USER_CMD:
user_command();
break;
case HOTKEY_CUSTOM_CMD:
custom_command();
break;
case HOTKEY_AI_FORMULA:
ai_formula();
break;
case HOTKEY_CLEAR_MSG:
clear_messages();
break;
case HOTKEY_LANGUAGE:
change_language();
break;
case HOTKEY_REPLAY_PLAY:
play_replay();
break;
case HOTKEY_REPLAY_RESET:
reset_replay();
break;
case HOTKEY_REPLAY_STOP:
stop_replay();
break;
case HOTKEY_REPLAY_NEXT_TURN:
replay_next_turn();
break;
case HOTKEY_REPLAY_NEXT_SIDE:
replay_next_side();
break;
case HOTKEY_REPLAY_NEXT_MOVE:
replay_next_move();
break;
case HOTKEY_REPLAY_SHOW_EVERYTHING:
replay_show_everything();
break;
case HOTKEY_REPLAY_SHOW_EACH:
replay_show_each();
break;
case HOTKEY_REPLAY_SHOW_TEAM1:
replay_show_team1();
break;
case HOTKEY_REPLAY_SKIP_ANIMATION:
replay_skip_animation();
break;
case HOTKEY_REPLAY_EXIT:
replay_exit();
break;
case HOTKEY_WB_TOGGLE:
whiteboard_toggle();
break;
case HOTKEY_WB_EXECUTE_ACTION:
whiteboard_execute_action();
break;
case HOTKEY_WB_EXECUTE_ALL_ACTIONS:
whiteboard_execute_all_actions();
break;
case HOTKEY_WB_DELETE_ACTION:
whiteboard_delete_action();
break;
case HOTKEY_WB_BUMP_UP_ACTION:
whiteboard_bump_up_action();
break;
case HOTKEY_WB_BUMP_DOWN_ACTION:
whiteboard_bump_down_action();
break;
case HOTKEY_WB_SUPPOSE_DEAD:
whiteboard_suppose_dead();
break;
case HOTKEY_SELECT_HEX:
select_hex();
break;
case HOTKEY_DESELECT_HEX:
deselect_hex();
break;
case HOTKEY_MOVE_ACTION:
move_action();
break;
case HOTKEY_SELECT_AND_ACTION:
select_and_action();
break;
case HOTKEY_ACCELERATED:
toggle_accelerated_speed();
break;
case LUA_CONSOLE:
lua_console();
break;
case HOTKEY_ZOOM_IN:
zoom_in();
break;
case HOTKEY_ZOOM_OUT:
zoom_out();
break;
case HOTKEY_ZOOM_DEFAULT:
zoom_default();
break;
case HOTKEY_MAP_SCREENSHOT:
map_screenshot();
break;
case HOTKEY_QUIT_TO_DESKTOP:
quit_confirmation::quit_to_desktop();
break;
case HOTKEY_QUIT_GAME:
quit_confirmation::quit_to_title();
break;
default:
return false;
}
return true;
}
void edit_level(al_defs *al, char name[255]) {
level *lvl = read_level(name);
int posx,posy; posx=posy=1;
while(true){
draw_background(al);
int i,j;
for(i=0;i<lvl->h;i++) {
for(j=0;j<lvl->w;j++) {
draw_tile(al, i, j, lvl);
}
}
draw_tile_border(al, posy, posx, lvl);
al_draw_text(al->hint_font, al_map_rgb(120,120,120),
20,al->height-80,ALLEGRO_ALIGN_LEFT,
"W - wall, O - nothing");
al_draw_text(al->hint_font, al_map_rgb(120,120,120),
20,al->height-60,ALLEGRO_ALIGN_LEFT,
"P - player, S - chest, X - destination point");
al_draw_text(al->hint_font, al_map_rgb(120,120,120),
20,al->height-40,ALLEGRO_ALIGN_LEFT,
"Z - chest in correct place, C - player on dest. point");
al_draw_text(al->hint_font, al_map_rgb(120,120,120),
20,al->height-20,ALLEGRO_ALIGN_LEFT,
"Esc - escape, Enter - save");
al_flip_display();
//event time!
ALLEGRO_EVENT ev;
al_wait_for_event(al->queue, &ev);
if(ev.type!=ALLEGRO_EVENT_KEY_DOWN)
continue;
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_LEFT:
if(posx>1) posx--;
break;
case ALLEGRO_KEY_RIGHT:
if(posx<(lvl->w-2)) posx++;
break;
case ALLEGRO_KEY_UP:
if(posy>1) posy--;
break;
case ALLEGRO_KEY_DOWN:
if(posy<(lvl->h-2)) posy++;
break;
case ALLEGRO_KEY_P:
for(i=0;i<lvl->h;i++)
for(j=0;j<lvl->w;j++)
if(lvl->map[i][j]=='P' || lvl->map[i][j]=='C')
lvl->map[i][j]=' ';
lvl->map[posy][posx]='P';
break;
case ALLEGRO_KEY_X:
lvl->map[posy][posx]='X';
break;
case ALLEGRO_KEY_Z:
lvl->map[posy][posx]='Z';
break;
case ALLEGRO_KEY_S:
lvl->map[posy][posx]='S';
break;
case ALLEGRO_KEY_C:
for(i=0;i<lvl->h;i++)
for(j=0;j<lvl->w;j++)
if(lvl->map[i][j]=='P' || lvl->map[i][j]=='C')
lvl->map[i][j]=' ';
lvl->map[posy][posx]='C';
break;
case ALLEGRO_KEY_O:
lvl->map[posy][posx]=' ';
break;
case ALLEGRO_KEY_W:
lvl->map[posy][posx]='#';
break;
case ALLEGRO_KEY_ENTER:
save_map(name, lvl);
return;
case ALLEGRO_KEY_ESCAPE:
return;
}
}
}
/*
* Function name: save_message
* Description : Save the individual message to disk.
* Arguments : mapping message - the message.
* int number - the current time to save.
*/
static void
save_message(mapping message, int number)
{
save_map(message, FILE_NAME_MESSAGE(number, HASH_SIZE));
}
/*
* Function name: save_mail
* Description : Save the mail-file of a player to disk.
* Arguments : mapping mail - the mail of the player.
* string name - the name of the player.
*/
static void
save_mail(mapping mail, string name)
{
save_map(mail, FILE_NAME_MAIL(name));
}
int main()
{
int exit = 0;
init();
BITMAP *cursor_bmp = load_bitmap("cursor.bmp", NULL);
VECTOR temp_shape[100];
LINE_LOOP loop[1000];
int n = 0, sn = 0, timeout = 100, i, j;
while(!exit)
{
if(keypressed())
{
if(key[KEY_ESC]) { exit = 1; }
if(key[KEY_C] && n > 2 && sn < 1000)
{
loop[sn].point = (VECTOR *)malloc(n * sizeof(VECTOR));
for(i = 0; i < n; i++)
loop[sn].point[i] = temp_shape[i];
loop[sn].n = n;
loop[sn].closed = 1;
sn++;
n = 0;
}
if(key[KEY_V] && n > 1 && sn < 1000)
{
loop[sn].point = (VECTOR *)malloc(n * sizeof(VECTOR));
for(i = 0; i < n; i++)
loop[sn].point[i] = temp_shape[i];
loop[sn].n = n;
loop[sn].closed = 0;
sn++;
n = 0;
}
}
VECTOR cursor;
cursor.x = (mouse_x / 5) * 5;
cursor.y = (mouse_y / 5) * 5;
timeout--;
if(mouse_b == 1 && timeout < 1 && n < 100)
{
int error_flag = 0;
timeout = 100;
if(n > 0)
if(sq_dist(cursor, temp_shape[n - 1]) < 25)
error_flag = 1;
if(n > 1)
if(fabs(VECTOR_SLOPE(VECTOR_DIFF(temp_shape[n - 1], temp_shape[n - 2])) -
VECTOR_SLOPE(VECTOR_DIFF(temp_shape[n - 1], cursor))) < 0.2 ||
(temp_shape[n - 1].x == temp_shape[n - 2].x && temp_shape[n - 2].x == cursor.x))
error_flag = 1;
if(!error_flag)
{
temp_shape[n] = cursor;
n++;
}
}
clear_to_color(buffer, makecol(128, 128, 128));
if(sn > 0)
for(j = 0; j < sn; j++)
vector_loop(buffer, loop[j].point, loop[j].n, loop[j].closed, 0);
vector_loop(buffer, temp_shape, n, -2, 0);
if(n > 1)
{
vector_loop(buffer, temp_shape, n, 0, 0);
vector_line(buffer, temp_shape[n - 1], temp_shape[0], makecol(128, 0, 0));
}
if(n > 0)
{
vector_line(buffer, temp_shape[n - 1], cursor, makecol(0, 128, 128));
vector_line(buffer, cursor, temp_shape[0], makecol(0, 128, 128));
}
draw_sprite(buffer, cursor_bmp, cursor.x - 4, cursor.y - 5);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
}
clear_keybuf();
clear_to_color(buffer, makecol(128, 128, 128));
float wall_width = 20.0;
LINE_LOOP *final_shape;
final_shape = (LINE_LOOP *)malloc(sn * sizeof(LINE_LOOP));
if(sn > 0)
for(j = 0; j < sn; j++)
{
if(loop[j].n > 2 && !loop[j].closed)
{
VECTOR norm;
int pn = loop[j].n;
final_shape[j] = new_shape(pn * 2, 0);
for(i = 0; i < pn; i++)
final_shape[j].point[i] = loop[j].point[i];
norm = NORMALIZED_NORMAL(loop[j].point[0], loop[j].point[1]);
final_shape[j].point[pn] = VECTOR_SUM(loop[j].point[0], USCALE_VECTOR(norm, wall_width));
norm = NORMALIZED_NORMAL(loop[j].point[pn - 2], loop[j].point[pn - 1]);
final_shape[j].point[pn * 2 - 1] = VECTOR_SUM(loop[j].point[pn - 1], USCALE_VECTOR(norm, wall_width));
for(i = 1; i < pn - 1; i++)
final_shape[j].point[pn + i] = make_wall(loop[j].point[i - 1], loop[j].point[i], loop[j].point[i + 1], wall_width);
}
if(loop[j].n > 2 && loop[j].closed)
{
int pn = loop[j].n;
final_shape[j] = new_shape(pn, 1);
for(i = 0; i < pn; i++)
final_shape[j].point[i] = loop[j].point[i];
}
if(loop[j].n == 2)
{
final_shape[j] = new_shape(4, 0);
VECTOR norm = USCALE_VECTOR(NORMALIZED_NORMAL(loop[j].point[0], loop[j].point[1]), wall_width);
final_shape[j].point[0] = loop[j].point[0];
final_shape[j].point[1] = loop[j].point[1];
final_shape[j].point[2] = VECTOR_SUM(loop[j].point[0], norm);
final_shape[j].point[3] = VECTOR_SUM(loop[j].point[1], norm);
}
}
draw_map_sketch(buffer, final_shape, sn);
save_map("map.txt", final_shape, sn);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
readkey();
free_map(final_shape, sn);
for(i = 0; i < sn; i++)
free(loop[i].point);
destroy_bitmap(cursor_bmp);
destroy_bitmap(buffer);
return 0;
}
static void button_click(gpointer data)
{
if(strcmp("button.open", (char *)data) == 0)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_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], file, colors, &err);
else
generate_image(mdata[current_buffer], 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);
}
else if(strcmp("button.save", (char *)data) == 0)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_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);
}
gtk_widget_destroy(dialog);
printf("bracket cleared\n");
}
else if(strcmp("button.exp_img", (char *)data) == 0)
{
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,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_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(strcmp("button.save_rm", (char *)data) == 0)
{
if(mdata == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_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(strcmp("button.palette", (char *)data) == 0)
{
add_buffer();
generate_palette(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.random_noise", (char *)data) == 0)
{
add_buffer();
generate_random_noise(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.mandelbrot", (char *)data) == 0)
{
add_buffer();
generate_mandelbrot(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.julia", (char *)data) == 0)
{
add_buffer();
generate_julia(mdata[current_buffer], 0.5, 0.5);
set_image();
}
else if(strcmp("button.from_clipboard", (char *)data) == 0)
{
GtkClipboard * clipboard;
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_image(clipboard, clipboard_callback, NULL);
}
else
printf("Unhandeled button press: %s\n", (char *)data);
}
int main(int argc, char *argv[])
{
char *terrainmap, *seedmap, *lakemap, *mapset;
int rows, cols, in_terran_fd, out_fd, lake_fd, row, col, pases, pass;
int lastcount, curcount, start_col = 0, start_row = 0;
double east, north, area = 0, volume = 0;
FCELL **in_terran, **out_water, water_level, max_depth = 0, min_depth = 0;
FCELL water_window[3][3];
struct Option *tmap_opt, *smap_opt, *wlvl_opt, *lake_opt, *sdxy_opt;
struct Flag *negative_flag, *overwrite_flag;
struct GModule *module;
struct Colors colr;
struct Cell_head window;
struct History history;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, hydrology");
module->description = _("Fills lake at given point to given level.");
tmap_opt = G_define_option();
tmap_opt->key = "dem";
tmap_opt->key_desc = "name";
tmap_opt->description = _("Name of terrain raster map (DEM)");
tmap_opt->type = TYPE_STRING;
tmap_opt->gisprompt = "old,cell,raster";
tmap_opt->required = YES;
wlvl_opt = G_define_option();
wlvl_opt->key = "wl";
wlvl_opt->description = _("Water level");
wlvl_opt->type = TYPE_DOUBLE;
wlvl_opt->required = YES;
lake_opt = G_define_option();
lake_opt->key = "lake";
lake_opt->key_desc = "name";
lake_opt->description = _("Name for output raster map with lake");
lake_opt->type = TYPE_STRING;
lake_opt->gisprompt = "new,cell,raster";
lake_opt->required = NO;
sdxy_opt = G_define_option();
sdxy_opt->key = "xy";
sdxy_opt->description = _("Seed point coordinates");
sdxy_opt->type = TYPE_DOUBLE;
sdxy_opt->key_desc = "east,north";
sdxy_opt->required = NO;
sdxy_opt->multiple = NO;
smap_opt = G_define_option();
smap_opt->key = "seed";
smap_opt->key_desc = "name";
smap_opt->description =
_("Name of raster map with given starting point(s) (at least 1 cell > 0)");
smap_opt->type = TYPE_STRING;
smap_opt->gisprompt = "old,cell,raster";
smap_opt->required = NO;
negative_flag = G_define_flag();
negative_flag->key = 'n';
negative_flag->description =
_("Use negative depth values for lake raster map");
overwrite_flag = G_define_flag();
overwrite_flag->key = 'o';
overwrite_flag->description =
_("Overwrite seed map with result (lake) map");
if (G_parser(argc, argv)) /* Returns 0 if successful, non-zero otherwise */
exit(EXIT_FAILURE);
if (smap_opt->answer && sdxy_opt->answer)
G_fatal_error(_("Both seed map and coordinates cannot be specified"));
if (!smap_opt->answer && !sdxy_opt->answer)
G_fatal_error(_("Seed map or seed coordinates must be set!"));
if (sdxy_opt->answer && !lake_opt->answer)
G_fatal_error(_("Seed coordinates and output map lake= must be set!"));
if (lake_opt->answer && overwrite_flag->answer)
G_fatal_error(_("Both lake and overwrite cannot be specified"));
if (!lake_opt->answer && !overwrite_flag->answer)
G_fatal_error(_("Output lake map or overwrite flag must be set!"));
terrainmap = tmap_opt->answer;
seedmap = smap_opt->answer;
sscanf(wlvl_opt->answer, "%f", &water_level);
lakemap = lake_opt->answer;
/* If lakemap is set, write to it, else is set overwrite flag and we should write to seedmap. */
if (lakemap) {
lake_fd = G_open_raster_new(lakemap, 1);
if (lake_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), lakemap);
}
rows = G_window_rows();
cols = G_window_cols();
/* If we use x,y as seed... */
if (sdxy_opt->answer) {
G_get_window(&window);
east = window.east;
north = window.north;
G_scan_easting(sdxy_opt->answers[0], &east, G_projection());
G_scan_northing(sdxy_opt->answers[1], &north, G_projection());
start_col = (int)G_easting_to_col(east, &window);
start_row = (int)G_northing_to_row(north, &window);
if (start_row < 0 || start_row > rows ||
start_col < 0 || start_col > cols)
G_fatal_error(_("Seed point outside the current region"));
}
/* Open terran map */
mapset = G_find_cell2(terrainmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), terrainmap);
in_terran_fd = G_open_cell_old(terrainmap, mapset);
if (in_terran_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(terrainmap, mapset));
/* Open seed map */
if (smap_opt->answer) {
mapset = G_find_cell2(seedmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), seedmap);
out_fd = G_open_cell_old(seedmap, mapset);
if (out_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(seedmap, mapset));
}
/* Pointers to rows. Row = ptr to 'col' size array. */
in_terran = (FCELL **) G_malloc(rows * sizeof(FCELL *));
out_water = (FCELL **) G_malloc(rows * sizeof(FCELL *));
if (in_terran == NULL || out_water == NULL)
G_fatal_error(_("G_malloc: out of memory"));
G_debug(1, "Loading maps...");
/* foo_rows[row] == array with data (2d array). */
for (row = 0; row < rows; row++) {
in_terran[row] = (FCELL *) G_malloc(cols * sizeof(FCELL));
out_water[row] = (FCELL *) G_calloc(cols, sizeof(FCELL));
/* In newly created space load data from file. */
if (G_get_f_raster_row(in_terran_fd, in_terran[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
terrainmap, row);
if (smap_opt->answer)
if (G_get_f_raster_row(out_fd, out_water[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
seedmap, row);
G_percent(row + 1, rows, 5);
}
/* Set seed point */
if (sdxy_opt->answer)
/* Check is water level higher than seed point */
if (in_terran[start_row][start_col] >= water_level)
G_fatal_error(_("Given water level at seed point is below earth surface. "
"Increase water level or move seed point."));
out_water[start_row][start_col] = 1;
/* Close seed map for reading. */
if (smap_opt->answer)
G_close_cell(out_fd);
/* Open output map for writing. */
if (lakemap) {
out_fd = lake_fd;
}
else {
out_fd = G_open_raster_new(seedmap, 1);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), seedmap);
}
/* More pases are renudant. Real pases count is controled by altered cell count. */
pases = (int)(rows * cols) / 2;
G_debug(1,
"Starting lake filling at level of %8.4f in %d passes. Percent done:",
water_level, pases);
lastcount = 0;
for (pass = 0; pass < pases; pass++) {
G_debug(3, "Pass: %d", pass);
curcount = 0;
/* Move from left upper corner to right lower corner. */
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
/* Loading water data into window. */
load_window_values(out_water, water_window, rows, cols, row,
col);
/* Cheking presence of water. */
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0; /* Cell is higher than water level -> NULL. */
}
}
}
}
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
curcount = 0;
/* Move backwards - from lower right corner to upper left corner. */
for (row = rows - 1; row >= 0; row--) {
for (col = cols - 1; col >= 0; col--) {
load_window_values(out_water, water_window, rows, cols, row,
col);
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0;
}
}
}
}
G_percent(pass + 1, pases, 10);
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
} /*pases */
G_percent(pases, pases, 10); /* Show 100%. */
save_map(out_water, out_fd, rows, cols, negative_flag->answer, &min_depth,
&max_depth, &area, &volume);
G_message(_("Lake depth from %f to %f"), min_depth, max_depth);
G_message(_("Lake area %f square meters"), area);
G_message(_("Lake volume %f cubic meters"), volume);
G_warning(_("Volume is correct only if lake depth (terrain raster map) is in meters"));
/* Close all files. Lake map gets written only now. */
G_close_cell(in_terran_fd);
G_close_cell(out_fd);
/* Add blue color gradient from light bank to dark depth */
G_init_colors(&colr);
if (negative_flag->answer == 1) {
G_add_f_raster_color_rule(&max_depth, 0, 240, 255,
&min_depth, 0, 50, 170, &colr);
}
else {
G_add_f_raster_color_rule(&min_depth, 0, 240, 255,
&max_depth, 0, 50, 170, &colr);
}
if (G_write_colors(lakemap, G_mapset(), &colr) != 1)
G_fatal_error(_("Unable to read color file of raster map <%s>"),
lakemap);
G_short_history(lakemap, "raster", &history);
G_command_history(&history);
G_write_history(lakemap, &history);
return EXIT_SUCCESS;
}
void after_relations() const {
std::cout << "Relation versions: " << m_numRels << std::endl;
std::cout << "Relation versions with uid: " << m_numURels << std::endl;
save_map();
}
void convert_image()
{
resource_configuration resconf;
resource_map rmap;
unit_configuration_map uconfmap;
advance_map amap;
city_improv_map cimap;
government_map govmap;
std::vector<civilization*> civs;
get_configuration(ruleset_name, &civs, &uconfmap, &amap, &cimap,
&resconf, &govmap, &rmap);
SDL_Surface* surf = IMG_Load(infile);
if(!surf) {
throw std::runtime_error("Could not load image");
}
int w = surf->w;
int h = surf->h;
printf("Map size: %dx%d\n", w, h);
printf("Bytes per pixel: %d\n", surf->format->BytesPerPixel);
int sea = resconf.get_sea_tile();
std::vector<colormap> colormapping;
colormapping = loadColorMapping(resconf);
int count[num_terrain_types];
memset(count, 0x00, sizeof(count));
map m(w, h, resconf, rmap);
m.set_x_wrap(wrap_x);
for(int j = 0; j < h; j++) {
for(int i = 0; i < w; i++) {
color c = sdl_get_pixel(surf, i, j);
int mindiff = INT_MAX;
int type = -1;
for(const auto& cm : colormapping) {
int diff = abs(c.r - cm.col.r) +
abs(c.g - cm.col.g) +
abs(c.b - cm.col.b);
if(diff < mindiff) {
type = cm.type;
mindiff = diff;
}
}
m.set_data(i, j, type);
count[type]++;
}
}
// turn coasts to sea
for(int j = 0; j < h; j++) {
for(int i = 0; i < w; i++) {
if(!m.resconf.is_water_tile(m.get_data(i, j))) {
for(int k = -1; k <= 1; k++) {
for(int l = -1; l <= 1; l++) {
int neighbour = m.get_data(i + k, j + l);
if(m.resconf.is_ocean_tile(neighbour)) {
m.set_data(i + k, j + l, sea);
}
}
}
}
}
}
// add random resources
m.add_random_resources();
save_map(outfile, ruleset_name, m);
int total_land = 0;
int total_tiles = w * h;
for(int i = 0; i < num_terrain_types; i++) {
if(!resconf.is_water_tile(i)) {
total_land += count[i];
}
}
printf("%-20s: %3d %%\n", "Land", 100 * total_land / total_tiles);
for(int i = 0; i < num_terrain_types; i++) {
if(count[i] && !resconf.is_water_tile(i)) {
printf("%-20s: %3d %%\n", resconf.resource_name[i].c_str(),
100 * count[i] / total_land);
}
}
}
void save_map_file_continued()
{
if (selected_file)
save_map(selected_file);
}
bool command_executor::execute_command(HOTKEY_COMMAND command, int /*index*/)
{
switch(command) {
case HOTKEY_CYCLE_UNITS:
cycle_units();
break;
case HOTKEY_CYCLE_BACK_UNITS:
cycle_back_units();
break;
case HOTKEY_ENDTURN:
end_turn();
break;
case HOTKEY_UNIT_HOLD_POSITION:
unit_hold_position();
break;
case HOTKEY_END_UNIT_TURN:
end_unit_turn();
break;
case HOTKEY_LEADER:
goto_leader();
break;
case HOTKEY_UNDO:
undo();
break;
case HOTKEY_REDO:
redo();
break;
case HOTKEY_UNIT_DESCRIPTION:
unit_description();
break;
case HOTKEY_RENAME_UNIT:
rename_unit();
break;
case HOTKEY_SAVE_GAME:
save_game();
break;
case HOTKEY_SAVE_REPLAY:
save_replay();
break;
case HOTKEY_SAVE_MAP:
save_map();
break;
case HOTKEY_LOAD_GAME:
load_game();
break;
case HOTKEY_TOGGLE_ELLIPSES:
toggle_ellipses();
break;
case HOTKEY_TOGGLE_GRID:
toggle_grid();
break;
case HOTKEY_STATUS_TABLE:
status_table();
break;
case HOTKEY_RECALL:
recall();
break;
case HOTKEY_RECRUIT:
recruit();
break;
case hotkey::HOTKEY_REPEAT_RECRUIT:
repeat_recruit();
break;
case HOTKEY_SPEAK:
speak();
break;
case HOTKEY_SPEAK_ALLY:
whisper();
break;
case HOTKEY_SPEAK_ALL:
shout();
break;
case HOTKEY_CREATE_UNIT:
create_unit();
break;
case HOTKEY_CHANGE_SIDE:
change_side();
break;
case HOTKEY_PREFERENCES:
preferences();
break;
case HOTKEY_OBJECTIVES:
objectives();
break;
case HOTKEY_UNIT_LIST:
unit_list();
break;
case HOTKEY_STATISTICS:
show_statistics();
break;
case HOTKEY_STOP_NETWORK:
stop_network();
break;
case HOTKEY_START_NETWORK:
start_network();
break;
case HOTKEY_LABEL_TEAM_TERRAIN:
label_terrain(true);
break;
case HOTKEY_LABEL_TERRAIN:
label_terrain(false);
break;
case HOTKEY_CLEAR_LABELS:
clear_labels();
break;
case HOTKEY_SHOW_ENEMY_MOVES:
show_enemy_moves(false);
break;
case HOTKEY_BEST_ENEMY_MOVES:
show_enemy_moves(true);
break;
case HOTKEY_DELAY_SHROUD:
toggle_shroud_updates();
break;
case HOTKEY_UPDATE_SHROUD:
update_shroud_now();
break;
case HOTKEY_CONTINUE_MOVE:
continue_move();
break;
case HOTKEY_SEARCH:
search();
break;
case HOTKEY_HELP:
show_help();
break;
case HOTKEY_CHAT_LOG:
show_chat_log();
break;
case HOTKEY_USER_CMD:
user_command();
break;
case HOTKEY_CUSTOM_CMD:
custom_command();
break;
case HOTKEY_AI_FORMULA:
ai_formula();
break;
case HOTKEY_CLEAR_MSG:
clear_messages();
break;
case HOTKEY_LANGUAGE:
change_language();
break;
case HOTKEY_PLAY_REPLAY:
play_replay();
break;
case HOTKEY_RESET_REPLAY:
reset_replay();
break;
case HOTKEY_STOP_REPLAY:
stop_replay();
break;
case HOTKEY_REPLAY_NEXT_TURN:
replay_next_turn();
break;
case HOTKEY_REPLAY_NEXT_SIDE:
replay_next_side();
break;
case HOTKEY_REPLAY_SHOW_EVERYTHING:
replay_show_everything();
break;
case HOTKEY_REPLAY_SHOW_EACH:
replay_show_each();
break;
case HOTKEY_REPLAY_SHOW_TEAM1:
replay_show_team1();
break;
case HOTKEY_REPLAY_SKIP_ANIMATION:
replay_skip_animation();
break;
case HOTKEY_WB_TOGGLE:
whiteboard_toggle();
break;
case HOTKEY_WB_EXECUTE_ACTION:
whiteboard_execute_action();
break;
case HOTKEY_WB_EXECUTE_ALL_ACTIONS:
whiteboard_execute_all_actions();
break;
case HOTKEY_WB_DELETE_ACTION:
whiteboard_delete_action();
break;
case HOTKEY_WB_BUMP_UP_ACTION:
whiteboard_bump_up_action();
break;
case HOTKEY_WB_BUMP_DOWN_ACTION:
whiteboard_bump_down_action();
break;
case HOTKEY_WB_SUPPOSE_DEAD:
whiteboard_suppose_dead();
break;
case HOTKEY_LEFT_MOUSE_CLICK:
left_mouse_click();
break;
case HOTKEY_RIGHT_MOUSE_CLICK:
right_mouse_click();
break;
default:
return false;
}
return true;
}
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);
}
int main(int argc, char *argv[]) {
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) == -1) {
printf("Can't initialize SDL: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
atexit(SDL_Quit);
SDL_Surface *screen, *text, *save_message;
SDL_Event event;
TTF_Font *font;
int i, done = 0, mouse_x = 0, mouse_y = 0;
unsigned int frames = SDL_GetTicks() + FLIMIT;
unsigned int *frame_limit;
frame_limit = &frames;
int *mouse_x_ptr, *mouse_y_ptr;
mouse_x_ptr = &mouse_x;
mouse_y_ptr = &mouse_y;
int show_save_msg = 0;
screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 16, SDL_DOUBLEBUF | SDL_HWSURFACE);
//screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 16, SDL_DOUBLEBUF | SDL_FULLSCREEN);
if(NULL == screen) {
printf("Can't set video mode: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
/* set window title */
SDL_WM_SetCaption("2D SIMULATION", NULL);
/* disable cursor */
SDL_ShowCursor(SDL_DISABLE);
/* load new cursor */
load_cursor();
/* load the map and fill tiles array */
load_map();
/* load tileset */
load_tileset();
/* load player */
load_player_image();
/* setup font */
TTF_Init();
SDL_Color text_color = {255, 255, 255};
font = TTF_OpenFont("media/fonts/slkscrb.ttf", 8);
/* game loop */
while(!done) {
while(SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_QUIT:
done = 1;
break;
case SAVE_EVENT:
show_save_msg = 0;
//printf("SDL_USEREVENT: %i\n", SAVE_EVENT);
break;
case SDL_MOUSEMOTION:
*mouse_x_ptr = event.motion.x;
*mouse_y_ptr = event.motion.y;
break;
case SDL_MOUSEBUTTONDOWN:
switch(event.button.button) {
case 1:
//destroy_block(screen, event.button.x, event.button.y);
input.mleft = 1;
break;
case 3:
//place_block(event.button.x, event.button.y, &player);
input.mright = 1;
break;
default:
break;
}
break;
case SDL_MOUSEBUTTONUP:
switch(event.button.button) {
/* removed because if player falls down, it deletes always the block below the player */
case 1:
input.mleft = 0;
break;
case 3:
input.mright = 0;
break;
default:
break;
}
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_ESCAPE:
done = 1;
break;
case SDLK_a:
input.left = 1;
break;
case SDLK_d:
input.right = 1;
break;
case SDLK_SPACE:
input.jump = 1;
break;
case SDLK_1:
player.selected = DIRT;
break;
case SDLK_2:
player.selected = GRASS;
break;
case SDLK_3:
player.selected = SAND;
break;
case SDLK_4:
player.selected = ROCK;
break;
case SDLK_5:
player.selected = WATER5;
break;
case SDLK_6:
player.selected = OIL;
break;
case SDLK_F12:
save_map();
SDL_AddTimer (2000, msg_event, NULL);
show_save_msg = 1;
break;
default:
break;
}
break;
case SDL_KEYUP:
switch(event.key.keysym.sym) {
case SDLK_a:
input.left = 0;
break;
case SDLK_d:
input.right = 0;
break;
default:
break;
}
break;
}
}
move_player(&player); // and camera
move_sand();
simulate_water();
simulate_oil();
place_and_destroy_blocks(screen, event.button.x, event.button.y, &player);
//input.mleft = 0; // uncomment for click once to delete one block
//input.mright = 0; // uncomment for click once to place one block
draw(screen, mouse_x_ptr, mouse_y_ptr, &player, text, font, text_color, show_save_msg, save_message);
delay(frame_limit);
*frame_limit = SDL_GetTicks() + FLIMIT;
}
/* free tiles/mass/new_mass array in reverse order */
for(i = 0; i < map.h; i++) {
free(map.tiles[i]);
free(map.water_mass[i]);
free(map.new_water_mass[i]);
free(map.oil_mass[i]);
free(map.new_oil_mass[i]);
}
free(map.tiles);
free(map.water_mass);
free(map.new_water_mass);
free(map.oil_mass);
free(map.new_oil_mass);
SDL_FreeSurface(tileset);
SDL_FreeSurface(player_image);
SDL_FreeSurface(cursor);
SDL_FreeSurface(text);
SDL_FreeSurface(save_message);
return 0;
}
