00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #include "mapedit.h"
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 App *app;
00028 Window *win;
00029 MainWin *mwin;
00030 TileWin *tile_win;
00031 NewMapWin *newmap_win;
00032 PropWin *prop_win;
00033 HelpWin *help_win;
00034 MMapWin *minimap_win;
00035 Timer *clicktime;
00036 tile *tile_array;
00037 map *map_array, *prev_map_array;
00038 FILE *tilefile, *openmapfile, *savemapfile;
00039 FILE *ofile;
00040 static char tilenames[256][40];
00041 Control *debug, *debug2;
00042 char dstring[200];
00043
00044
00045 int init_main_window(MainWin *mclass){
00046 int x,y,level, width, height;
00047 char s[3];
00048 mclass->win = new_window(app, rect(0,0,MAINWINWIDTH,MAINWINHEIGHT),
00049 "Project Piedmont Level Editor", STANDARD_WINDOW);
00050 on_window_close(mclass->win, exit_mainwin);
00051 mclass->double_click_flag = 0;
00052 mclass->mapwidth = 50;
00053 mclass->mapheight = 50;
00054
00055
00056
00057 mclass->ctile.name = NULL;
00058 mclass->ctile.index = -1;
00059 mclass->ctile.walkable = -1;
00060 mclass->ctile.hitpoints = -1;
00061 mclass->ctile.damage = -1;
00062 mclass->ctile_edit.x = 0;
00063 mclass->ctile_edit.y = 0;
00064 mclass->ctile_prop_edit = 0;
00065 mclass->drag_start_pt.x = -1;
00066 mclass->drag_start_pt.y = -1;
00067 mclass->char_start_pt.x = -1;
00068 mclass->char_start_pt.y = -1;
00069 mclass->save_flag = 0;
00070 mclass->filename = NULL;
00071 mclass->choose_startpt_flag = 0;
00072 mclass->drag_flag = 0;
00073 mclass->currentimgpic = new_image_label(mclass->win, rect(25,60,TILESIZE,TILESIZE),
00074 NULL, ALIGN_JUSTIFY);
00075 for(y=0;y<MAXMAPHEIGHT;y++){
00076 for(x=0;x<MAXMAPWIDTH;x++){
00077 for(level=0;level<2;level++){
00078 map_array->index[x][y][level] = prev_map_array->index[x][y][level] = -1;
00079 map_array->walkable[x][y][level] = prev_map_array->walkable[x][y][level] = -1;
00080 map_array->hitpoints[x][y][level] = prev_map_array->hitpoints[x][y][level] = -1;
00081 map_array->damage[x][y][level] = prev_map_array->damage[x][y][level] = -1;
00082 }
00083 }
00084 }
00085 mclass->mapdrawwidth = MAINWINWIDTH-150-((MAINWINWIDTH-150)%TILESIZE);
00086 mclass->mapdrawheight = MAINWINHEIGHT-65-((MAINWINHEIGHT-65)%TILESIZE);
00087 mclass->mapdrawing = new_control(mclass->win, rect(150,65,mclass->mapdrawwidth,mclass->mapdrawheight));
00088 on_control_redraw(mclass->mapdrawing, redraw_map);
00089 mclass->mapdrawtwidth = mclass->mapdrawwidth/TILESIZE;
00090 mclass->mapdrawtheight = mclass->mapdrawheight/TILESIZE;
00091 mclass->bit = new_bitmap(mclass->win, mclass->mapwidth*TILESIZE, mclass->mapheight*TILESIZE);
00092 mclass->mapgraphics = get_bitmap_graphics(mclass->bit);
00093 set_color(mclass->mapgraphics, CLEAR);
00094 fill_rect(mclass->mapgraphics, get_bitmap_area(mclass->bit));
00095 mclass->lev1 = new_bitmap(mclass->win, mclass->mapwidth*TILESIZE, mclass->mapheight*TILESIZE);
00096 mclass->lev1graphics = get_bitmap_graphics(mclass->lev1);
00097 set_color(mclass->lev1graphics, CLEAR);
00098 fill_rect(mclass->lev1graphics, get_bitmap_area(mclass->lev1));
00099 mclass->grid = new_bitmap(mclass->win, mclass->mapdrawwidth, mclass->mapdrawheight);
00100 mclass->gridgraphics = get_bitmap_graphics(mclass->grid);
00101 set_color(mclass->gridgraphics, CLEAR);
00102 fill_rect(mclass->gridgraphics, get_bitmap_area(mclass->grid));
00103 set_color(mclass->gridgraphics, BLACK);
00104 width = mclass->mapdrawwidth;
00105 height = mclass->mapdrawheight;
00106 if(mclass->mapwidth < mclass->mapdrawtwidth){ width = mclass->mapwidth * TILESIZE; }
00107 if(mclass->mapheight < mclass->mapdrawtheight){ height = mclass->mapheight * TILESIZE; }
00108 for(x=TILESIZE;x<=width;x+=TILESIZE){
00109 draw_line(mclass->gridgraphics, pt(x,0), pt(x,height));
00110 }
00111 for(y=TILESIZE;y<=height;y+=TILESIZE){
00112 draw_line(mclass->gridgraphics, pt(0,y), pt(width,y));
00113 }
00114 for(x=0;x<mclass->mapdrawtwidth;x++){
00115 sprintf(s, "%d", x);
00116 mclass->htilenum[x] = new_label(mclass->win, rect(150+(x*TILESIZE),50,TILESIZE,15), s, ALIGN_CENTER);
00117 }
00118 for(y=0;y<mclass->mapdrawtheight;y++){
00119 sprintf(s, "%d", y);
00120 mclass->vtilenum[y] = new_label(mclass->win, rect(130,65+(y*TILESIZE),15,20), s, ALIGN_RIGHT);
00121 }
00122 mclass->ctile_topleft.x = 0;
00123 mclass->ctile_topleft.y = 0;
00124 on_control_mouse_move(mclass->mapdrawing, mapdrawing_coor);
00125 on_control_mouse_down(mclass->mapdrawing, mapdrawing_click);
00126 on_control_mouse_drag(mclass->mapdrawing, mapdrawing_drag);
00127 on_control_mouse_up(mclass->mapdrawing, mapdrawing_mouseup);
00128 on_window_key_action(mclass->win, mapdrawing_move);
00129 on_window_key_down(mclass->win, mapdrawing_undo);
00130
00131
00132 mclass->lcurrentimg = new_label(mclass->win, rect(10,30,250,20), "Current Image", ALIGN_LEFT);
00133 debug = new_label(mclass->win, rect(20, MAINWINHEIGHT, 200, 20), "DEBUG", ALIGN_LEFT);
00134 debug2 = new_label(mclass->win, rect(250, MAINWINHEIGHT, 300, 20), "DEBUG", ALIGN_LEFT);
00135 mclass->lcurrentimgindex = new_label(mclass->win, rect(90,45,30,20), NULL, ALIGN_LEFT);
00136 mclass->lcurrentprop = new_label(mclass->win, rect(10,120,120,20), NULL, ALIGN_LEFT);
00137 mclass->showlev0btn = new_button(mclass->win, rect(10,145,75,20), "Level 0", choose_map_level);
00138 set_control_value(mclass->showlev0btn, 0);
00139 highlight(mclass->showlev0btn);
00140 mclass->currentmaplevel = 0;
00141 mclass->showlev1btn = new_button(mclass->win, rect(10,170,75,20), "Level 1", choose_map_level);
00142 set_control_value(mclass->showlev1btn, 1);
00143 mclass->showmergedbtn = new_button(mclass->win, rect(10,195,75,20), "Merged", choose_map_level);
00144 set_control_value(mclass->showmergedbtn, 2);
00145 mclass->startpointbtn = new_button(mclass->win, rect(10,220,90,20), "Select start pt", choose_start_pt);
00146 mclass->startptxfield = new_field(mclass->win, rect(10,245,30,22), NULL);
00147 mclass->startptyfield = new_field(mclass->win, rect(50,245,30,22), NULL);
00148 mclass->lproperties = new_label(mclass->win, rect(10,270,100,20), "Tile Properties", ALIGN_LEFT);
00149 mclass->walkablebox = new_check_box(mclass->win, rect(10,295,125,20), "Walkable", NULL);
00150 mclass->hitpointsfield = new_field(mclass->win, rect(5,320,40,22), NULL);
00151 mclass->lhitpoints = new_label(mclass->win, rect(50,320,95,20), "Hitpoints", ALIGN_LEFT);
00152 mclass->damagefield = new_field(mclass->win, rect(5,345,40,22), NULL);
00153 mclass->ldamage = new_label(mclass->win, rect(50,345,95,20), "Damage", ALIGN_LEFT);
00154 mclass->lcoor = new_label(mclass->win, rect(10,370,75,20), "xy(0,0)", ALIGN_LEFT);
00155 mclass->ltcoor = new_label(mclass->win, rect(10,395,125,20), "Tile xy(0,0)", ALIGN_LEFT);
00156 mclass->lmapsize = new_label(mclass->win, rect(10,420,140,50), "Map Size: 0x0", ALIGN_LEFT);
00157 mclass->lmove = new_label(mclass->win, rect(300,30,300,20), "Use the arrow keys to move the map", ALIGN_LEFT);
00158
00159 mclass->main_menubar = new_menu_bar(mclass->win);
00160 mclass->file_menu = new_menu(mclass->main_menubar, "File");
00161 mclass->new_item = new_menu_item(mclass->file_menu, "New", 'N', show_sizewin);
00162 mclass->open_item = new_menu_item(mclass->file_menu, "Open", 'O', open_mapfile);
00163 mclass->save_item = new_menu_item(mclass->file_menu, "Save", 'S', save_mapfile);
00164 mclass->line1_item = new_menu_item(mclass->file_menu, "-", 0, NULL);
00165 mclass->quit_item = new_menu_item(mclass->file_menu, "Quit", 'Q', exit_prog);
00166 mclass->options_menu = new_menu(mclass->main_menubar, "Options");
00167 mclass->loadtiles_item = new_menu_item(mclass->options_menu, "Load Tiles", 'L', load_tiles);
00168 mclass->tilewin_item = new_menu_item(mclass->options_menu, "Show TileWin", 'T', show_tilewin);
00169 mclass->mmap_item = new_menu_item(mclass->options_menu, "Show Mini Map", 'M', show_mmapwin);
00170 mclass->showgrid_item = new_menu_item(mclass->options_menu, "Show Map Grid", 'G', show_grid);
00171 mclass->help_menu = new_menu(mclass->main_menubar, "Help");
00172 mclass->help_item = new_menu_item(mclass->help_menu, "Help", 'H', show_helpwin);
00173 return(1);
00174 }
00175
00176 int init_tile_window(){
00177 int i,x,y,space;
00178 char s[3];
00179 tile_win->tile_size = TILESIZE;
00180 tile_win->r = rect(500,500,TWINWIDTH,500);
00181 tile_win->win = new_window(app, tile_win->r, "Tiles", STANDARD_WINDOW);
00182 on_window_close(tile_win->win, exit_tilewin);
00183 disable( tile_win->first_btn = new_button(tile_win->win, rect(5,5,80,25), "0-63", view_tiles) );
00184 set_control_value(tile_win->first_btn, 0);
00185 disable( tile_win->second_btn = new_button(tile_win->win, rect(85,5,80,25), "64-127", view_tiles) );
00186 set_control_value(tile_win->second_btn, 64);
00187 disable( tile_win->third_btn = new_button(tile_win->win, rect(5,30,80,25), "128-191", view_tiles) );
00188 set_control_value(tile_win->third_btn, 128);
00189 disable( tile_win->fourth_btn = new_button(tile_win->win, rect(85,30,80,25), "192-255", view_tiles) );
00190 set_control_value(tile_win->fourth_btn, 192);
00191 tile_win->tile_columns = (TWINWIDTH-25)/(TILESIZE+4);
00192 tile_win->tile_rows = 64 / tile_win->tile_columns;
00193 if( (64 % tile_win->tile_columns) != 0) tile_win->tile_rows++;
00194 x = 30;
00195 y = 65;
00196 space = 4;
00197 tile_win->tile_label[0] = new_label(tile_win->win, rect(5,y,25,30), "0", ALIGN_LEFT);
00198 tile_win->offset = 0;
00199 for(i=0; i<64; i++){
00200 disable( tile_win->tile_btn[i] = new_image_button(tile_win->win,
00201 rect(x,y,TILESIZE,TILESIZE),
00202 new_image(TILESIZE, TILESIZE, TILEDEPTH),
00203 choose_tile) );
00204 x = x+TILESIZE+space;
00205 if( (x+TILESIZE+space) > TWINWIDTH){
00206 y = y+TILESIZE+space;
00207 x = 30;
00208 sprintf(s, "%d", i+1);
00209
00210 tile_win->tile_label[(tile_win->tile_rows-((64-i+1)/tile_win->tile_columns))] =
00211 new_label(tile_win->win, rect(5,y,25,30), s, ALIGN_LEFT);
00212
00213 }
00214 hide_control(tile_win->tile_btn[i]);
00215 }
00216 hide_window(tile_win->win);
00217 return(1);
00218 }
00219
00220 int init_size_window(){;
00221 char tstring[50];
00222 sprintf(newmap_win->sheight, "10");
00223 sprintf(newmap_win->swidth, "10");
00224 newmap_win->win = new_window(app, rect(20,20,220,170),
00225 "Map Initialization", STANDARD_WINDOW | MODAL | FLOATING);
00226 on_window_close(newmap_win->win, exit_sizewin);
00227 sprintf(tstring, "Current tilesize in pixels: %d", (int) TILESIZE);
00228 newmap_win->ltilesize = new_label(newmap_win->win, rect(10,10,180,15), tstring, ALIGN_LEFT);
00229 newmap_win->lheight = new_label(newmap_win->win, rect(10,30,180,15), "Map height (in tile units)", ALIGN_LEFT);
00230 newmap_win->heightfield = new_field(newmap_win->win, rect(10,50,50,25), newmap_win->sheight);
00231 newmap_win->lwidth = new_label(newmap_win->win, rect(10,75,180,15), "Map width (in tile units)", ALIGN_LEFT);
00232 newmap_win->widthfield = new_field(newmap_win->win, rect(10,95,50,25), newmap_win->swidth);
00233 newmap_win->ok = new_button(newmap_win->win, rect(20,130,50,20), "Ok", ok_sizewin);
00234 newmap_win->cancel = new_button(newmap_win->win, rect(80,130,50,20), "Cancel", cancel_sizewin);
00235 return(1);
00236 }
00237
00238 int init_prop_window(){
00239 prop_win->win = new_window(app, rect(10,10,200,150),
00240 "Tile Properties", STANDARD_WINDOW | FLOATING);
00241 on_window_close(prop_win->win, exit_propwin);
00242 prop_win->ltileinfo = new_label(prop_win->win, rect(10,10,190,20), "", ALIGN_LEFT);
00243 prop_win->walkablebox = new_check_box(prop_win->win, rect(10,35,150,25), "Walkable", NULL);
00244 prop_win->hitpointsfield = new_field(prop_win->win, rect(5,65,40,25), NULL);
00245 prop_win->lhitpoints = new_label(prop_win->win, rect(50,65,150,25), "Hit Points", ALIGN_LEFT);
00246 prop_win->damagefield = new_field(prop_win->win, rect(5,95,40,25), NULL);
00247 prop_win->ldamage = new_label(prop_win->win, rect(50,95,150,25), "Damage", ALIGN_LEFT);
00248 prop_win->ok = new_button(prop_win->win, rect(20,120,50,20), "Ok", ok_propwin);
00249 prop_win->cancel = new_button(prop_win->win, rect(80,120,50,20), "Cancel", cancel_propwin);
00250 return(1);
00251 }
00252
00253 int init_help_window(){
00254 char * s;
00255 s = (char *) malloc(sizeof(char) * 2000);
00256 help_win->win = new_window(app, rect(10,10,600,550),
00257 "Map Editor Help", STANDARD_WINDOW);
00258 on_window_close(help_win->win, exit_helpwin);
00259 help_win->exitbtn = new_button(help_win->win, rect(10,10,50,20), "Close", cancel_helpwin);
00260 strcpy(s, "Command summary of mouse controls in map window:\n\n");
00261 strcat(s, "Left click: Places current tile at pointer location\n");
00262 strcat(s, "Double left click on tile: Opens tile property editing dialog\n");
00263 strcat(s, "Right click on tile: Sets tile under pointer as current tile\n");
00264 strcat(s, "Mouse drag: Fills rectangle defined by drag with current tile (level 0)\n");
00265 strcat(s, "Middle click: Clear the current tile\n\n");
00266 strcat(s, "Command summary of key commands:\n");
00267 strcat(s, " u: undoes last map change (aka tile placement(s))\n");
00268 strcat(s, " g: toggles map grid\n");
00269 strcat(s, " l: open tile definition file\n");
00270 strcat(s, " o: open a map level file\n");
00271 strcat(s, " s: save current map level\n");
00272 strcat(s, " n: create new map\n");
00273 strcat(s, " x: exit program\n");
00274 strcat(s, " h: help\n");
00275 strcat(s, " 0,1,2: Will toggle between Level 0, Level 1 and Merged views, respectively\n\n");
00276 strcat(s, "Map Overview:\n");
00277 strcat(s, " All maps are composed of two levels of tiles. Level 0 contains all the background tiles\n");
00278 strcat(s, "and must be completely filled. Level 1 tiles are special tiles such as enemies, powerups,\n");
00279 strcat(s, "teleporters, exits, etc and generally contain some transparency and are animated. Level 0 \n");
00280 strcat(s, "tiles all have default walkable, hitpoint and damage properties; Level 1 tiles have item ");
00281 strcat(s, "specific properties. These properties can be changed by the map designer.\n\n");
00282 strcat(s, "Tile Information:\n");
00283 strcat(s, " All tile information is taken from a tile definition file. This file associates tile\n");
00284 strcat(s, "names with an index (0-255) number and assigns the tiles default properties. This tile\n");
00285 strcat(s, "definition file and associated GIF image files are absolutely necessary to proper operation");
00286 strcat(s, "of this program. The tile definition file is created manually.");
00287 help_win->ltext = new_label(help_win->win, rect(5,35,590,510), s, ALIGN_LEFT);
00288 return(1);
00289 }
00290
00291
00292 int init_minimap_window(){;
00293 int x, y;
00294 char s[20];
00295 minimap_win->win = new_window(app, rect(200,200,350,350),
00296 "Mini Map", STANDARD_WINDOW | FLOATING);
00297 on_window_close(minimap_win->win, exit_mmapwin);
00298 if(mwin->mapwidth > mwin->mapheight){
00299 minimap_win->r.width = 300;
00300 minimap_win->r.height = (300 * mwin->mapheight) / mwin->mapwidth;
00301 }else{
00302 minimap_win->r.height = 300;
00303 minimap_win->r.width = (300 * mwin->mapwidth) / mwin->mapheight;
00304 }
00305 minimap_win->frame.width = (minimap_win->r.width * mwin->mapdrawtwidth) / mwin->mapwidth;
00306 minimap_win->frame.height = (minimap_win->r.height * mwin->mapdrawtheight) / mwin->mapheight;
00307 minimap_win->mmap = new_control(minimap_win->win, rect(25,25,minimap_win->r.width, minimap_win->r.height));
00308 on_control_redraw(minimap_win->mmap, redraw_minimap);
00309 on_control_mouse_move(minimap_win->mmap, minimap_coor);
00310 on_control_mouse_down(minimap_win->mmap, minimap_click);
00311 minimap_win->mmap_bit = new_bitmap(minimap_win->win, minimap_win->r.width, minimap_win->r.height);
00312 minimap_win->mmap_graphics = get_bitmap_graphics(minimap_win->mmap_bit);
00313 minimap_win->lev0_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
00314 minimap_win->lev1_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
00315 for (y=0; y < minimap_win->lev0_image->height; y++){
00316 for (x=0; x < minimap_win->lev0_image->width; x++){
00317 minimap_win->lev0_image->data32[y][x] = CLEAR;
00318 minimap_win->lev1_image->data32[y][x] = CLEAR;
00319 }
00320 }
00321 sprintf(s, "Map size: %d x %d", mwin->mapwidth, mwin->mapheight);
00322 minimap_win->size_label = new_label(minimap_win->win, rect(25,325,300,20), s, ALIGN_LEFT);
00323 minimap_win->instr_label = new_label(minimap_win->win, rect(25,0,300,20), "Click to edit region", ALIGN_LEFT);
00324 return(1);
00325 }
00326
00327 void mapdrawing_click(Control* c, int buttons, Point p){
00328 int x,y,x1,y1, index, level;
00329 static int toggle_level = 0, tl2;
00330 static int samepoint_x = 500;
00331 static int samepoint_y = 500;
00332 char s[18];
00333 set_control_text(debug, "mapdrawing_click");
00334 x = p.x/TILESIZE;
00335 y = p.y/TILESIZE;
00336 mwin->mouse_pt.x = x;
00337 mwin->mouse_pt.y = y;
00338 if(x+mwin->ctile_topleft.x > mwin->mapwidth - 1 ||
00339 y+mwin->ctile_topleft.y > mwin->mapheight - 1) return;
00340 if(buttons & LEFT_BUTTON){
00341 if(mwin->ctile.index == -1) return;
00342 if(mwin->choose_startpt_flag == 1){
00343 mwin->char_start_pt.x = x + mwin->ctile_topleft.x;
00344 mwin->char_start_pt.y = y + mwin->ctile_topleft.y;
00345 sprintf(s,"%d", x + mwin->ctile_topleft.x);
00346 set_control_text(mwin->startptxfield, s);
00347 sprintf(s,"%d", y + mwin->ctile_topleft.y);
00348 set_control_text(mwin->startptyfield, s);
00349 unhighlight(mwin->startpointbtn);
00350 mwin->choose_startpt_flag = 0;
00351 return;
00352 }
00353 if(mwin->double_click_flag){
00354 mwin->double_click_flag = 0;
00355 mapdrawing_undo(mwin->win, 'z');
00356 prop_win->index = map_array->index[x][y][mwin->currentmaplevel];
00357 show_propwin();
00358 return;
00359 }else{
00360 mwin->double_click_flag = 1;
00361 clicktime = new_timer(app, timer_callback, 250);
00362 }
00363 for(y1=0;y1<mwin->mapheight;y1++){
00364 for(x1=0;x1<mwin->mapwidth;x1++){
00365 for(level=0;level<2;level++){
00366 prev_map_array->index[x1][y1][level] = map_array->index[x1][y1][level];
00367 prev_map_array->walkable[x1][y1][level] = map_array->walkable[x1][y1][level];
00368 prev_map_array->hitpoints[x1][y1][level] = map_array->hitpoints[x1][y1][level];
00369 prev_map_array->damage[x1][y1][level] = map_array->damage[x1][y1][level];
00370 }
00371 }
00372 }
00373 if((mwin->ctile.index < 177 && mwin->currentmaplevel == 1) || mwin->ctile.index == -1){
00374 ask_ok(app, "Tile level error", "Cannot place this tile on this level!\nTiles 0-176 -> Level 0\nTiles 177-256 -> Level 1");
00375 return;
00376
00377
00378
00379
00380 }
00381 if(mwin->ctile.index >= 177 && mwin->currentmaplevel == 0){
00382 ask_ok(app, "Tile level error", "Cannot place this tile on this level!\nTiles 0-176 -> Level 0\nTiles 177-256 -> Level 1");
00383 return;
00384
00385
00386
00387
00388 }
00389 level = mwin->currentmaplevel;
00390 if(level = 2 && mwin->ctile.index < 177) level = 0;
00391 if(level = 2 && mwin->ctile.index >= 177) level = 1;
00392 mwin->ctile.img;
00393 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] =
00394 mwin->ctile.index;
00395 map_array->walkable[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] =
00396 mwin->ctile.walkable;
00397 map_array->hitpoints[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] =
00398 mwin->ctile.hitpoints;
00399 map_array->damage[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] =
00400 mwin->ctile.damage;
00401 mwin->ctile_edit.x = x;
00402 mwin->ctile_edit.y = y;
00403 mwin->save_flag = 1;
00404 sprintf(dstring, "click x,y(%d, %d) topleft(%d, %d)", x, y, (mwin->ctile_topleft.x+x)*TILESIZE, (mwin->ctile_topleft.y+y)*TILESIZE);
00405 set_control_text(debug2, dstring);
00406 if(level == 0){
00407 draw_image(mwin->mapgraphics,
00408 rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE, TILESIZE, TILESIZE),
00409 mwin->ctile.img,
00410 rect(0,0,TILESIZE, TILESIZE));
00411 copy_rect_image(minimap_win->lev0_image,
00412 pt((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE),
00413 mwin->ctile.img,
00414 rect(0,0,TILESIZE, TILESIZE));
00415 }else{
00416 draw_image(mwin->lev1graphics,
00417 rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE, TILESIZE, TILESIZE),
00418 mwin->ctile.img,
00419 rect(0,0,TILESIZE, TILESIZE));
00420 copy_rect_image(minimap_win->lev1_image,
00421 pt((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE),
00422 mwin->ctile.img,
00423 rect(0,0,TILESIZE, TILESIZE));
00424 }
00425 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00426 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00427 } else if(buttons & MIDDLE_BUTTON){
00428 if(map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][0] == -1 &&
00429 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][1] == -1) {
00430 return;
00431 }
00432 for(y1=0;y1<mwin->mapheight;y1++){
00433 for(x1=0;x1<mwin->mapwidth;x1++){
00434 for(level=0;level<2;level++){
00435 prev_map_array->index[x1][y1][level] = map_array->index[x1][y1][level];
00436 prev_map_array->walkable[x1][y1][level] = map_array->walkable[x1][y1][level];
00437 prev_map_array->hitpoints[x1][y1][level] = map_array->hitpoints[x1][y1][level];
00438 prev_map_array->damage[x1][y1][level] = map_array->damage[x1][y1][level];
00439 }
00440 }
00441 }
00442 level = mwin->currentmaplevel;
00443 index = map_array->index[x][y][level];
00444 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] = -1;
00445 map_array->walkable[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] = -1;
00446 map_array->hitpoints[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] = -1;
00447 map_array->damage[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][level] = -1;
00448 mwin->save_flag = 1;
00449 if(level == 0 || level == 2){
00450 set_color(mwin->mapgraphics, WHITE);
00451 fill_rect(mwin->mapgraphics, rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE, TILESIZE,TILESIZE));
00452 copy_rect(get_control_graphics(mwin->mapdrawing),
00453 pt(x*TILESIZE, y*TILESIZE),
00454 mwin->mapgraphics,
00455 rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE,TILESIZE,TILESIZE));
00456 for(x=0; x<TILESIZE; x++){
00457 for(y=0; y<TILESIZE; y++){
00458 minimap_win->lev0_image->data32[y+(mwin->ctile_topleft.y*TILESIZE)][x+(mwin->ctile_topleft.x)] = CLEAR;
00459 }
00460 }
00461 }
00462 if(level == 1 || level == 2){
00463 set_color(mwin->lev1graphics, WHITE);
00464 fill_rect(mwin->lev1graphics, rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE, TILESIZE,TILESIZE));
00465 copy_rect(get_control_graphics(mwin->mapdrawing),
00466 pt(x*TILESIZE, y*TILESIZE),
00467 mwin->lev1graphics,
00468 rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE,TILESIZE,TILESIZE));
00469 for(x=0; x<TILESIZE; x++){
00470 for(y=0; y<TILESIZE; y++){
00471 minimap_win->lev1_image->data32[y+(mwin->ctile_topleft.y*TILESIZE)][x+(mwin->ctile_topleft.x)] = CLEAR;
00472 }
00473 }
00474 }
00475 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00476 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00477 return;
00478 }else if(buttons & RIGHT_BUTTON){
00479 if(mwin->currentmaplevel == 2){
00480 if(toggle_level == 1 && samepoint_x == x && samepoint_y == y){ toggle_level = 0; tl2=1;
00481 }else if(toggle_level == 0 && samepoint_x == x && samepoint_y == y){
00482 toggle_level = 1; tl2=0;}
00483 samepoint_x = x; samepoint_y = y;
00484 index =
00485 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][toggle_level];
00486 if(index == -1) return;
00487 }else{
00488 index =
00489 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][mwin->currentmaplevel];
00490 }
00491 if(index == -1)return;
00492 mwin->ctile.index = index;
00493 level = 1;
00494 if(mwin->ctile.index < 128) level = 0;
00495 mwin->ctile.img = tile_array[index].img;
00496 mwin->ctile.bit = image_to_bitmap(mwin->win, mwin->ctile.img);
00497 set_control_image(mwin->currentimgpic, mwin->ctile.img);
00498 set_control_text(mwin->lcurrentimg, tile_array[index].name);
00499 sprintf(s, "%d", index);
00500 set_control_text(mwin->lcurrentimgindex, s);
00501 set_currentimg_props(index);
00502 redraw_control(mwin->currentimgpic);
00503 redraw_control(mwin->lcurrentimg);
00504 redraw_control(mwin->lcurrentimgindex);
00505 }
00506 return;
00507 }
00508
00509
00510 void mapdrawing_mouseup(Control* c, int buttons, Point p){
00511 int x,y, level;
00512 Point start;
00513 Point end;
00514 Point temp;
00515 sprintf(dstring, "ctile.index=%d currentmaplevel=%d", mwin->ctile.index, mwin->currentmaplevel);
00516 set_control_text(debug2, dstring);
00517 if(mwin->ctile.index == -1 || mwin->currentmaplevel == 1 || !mwin->drag_flag){ mwin->drag_flag = 0; return; }
00518 set_control_text(debug2, "mapdrawing_mouseup1");
00519 if(mwin->ctile.index > 128 && mwin->currentmaplevel == 2){ mwin->drag_flag = 0; return; }
00520 set_control_text(debug2, "mapdrawing_mouseup2");
00521 if(mwin->drag_start_pt.x == -1){ mwin->drag_flag = 0; return; }
00522 set_control_text(debug2, "mapdrawing_mouseup3");
00523 start.x = mwin->drag_start_pt.x; start.y = mwin->drag_start_pt.y;
00524 end.x = p.x/TILESIZE; end.y = p.y/TILESIZE;
00525 if(start.x == end.x && start.y == end.y){ mwin->drag_flag = 0; return; }
00526 set_control_text(debug2, "mapdrawing_mouseup4");
00527 if(start.x+mwin->ctile_topleft.x > mwin->mapwidth - 1 ||
00528 end.x+mwin->ctile_topleft.x > mwin->mapwidth - 1 ||
00529 start.y+mwin->ctile_topleft.y > mwin->mapheight - 1 ||
00530 end.y+mwin->ctile_topleft.y > mwin->mapheight - 1){ mwin->drag_flag = 0; return; }
00531 set_control_text(debug2, "mapdrawing_mouseup5");
00532 if(!(start.x == mwin->mouse_pt.x && start.y == mwin->mouse_pt.y)){
00533 for(y=0;y<mwin->mapheight;y++){
00534 for(x=0;x<mwin->mapwidth;x++){
00535 for(level=0;level<2;level++){
00536 prev_map_array->index[x][y][level] = map_array->index[x][y][level];
00537 prev_map_array->walkable[x][y][level] = map_array->walkable[x][y][level];
00538 prev_map_array->hitpoints[x][y][level] = map_array->hitpoints[x][y][level];
00539 prev_map_array->damage[x][y][level] = map_array->damage[x][y][level];
00540 }
00541 }
00542 }
00543 }
00544
00545
00546 if(start.x <= end.x){
00547 if(start.y >= end.y){
00548 temp.y = start.y;
00549 start.y = end.y;
00550 end.y = temp.y;
00551 }
00552 }else{
00553 if(start.y <= end.y){
00554 temp.x = start.x;
00555 start.x = end.x;
00556 end.x = temp.x;
00557 }else{
00558 temp.y = start.y; temp.x = start.x;
00559 start.y = end.y; start.x = end.x;
00560 end.y = temp.y; end.x = temp.x;
00561 }
00562 }
00563
00564 sprintf(dstring, "drag copy start(%d, %d) end(%d, %d)", start.x, start.y, end.x, end.y);
00565 set_control_text(debug2, dstring);
00566 for(y=start.y;y<=end.y;y++){
00567 for(x=start.x;x<=end.x;x++){
00568 draw_image(mwin->mapgraphics,
00569 rect((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE, TILESIZE,TILESIZE),
00570 mwin->ctile.img,
00571 rect(0,0,TILESIZE, TILESIZE));
00572 copy_rect_image(minimap_win->lev0_image,
00573 pt((x+mwin->ctile_topleft.x)*TILESIZE, (y+mwin->ctile_topleft.y)*TILESIZE),
00574 mwin->ctile.img,
00575 rect(0,0,TILESIZE, TILESIZE));
00576 map_array->index[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][0] =
00577 mwin->ctile.index;
00578 map_array->walkable[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][0] =
00579 mwin->ctile.walkable;
00580 map_array->hitpoints[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][0] =
00581 mwin->ctile.hitpoints;
00582 map_array->damage[x+mwin->ctile_topleft.x][y+mwin->ctile_topleft.y][0] =
00583 mwin->ctile.damage;
00584 }
00585 }
00586 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00587 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00588 mwin->drag_flag = 0;
00589 mwin->drag_start_pt.x = mwin->drag_start_pt.y = -1;
00590 mwin->save_flag = 1;
00591 return;
00592 }
00593
00594
00595 void mapdrawing_drag(Control* c, int buttons, Point p){
00596 if(mwin->drag_flag)return;
00597 if(buttons & RIGHT_BUTTON)return;
00598 if(buttons & MIDDLE_BUTTON)return;
00599 mwin->drag_start_pt.x = p.x/TILESIZE;
00600 mwin->drag_start_pt.y = p.y/TILESIZE;
00601 mwin->drag_flag = 1;
00602 set_control_text(debug, "mapdrawing_drag");
00603 return;
00604 }
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616 void mapdrawing_coor(Control* c, int buttons, Point p){
00617 char s[13];
00618 int level,x,y, index;
00619 static int prev_x = 0, prev_y = 0;
00620 prop_strings pstring;
00621 x = p.x/TILESIZE + mwin->ctile_topleft.x;
00622 y = p.y/TILESIZE + mwin->ctile_topleft.y;
00623 level = mwin->currentmaplevel;
00624 if(level == 2) level = 0;
00625 index = map_array->index[x][y][level];
00626 sprintf(s, "xy(%d,%d)", p.x, p.y);
00627 set_control_text(mwin->lcoor, s);
00628 p.x = p.x/TILESIZE + mwin->ctile_topleft.x;
00629 p.y = p.y/TILESIZE + mwin->ctile_topleft.y;
00630
00631 if((p.x == prev_x) && (p.y == prev_y)) return;
00632 get_prop_strings(index, 1, &pstring);
00633 prev_x = p.x; prev_y = p.y;
00634 sprintf(s, "Tile xy(%d,%d)", p.x, p.y);
00635 set_control_text(mwin->ltcoor, s);
00636 if(map_array->index[p.x][p.y][level] != -1){
00637 sprintf(s, "%d", map_array->hitpoints[p.x][p.y][level]);
00638 set_control_text(mwin->hitpointsfield, s);
00639 set_control_text(mwin->lhitpoints, pstring.second);
00640 sprintf(s, "%d", map_array->damage[p.x][p.y][level]);
00641 set_control_text(mwin->damagefield, s);
00642 set_control_text(mwin->ldamage, pstring.third);
00643 set_control_text(mwin->walkablebox, pstring.first);
00644 if(map_array->walkable[p.x][p.y][level] == 1){
00645 check(mwin->walkablebox); redraw_control(mwin->walkablebox);
00646 }else if(map_array->walkable[p.x][p.y][level] == 0){
00647 uncheck(mwin->walkablebox); redraw_control(mwin->walkablebox);
00648 }
00649 set_control_text(debug, "mapdrawing_coor1");
00650 }else{
00651 set_control_text(mwin->walkablebox, " ");
00652 uncheck(mwin->walkablebox);
00653 set_control_text(mwin->damagefield, " ");
00654 set_control_text(mwin->ldamage, " ");
00655 set_control_text(mwin->hitpointsfield, " ");
00656 set_control_text(mwin->lhitpoints, " ");
00657
00658
00659
00660 hide_control(mwin->lhitpoints);
00661 hide_control(mwin->ldamage);
00662 set_control_text(debug, "mapdrawing_coor2");
00663 }
00664
00665 return;
00666 }
00667
00668 void mapdrawing_move(Window* w, unsigned long key){
00669 int x,y, update;
00670 char s[3];
00671 sprintf(dstring, "key: %c", key);
00672 set_control_text(debug2, dstring);
00673 update = 0;
00674 switch(key){
00675 case LEFT:
00676 sprintf(dstring, "key: left (%d, %d) %d, %d", mwin->ctile_topleft.x, mwin->ctile_topleft.y, mwin->mapwidth, mwin->mapdrawtwidth);
00677 set_control_text(debug2, dstring);
00678 if(mwin->ctile_topleft.x == 0 || mwin->mapwidth <= mwin->mapdrawtwidth){break;}
00679 mwin->ctile_topleft.x -= 1;
00680 update = 1;
00681 break;
00682 case RIGHT:
00683 sprintf(dstring, "key: right (%d, %d) %d, %d", mwin->ctile_topleft.x, mwin->ctile_topleft.y, mwin->mapwidth, mwin->mapdrawtwidth);
00684 set_control_text(debug2, dstring);;
00685 if(mwin->mapwidth <= mwin->mapdrawtwidth ||
00686 mwin->mapwidth == (mwin->ctile_topleft.x + mwin->mapdrawtwidth)){break;}
00687 mwin->ctile_topleft.x += 1;
00688 update = 1;
00689 break;
00690 case UP:
00691 sprintf(dstring, "key: up (%d, %d) %d, %d, %d", mwin->ctile_topleft.x, mwin->ctile_topleft.y, mwin->mapheight, mwin->mapdrawtheight, mwin->mapdrawheight);
00692 set_control_text(debug2, dstring);
00693 if(mwin->ctile_topleft.y == 0 || mwin->mapheight <= mwin->mapdrawtheight){break;}
00694 mwin->ctile_topleft.y -= 1;
00695 update = 1;
00696 break;
00697 case DOWN:
00698 sprintf(dstring, "key: down (%d, %d) %d, %d, %d", mwin->ctile_topleft.x, mwin->ctile_topleft.y, mwin->mapheight, mwin->mapdrawtheight, mwin->mapdrawheight);
00699 set_control_text(debug2, dstring);
00700 if(mwin->mapheight <= mwin->mapdrawtheight ||
00701 (mwin->mapheight == (mwin->ctile_topleft.y + mwin->mapdrawtheight))){break;}
00702 mwin->ctile_topleft.y += 1;
00703 update = 1;
00704 break;
00705 case F10:
00706 update = 1;
00707 break;
00708 }
00709 if (update){
00710 for(x=mwin->ctile_topleft.x;x<mwin->mapdrawtwidth+mwin->ctile_topleft.x;x++){
00711 set_control_text(mwin->htilenum[x-mwin->ctile_topleft.x], NULL);
00712 if(x < mwin->mapwidth){
00713 itoa(x, s, 10);
00714 set_control_text(mwin->htilenum[x-mwin->ctile_topleft.x], s);
00715 }
00716 }
00717 for(y=mwin->ctile_topleft.y;y<mwin->mapdrawtheight+mwin->ctile_topleft.y;y++){
00718 set_control_text(mwin->vtilenum[y-mwin->ctile_topleft.y], NULL);
00719 if(y < mwin->mapheight){
00720 itoa(y, s, 10);
00721 set_control_text(mwin->vtilenum[y-mwin->ctile_topleft.y], s);
00722 }
00723 }
00724 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00725 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00726 }
00727 set_control_text(debug, "mapdrawing_move");
00728 }
00729
00730 void mapdrawing_undo(Window* c, unsigned long key){
00731 int x,y,level;
00732 sprintf(dstring, "key: %c", key);
00733 set_control_text(debug2, dstring);
00734 switch(key){
00735 case 'z':
00736 set_control_text(debug2, "Copying undo graphics");
00737 del_graphics(mwin->mapgraphics);
00738 del_graphics(mwin->lev1graphics);
00739 del_bitmap(mwin->bit);
00740 del_bitmap(mwin->lev1);
00741 mwin->bit = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
00742 mwin->lev1 = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
00743 mwin->mapgraphics = get_bitmap_graphics(mwin->bit);
00744 mwin->lev1graphics = get_bitmap_graphics(mwin->lev1);
00745 set_color(mwin->mapgraphics, WHITE);
00746 fill_rect(mwin->mapgraphics, get_bitmap_area(mwin->bit));
00747 set_color(mwin->lev1graphics, CLEAR);
00748 fill_rect(mwin->lev1graphics, get_bitmap_area(mwin->lev1));
00749 for(y=0;y<mwin->mapheight;y++){
00750 for(x=0;x<mwin->mapwidth;x++){
00751 for(level=0;level<2;level++){
00752 map_array->index[x][y][level] = prev_map_array->index[x][y][level];
00753 map_array->walkable[x][y][level] = prev_map_array->walkable[x][y][level];
00754 map_array->hitpoints[x][y][level] = prev_map_array->hitpoints[x][y][level];
00755 map_array->damage[x][y][level] = prev_map_array->damage[x][y][level];
00756 if(map_array->index[x][y][level] != -1) {
00757 if(level == 0){
00758 draw_image(mwin->mapgraphics,
00759 rect(x*TILESIZE, y*TILESIZE, TILESIZE, TILESIZE),
00760 tile_array[map_array->index[x][y][level]].img,
00761 rect(0,0,TILESIZE, TILESIZE));
00762 copy_rect_image(minimap_win->lev0_image,
00763 pt(x*TILESIZE, y*TILESIZE),
00764 mwin->ctile.img,
00765 rect(0,0,TILESIZE, TILESIZE));
00766 }
00767 if(level == 1){
00768 draw_image(mwin->lev1graphics,
00769 rect(x*TILESIZE, y*TILESIZE, TILESIZE, TILESIZE),
00770 tile_array[map_array->index[x][y][level]].img,
00771 rect(0,0,TILESIZE, TILESIZE));
00772 copy_rect_image(minimap_win->lev1_image,
00773 pt(x*TILESIZE, y*TILESIZE),
00774 mwin->ctile.img,
00775 rect(0,0,TILESIZE, TILESIZE));
00776 }
00777 }
00778 }
00779 }
00780 }
00781 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00782 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00783 break;
00784 case 'l':
00785 load_tiles(mwin->loadtiles_item);
00786 break;
00787 case 'g':
00788 show_grid(mwin->showgrid_item);
00789 break;
00790 case 'n':
00791 show_sizewin(mwin->new_item);
00792 break;
00793 case 'm':
00794 show_mmapwin(mwin->mmap_item);
00795 break;
00796 case 'o':
00797 open_mapfile(mwin->open_item);
00798 break;
00799 case 's':
00800 save_mapfile(mwin->save_item);
00801 break;
00802 case 'h':
00803 show_helpwin(mwin->help_item);
00804 break;
00805 case '0':
00806 choose_map_level(mwin->showlev0btn);
00807 break;
00808 case '1':
00809 choose_map_level(mwin->showlev1btn);
00810 break;
00811 case '2':
00812 choose_map_level(mwin->showmergedbtn);
00813 break;
00814 case 'x':
00815 exit_prog(mwin->quit_item);
00816 }
00817 return;
00818 }
00819
00820 void choose_map_level(Control* b){
00821 int index = (int) get_control_value(b);
00822 sprintf(dstring, "choose_map_level: %d", index);
00823 set_control_text(debug, dstring);
00824 unhighlight(mwin->showlev0btn);
00825 unhighlight(mwin->showlev1btn);
00826 unhighlight(mwin->showmergedbtn);
00827 switch(index){
00828 case 0: highlight(mwin->showlev0btn); mwin->currentmaplevel = index; break;
00829 case 1: highlight(mwin->showlev1btn); mwin->currentmaplevel = index; break;
00830 case 2: highlight(mwin->showmergedbtn); mwin->currentmaplevel = index;
00831 }
00832 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
00833 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
00834 return;
00835 }
00836
00837 void minimap_coor(Control *c, int i, Point p){
00838 Graphics *g = get_control_graphics(minimap_win->mmap);
00839 minimap_win->frame.x = p.x - minimap_win->frame.width/2;
00840 minimap_win->frame.y = p.y - minimap_win->frame.height/2;
00841 if (p.x + (minimap_win->frame.width/2) > minimap_win->r.width)
00842 minimap_win->frame.x = minimap_win->r.width - minimap_win->frame.width;
00843 if (p.y + (minimap_win->frame.height/2) > minimap_win->r.height)
00844 minimap_win->frame.y = minimap_win->r.height - minimap_win->frame.height;
00845 if (p.x <= minimap_win->frame.width/2)
00846 minimap_win->frame.x = 0;
00847 if (p.y <= minimap_win->frame.height/2)
00848 minimap_win->frame.y = 0;
00849 set_color(g, WHITE);
00850 fill_rect(g, get_control_area(c));
00851 copy_rect(g,
00852 pt(0,0),
00853 minimap_win->mmap_graphics,
00854 get_bitmap_area(minimap_win->mmap_bit));
00855 set_color(g, BLACK);
00856 draw_rect(g, get_control_area(minimap_win->mmap));
00857 draw_rect(g, rect(minimap_win->frame.x,minimap_win->frame.y,minimap_win->frame.width, minimap_win->frame.height));
00858 sprintf(dstring, "mmcoor: %d %d, %d %d", minimap_win->frame.x,minimap_win->frame.y,minimap_win->frame.width, minimap_win->frame.height);
00859 set_control_text(debug2, dstring);
00860 del_graphics(g);
00861 }
00862
00863 void minimap_click(Control *c, int i, Point p){
00864 mwin->ctile_topleft.x = (mwin->mapwidth * minimap_win->frame.x) / minimap_win->r.width;
00865 mwin->ctile_topleft.y = (mwin->mapheight * minimap_win->frame.y) / minimap_win->r.height;
00866 mapdrawing_move(mwin->win, F10);
00867 }
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881 void redraw_map(Control *c, Graphics *g){
00882 int x,y, width, height, index;
00883 int grid;
00884
00885
00886 set_color(g, WHITE);
00887 fill_rect(g, get_control_area(c));
00888
00889 if(mwin->currentmaplevel == 0 || mwin->currentmaplevel == 2){
00890 copy_rect(g,
00891 pt(0,0),
00892 mwin->mapgraphics,
00893 rect(TILESIZE*mwin->ctile_topleft.x, TILESIZE*mwin->ctile_topleft.y,mwin->mapdrawwidth, mwin->mapdrawheight));
00894 }
00895 if(mwin->currentmaplevel == 1 || mwin->currentmaplevel == 2){
00896 copy_rect(g,
00897 pt(0,0),
00898 mwin->lev1graphics,
00899 rect(TILESIZE*mwin->ctile_topleft.x, TILESIZE*mwin->ctile_topleft.y,mwin->mapdrawwidth, mwin->mapdrawheight));
00900 }
00901
00902 set_color(g, BLACK);
00903 draw_rect(g, get_control_area(c));
00904
00905 if(menu_item_is_checked(mwin->showgrid_item)){
00906 copy_rect(g,
00907 pt(0,0),
00908 mwin->gridgraphics,
00909 rect(0,0,mwin->mapdrawwidth, mwin->mapdrawheight));
00910 }
00911
00912 }
00913
00914 void redraw_minimap(Control *c, Graphics *g){
00915 int width, height;
00916 int grid;
00917
00918 set_color(g, WHITE);
00919 fill_rect(g, get_control_area(c));
00920 set_color(g, BLACK);
00921 draw_rect(g, get_control_area(c));
00922 set_control_text(debug2, "redrawing mini map");
00923
00924 draw_image(g,
00925 rect(0,0,minimap_win->r.width, minimap_win->r.height),
00926 minimap_win->lev0_image,
00927 get_image_area(minimap_win->lev0_image));
00928 draw_image(g,
00929 rect(0,0,minimap_win->r.width, minimap_win->r.height),
00930 minimap_win->lev1_image,
00931 get_image_area(minimap_win->lev0_image));
00932
00933 del_bitmap(minimap_win->mmap_bit);
00934 del_graphics(minimap_win->mmap_graphics);
00935 minimap_win->mmap_bit = new_bitmap(minimap_win->win, minimap_win->r.width, minimap_win->r.height);
00936 minimap_win->mmap_graphics = get_bitmap_graphics(minimap_win->mmap_bit);
00937 draw_image(minimap_win->mmap_graphics,
00938 rect(0,0,minimap_win->r.width, minimap_win->r.height),
00939 minimap_win->lev0_image,
00940 get_image_area(minimap_win->lev0_image));
00941 }
00942
00943 void choose_start_pt(Control* b){
00944 mwin->choose_startpt_flag = 1;
00945 highlight(mwin->startpointbtn);
00946 return;
00947 }
00948 void show_sizewin(MenuItem *m){
00949 char *question = "Current unsaved map elements exist. Creating a new map will\nerase all current map elements. Continue?";
00950 int x,y,level;
00951 if(mwin->save_flag){
00952 for(y=0;y<MAXMAPHEIGHT;y++){
00953 for(x=0;x<MAXMAPWIDTH;x++){
00954 for(level=0;level<2;level++){
00955 if(map_array->index[x][y][level] != -1){
00956 if(ask_yes_no(app, " ", question) == -1){
00957 return;
00958 }else{
00959 show_window(newmap_win->win);
00960 return;
00961 }
00962 }
00963 }
00964 }
00965 }
00966 }
00967 show_window(newmap_win->win);
00968 return;
00969 }
00970
00971 void show_propwin(){
00972 char s[40];
00973 int index, level, x, y;
00974 prop_strings pstring, pvalue;
00975 x = mwin->ctile_edit.x + mwin->ctile_topleft.x;
00976 y = mwin->ctile_edit.y + mwin->ctile_topleft.y;
00977 level = mwin->currentmaplevel;
00978 if(level == 2) level = 0;
00979 index = map_array->index[x][y][level];
00980 get_prop_strings(index, 0, &pstring);
00981 if(map_array->index[x][y][level] != -1){
00982 sprintf(s, "(%d,%d) %s", mwin->ctile_edit.x, mwin->ctile_edit.y, tile_array[index].name);
00983 sprintf(pvalue.second, "%d", map_array->hitpoints[x][y][level]);
00984 sprintf(pvalue.third, "%d", map_array->damage[x][y][level]);
00985 set_control_text(prop_win->hitpointsfield, pvalue.second);
00986 set_control_text(prop_win->damagefield, pvalue.third);
00987 if(map_array->walkable[x][y][level] == 1){
00988 check(prop_win->walkablebox);
00989 }else if(map_array->walkable[x][y][level] == 0){
00990 uncheck(prop_win->walkablebox);
00991 }
00992 set_control_text(prop_win->ltileinfo, s);
00993 set_control_text(prop_win->walkablebox, pstring.first);
00994 set_control_text(prop_win->lhitpoints, pstring.second);
00995 set_control_text(prop_win->ldamage, pstring.third);
00996 show_window(prop_win->win);
00997 }
00998 }
00999
01000 void show_mmapwin(MenuItem *m){
01001 check_menu_item(m);
01002 show_window(minimap_win->win);
01003 return;
01004 }
01005
01006 void open_mapfile(MenuItem *m){
01007 char line[80], tstring[50], s[3];
01008 int width, height, x, y, index, level, wflag, hitpoints, damage;
01009 int status = 0;
01010 tprops tp;
01011 mwin->filename = ask_file_open(app, "Load mapfile", "Open", "*.ppm");
01012
01013 if(!mwin->filename)return;
01014 openmapfile = fopen(mwin->filename, "r");
01015 load_tiles(mwin->loadtiles_item);
01016 while(fgets(line, 80, openmapfile) != NULL){
01017 if(line[0] != '#') {
01018 if(line[0] == 'L' && line[1] == '1'){
01019 status = 3;
01020 }else{
01021 switch(status){
01022 case 0:
01023 sscanf(line, "%d %d", &width, &height);
01024 for(y=0;y<MAXMAPHEIGHT;y++){
01025 for(x=0;x<MAXMAPWIDTH;x++){
01026 for(level=0;level<2;level++){
01027 map_array->index[x][y][level] = prev_map_array->index[x][y][level] = -1;
01028 map_array->walkable[x][y][level] = prev_map_array->walkable[x][y][level] = -1;
01029 map_array->hitpoints[x][y][level] = prev_map_array->hitpoints[x][y][level] = -1;
01030 map_array->damage[x][y][level] = prev_map_array->damage[x][y][level] = -1;
01031 }
01032 }
01033 }
01034 sprintf(tstring, "Map Size: %dx%d", width, height);
01035 set_control_text(mwin->lmapsize, tstring);
01036 mwin->mapheight = height;
01037 mwin->mapwidth = width;
01038
01039 mwin->ctile_topleft.x = 0;
01040 mwin->ctile_topleft.y = 0;
01041 del_bitmap(mwin->bit);
01042 del_bitmap(mwin->lev1);
01043 del_bitmap(mwin->grid);
01044 del_graphics(mwin->mapgraphics);
01045 del_graphics(mwin->lev1graphics);
01046 del_graphics(mwin->gridgraphics);
01047
01048 mwin->bit = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
01049 mwin->mapgraphics = get_bitmap_graphics(mwin->bit);
01050 set_color(mwin->mapgraphics, WHITE);
01051 fill_rect(mwin->mapgraphics, get_bitmap_area(mwin->bit));
01052 mwin->lev1 = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
01053 mwin->lev1graphics = get_bitmap_graphics(mwin->lev1);
01054 set_color(mwin->lev1graphics, CLEAR);
01055 fill_rect(mwin->lev1graphics, get_bitmap_area(mwin->bit));
01056 mwin->grid = new_bitmap(mwin->win, mwin->mapdrawwidth, mwin->mapdrawheight);
01057 mwin->gridgraphics = get_bitmap_graphics(mwin->grid);
01058 set_color(mwin->gridgraphics, CLEAR);
01059 fill_rect(mwin->gridgraphics, get_bitmap_area(mwin->grid));
01060 set_color(mwin->gridgraphics, BLACK);
01061 width = mwin->mapdrawing->area.width;
01062 height = mwin->mapdrawing->area.height;
01063 if(mwin->mapwidth*TILESIZE < mwin->mapdrawing->area.width){ width = mwin->mapwidth * TILESIZE; }
01064 if(mwin->mapheight*TILESIZE < mwin->mapdrawing->area.height){ height = mwin->mapheight * TILESIZE; }
01065 for(x=TILESIZE;x<=width;x+=TILESIZE){
01066 draw_line(mwin->gridgraphics, pt(x,0), pt(x,height));
01067 }
01068 for(y=TILESIZE;y<=height;y+=TILESIZE){
01069 draw_line(mwin->gridgraphics, pt(0,y), pt(width,y));
01070 }
01071
01072 del_control(minimap_win->mmap);
01073 if(mwin->mapwidth > mwin->mapheight){
01074 minimap_win->r.width = 300;
01075 minimap_win->r.height = (300 * mwin->mapheight) / mwin->mapwidth;
01076 }else{
01077 minimap_win->r.height = 300;
01078 minimap_win->r.width = (300 * mwin->mapwidth) / mwin->mapheight;
01079 }
01080 minimap_win->frame.width = (minimap_win->r.width * mwin->mapdrawtwidth) / mwin->mapwidth;
01081 minimap_win->frame.height = (minimap_win->r.height * mwin->mapdrawtheight) / mwin->mapheight;
01082 minimap_win->mmap = new_control(minimap_win->win, rect(25,25,minimap_win->r.width, minimap_win->r.height));
01083 on_control_redraw(minimap_win->mmap, redraw_minimap);
01084 on_control_mouse_move(minimap_win->mmap, minimap_coor);
01085 on_control_mouse_down(minimap_win->mmap, minimap_click);
01086 minimap_win->lev0_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
01087 minimap_win->lev1_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
01088 for (y=0; y < minimap_win->lev0_image->height; y++){
01089 for (x=0; x < minimap_win->lev0_image->width; x++){
01090 minimap_win->lev0_image->data32[y][x] = CLEAR;
01091 minimap_win->lev1_image->data32[y][x] = CLEAR;
01092 }
01093 }
01094 sprintf(s, "Map size: %d x %d", mwin->mapwidth, mwin->mapheight);
01095 set_control_text(minimap_win->size_label, s);
01096 status = 1;
01097 break;
01098 case 1:
01099 sscanf(line, "%d %d", &x, &y);
01100 mwin->char_start_pt.x = x + mwin->ctile_topleft.x;
01101 mwin->char_start_pt.y = y + mwin->ctile_topleft.y;
01102 sprintf(s,"%d", x + mwin->ctile_topleft.x);
01103 set_control_text(mwin->startptxfield, s);
01104 sprintf(s,"%d", y + mwin->ctile_topleft.y);
01105 set_control_text(mwin->startptyfield, s);
01106 status = 2;
01107 break;
01108
01109 case 2:
01110 sscanf(line, "%d %d %d %d %d %d", &x, &y, &index, &wflag, &hitpoints, &damage);
01111 if(tile_array[index].name == NULL){
01112 ask_ok(app, "Missing Tiles", "Missing tiles used in level. Can not use this tilefile with this map file.");
01113 return;
01114 }
01115 map_array->index[x][y][0] = prev_map_array->index[x][y][0] = index;
01116 map_array->walkable[x][y][0] = prev_map_array->walkable[x][y][0] = wflag;
01117 map_array->hitpoints[x][y][0] = prev_map_array->hitpoints[x][y][0] = hitpoints;
01118 map_array->damage[x][y][0] = prev_map_array->damage[x][y][0] = damage;
01119 if(tile_array[index].name != NULL && index != -1 ){
01120 draw_image(mwin->mapgraphics,
01121 rect(x*TILESIZE, y*TILESIZE, TILESIZE, TILESIZE),
01122 tile_array[index].img,
01123 rect(0,0,TILESIZE, TILESIZE));
01124 copy_rect_image(minimap_win->lev0_image,
01125 pt(x*TILESIZE, y*TILESIZE),
01126 tile_array[index].img,
01127 rect(0,0,TILESIZE, TILESIZE));
01128 }
01129
01130 break;
01131 case 3:
01132 sscanf(line, "%d %d %d %d %d %d", &x, &y, &index, &wflag, &hitpoints, &damage);
01133 if(tile_array[index].name == NULL){
01134 ask_ok(app, "Missing Tiles", "Missing tiles used in level. Can not use this tilefile with this map file.");
01135 return;
01136 }
01137 map_array->index[x][y][1] = prev_map_array->index[x][y][1] = index;
01138 which_tile_props(index, &tp);
01139 if(tp.walkable){
01140 map_array->walkable[x][y][1] = prev_map_array->walkable[x][y][1] = wflag;
01141 if(tp.hitpoints){
01142 map_array->hitpoints[x][y][1] = prev_map_array->hitpoints[x][y][1] = hitpoints;
01143 map_array->damage[x][y][1] = prev_map_array->damage[x][y][1] = damage;
01144 }
01145 }else{
01146 map_array->hitpoints[x][y][1] = prev_map_array->hitpoints[x][y][1] = wflag;
01147 map_array->damage[x][y][1] = prev_map_array->damage[x][y][1] = hitpoints;
01148 }
01149 if(tile_array[index].name != NULL && index != -1 ){
01150 draw_image(mwin->lev1graphics,
01151 rect(x*TILESIZE, y*TILESIZE, TILESIZE, TILESIZE),
01152 tile_array[index].img,
01153 rect(0,0,TILESIZE, TILESIZE));
01154 copy_rect_image(minimap_win->lev1_image,
01155 pt(x*TILESIZE, y*TILESIZE),
01156 tile_array[index].img,
01157 rect(0,0,TILESIZE, TILESIZE));
01158 }
01159
01160
01161
01162
01163 break;
01164 }
01165 }
01166 }
01167 }
01168 sprintf(line, "Project Piedmont Level Editor - %s", mwin->filename);
01169 set_window_title(mwin->win, line);
01170 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01171 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
01172 return;
01173 }
01174
01175 void save_mapfile(MenuItem *m){
01176 int x, y, level, index;
01177 char s[200];
01178 char *filename;
01179 tprops tp;
01180 if(mwin->save_flag == 0) return;
01181 for(y=0;y<mwin->mapheight;y++){
01182 for(x=0;x<mwin->mapwidth;x++){
01183 for(level=0;level<1;level++){
01184 if(map_array->index[x][y][level] == -1){
01185 sprintf(s, "Current map is unfinished and has blank spots in level 0.\nContinue with save?");
01186 if(ask_yes_no(app, "Completness check", s) == -1){
01187 return;
01188 }else{
01189 goto continue_save;
01190 }
01191 }
01192 }
01193 }
01194 }
01195 continue_save:
01196 if(mwin->filename != NULL){
01197 filename = ask_file_save(app, "Save As", "Save As:", mwin->filename);
01198
01199 }else{
01200 filename = ask_file_save(app, "Save As", "Save As:", "*.ppm");
01201
01202 }
01203 if(!filename)return;
01204 savemapfile = fopen(filename, "w");
01205
01206
01207 fprintf(savemapfile, "####################################################################\n");
01208 fprintf(savemapfile, "# FORMAT: x y tile_index, walkable_flag hitpoints damage\n");
01209 fprintf(savemapfile, "# WALKABLE_FLAG: 0 = not walkable, 1 = walkable\n");
01210 fprintf(savemapfile, "# HITPOINTS: -1 = indestructible, 0-X = X hitpoints\n");
01211 fprintf(savemapfile, "# DAMAGE: -1 = no damage, 0-X = X damage points\n");
01212 fprintf(savemapfile, "# A value of -1 basically means not applicable\n");
01213 fprintf(savemapfile, "####################################################################\n");
01214 fprintf(savemapfile, "%d %d\t#Map Size\n", mwin->mapwidth, mwin->mapheight);
01215 fprintf(savemapfile, "%d %d\t#Character starting point\n", mwin->char_start_pt.x, mwin->char_start_pt.y);
01216 for(y=0;y<mwin->mapheight;y++){
01217 for(x=0;x<mwin->mapwidth;x++){
01218 index = map_array->index[x][y][0];
01219 which_tile_props(index, &tp);
01220 fprintf(savemapfile, "%3d %3d %3d ", x, y, index);
01221 if(tp.walkable) fprintf(savemapfile, "%5d ", map_array->walkable[x][y][0]);
01222 if(tp.hitpoints) fprintf(savemapfile, "%5d ", map_array->hitpoints[x][y][0]);
01223 if(tp.damage) fprintf(savemapfile, "%5d ", map_array->damage[x][y][0]);
01224 fprintf(savemapfile, "\n");
01225 }
01226 }
01227 fprintf(savemapfile, "L1\n");
01228 for(y=0;y<mwin->mapheight;y++){
01229 for(x=0;x<mwin->mapwidth;x++){
01230 if(map_array->index[x][y][1] != -1){
01231 index = map_array->index[x][y][1];
01232 which_tile_props(index, &tp);
01233 fprintf(savemapfile, "%3d %3d %3d ", x, y, index);
01234 if(tp.walkable) fprintf(savemapfile, "%5d ", map_array->walkable[x][y][1]);
01235 if(tp.hitpoints) fprintf(savemapfile, "%5d ", map_array->hitpoints[x][y][1]);
01236 if(tp.damage) fprintf(savemapfile, "%5d ", map_array->damage[x][y][1]);
01237 fprintf(savemapfile, "\n");
01238 }
01239 }
01240 }
01241 fclose(savemapfile);
01242 mwin->save_flag = 0;
01243 mwin->filename = filename;
01244 return;
01245 }
01246 void exit_prog(MenuItem *m){
01247 exit_mainwin(mwin->win);
01248 }
01249 void exit_mainwin(Window *w){
01250 if(mwin->save_flag){
01251 if(ask_yes_no(app, "Save?", "Last changes to current map not saved. Do you wish to save map?") == 1){
01252 save_mapfile(mwin->save_item);
01253 return;
01254 }
01255 }
01256 del_all_windows(app);
01257 exit(0);
01258 }
01259 void show_tilewin(MenuItem *m){
01260 if(menu_item_is_checked(m) == 0){
01261 check_menu_item(m);
01262 show_window(tile_win->win);
01263 return;
01264 }
01265 uncheck_menu_item(m);
01266 hide_window(tile_win->win);
01267 return;
01268 }
01269
01270 void show_helpwin(MenuItem *m){
01271 show_window(help_win->win);
01272 }
01273
01274
01282 void load_tiles(MenuItem *m){
01283 static char tilename[40];
01284 char line[80];
01285 char *s;
01286 int i, x, y, index, wflag, hitpoints, damage;
01287 tprops tp;
01288 if(menu_item_is_checked(mwin->tilewin_item) == 0){
01289 show_window(tile_win->win);
01290 check_menu_item(mwin->tilewin_item);
01291 }
01292
01293 char * filename = "tilefile";
01294 for(i=0; i<256; i++){
01295 tile_array[i].img = new_image(32, 32, 32);
01296 tile_array[i].name = NULL;
01297 }
01298 tilefile = open_file(filename, "r");
01299 printf("%s\n", filename);
01300 while ( fgets(line, 80, tilefile) != NULL ){
01301 if(line[0] != '#' && line[0] != ' ' && line[0] != '\n'){
01302 sscanf(line, "%d %s %d %d %d", &index, tilename, &wflag, &hitpoints, &damage);
01303
01304 s = tilename;
01305 i=0;
01306 while((tilenames[index][i] = *s) != '\0') {i++;s++;}
01307 s -= i;
01308
01309 tile_array[index].name = tilenames[index];
01310 which_tile_props(index, &tp);
01311 if(tp.walkable){
01312 tile_array[index].walkable = wflag;
01313 if(tp.hitpoints){
01314 tile_array[index].hitpoints = hitpoints;
01315 tile_array[index].damage = damage;
01316 }
01317 }else{
01318 tile_array[index].hitpoints = wflag;
01319 tile_array[index].damage = hitpoints;
01320 }
01321 }
01322 }
01323 for(i=0; i<256; i++){
01324 if(tile_array[i].name != NULL){
01325
01326 Image *img;
01327 img = read_image(tile_array[i].name, 8);
01328 if(i >=177 || !strcmp(tile_array[i].name, "tiles/TEMP.gif") ){
01329 img->cmap[0].alpha = 255;
01330 }
01331 tile_array[i].img = image_convert_8_to_32(img);
01332 del_image(img);
01333
01334 if(tile_array[i].img == NULL)tile_array[i].name = NULL;
01335 if(tile_array[i].img != NULL){
01336 if((tile_array[i].img->width != TILESIZE) | (tile_array[i].img->height != TILESIZE)){
01337 tile_array[i].img = scale_image(tile_array[i].img,
01338 rect(0,0,TILESIZE, TILESIZE),
01339 rect(0,0,tile_array[i].img->width,tile_array[i].img->height));
01340
01341 }
01342 tile_array[i].bit = image_to_bitmap(tile_win->win, tile_array[i].img);
01343 if(i<64){
01344 set_control_background(tile_win->tile_btn[i], WHITE);
01345 set_control_image(tile_win->tile_btn[i], tile_array[i].img);
01346 enable(tile_win->tile_btn[i]);
01347 set_control_value(tile_win->tile_btn[i], i);
01348 show_control(tile_win->tile_btn[i]);
01349 draw_control(tile_win->tile_btn[i]);
01350 }
01351 }
01352 }else{
01353 if(i<64){
01354 set_control_background(tile_win->tile_btn[i], WHITE);
01355 set_control_image(tile_win->tile_btn[i], NULL);
01356 disable(tile_win->tile_btn[i]);
01357 }
01358 }
01359 }
01360 highlight(tile_win->first_btn);
01361 enable(tile_win->first_btn);
01362 enable(tile_win->second_btn);
01363 enable(tile_win->third_btn);
01364 enable(tile_win->fourth_btn);
01365 }
01366
01367
01371 void which_tile_props(int index, tprops* t){
01372 t->walkable = t->hitpoints = t->damage = 0;
01373 if(index >= BACKGROUND_BEGIN && index <= BACKGROUND_END){
01374 t->walkable = 1; t->hitpoints = 1; t->damage = 0;
01375 return;
01376 }
01377 if(index >= ENEMY_BEGIN && index <= ENEMY_END){
01378 t->walkable = 1; t->hitpoints = 1; t->damage = 1;
01379 return;
01380 }
01381 if(index >= KEY_BEGIN && index <= KEY_END){
01382 t->walkable = 0; t->hitpoints = 0; t->damage = 0;
01383 return;
01384 }
01385 if(index >= TELEPORTER_BEGIN && index <= TELEPORTER_END){
01386 t->walkable = 0; t->hitpoints = 1; t->damage = 1;
01387 return;
01388 }
01389 if(index >= EXIT_BEGIN && index <= EXIT_END){
01390 t->walkable = 0; t->hitpoints = 1; t->damage = 0;
01391 return;
01392 }
01393 if(index >= SCROLL_BEGIN && index <= SCROLL_END){
01394 t->walkable = 0; t->hitpoints = 0; t->damage = 0;
01395 return;
01396 }
01397 if(index >= DOOR_BEGIN && index <= DOOR_END){
01398 t->walkable = 1; t->hitpoints = 0; t->damage = 0;
01399 return;
01400 }
01401 if(index >= POWERUP_BEGIN && index <= POWERUP_END){
01402 t->walkable = 0; t->hitpoints = 1; t->damage = 0;
01403 return;
01404 }
01405 if(index >= GOLD_BEGIN && index <= GOLD_END){
01406 t->walkable = 0; t->hitpoints = 1; t->damage = 0;
01407 return;
01408 }
01409 if(index >= GENERATOR_BEGIN && index <= GENERATOR_END){
01410 t->walkable = 0; t->hitpoints = 1; t->damage = 1;
01411 return;
01412 }
01413 if(index >= TRAPS_BEGIN && index <= TRAPS_END){
01414 t->walkable = 0; t->hitpoints = 1; t->damage = 0;
01415 return;
01416 }
01417 if(index >= EMPTY_BEGIN && index <= EMPTY_END){
01418 t->walkable = 0; t->hitpoints = 0; t->damage = 0;
01419 return;
01420 }
01421 }
01422
01423
01426 void show_grid(MenuItem *m){
01427 if(menu_item_is_checked(m)){
01428 uncheck_menu_item(m);
01429 }else{
01430 check_menu_item(m);
01431 }
01432 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01433 return;
01434 }
01435
01436
01443 void timer_callback(Timer *t){
01444 if(clicktime){
01445 del_timer(clicktime);
01446 }
01447 mwin->double_click_flag = 0;
01448 return;
01449 }
01450
01451
01460 void view_tiles(Control *c){
01461 int i, start, t;
01462 char s[3];
01463 start = (int) get_control_value(c);
01464 unhighlight(tile_win->first_btn);
01465 unhighlight(tile_win->second_btn);
01466 unhighlight(tile_win->third_btn);
01467 unhighlight(tile_win->fourth_btn);
01468 switch(start){
01469 case 0: highlight(tile_win->first_btn); tile_win->offset = 0; break;
01470 case 64: highlight(tile_win->second_btn); tile_win->offset = 64; break;
01471 case 128: highlight(tile_win->third_btn); tile_win->offset = 128; break;
01472 case 192: highlight(tile_win->fourth_btn); tile_win->offset = 192;
01473 }
01474 t = start;
01475 for(i=0;i<tile_win->tile_rows;i++){
01476 sprintf(s, "%d", t);
01477 t+= tile_win->tile_columns;
01478 set_control_text(tile_win->tile_label[i], s);
01479 }
01480 for(i=start;i<start+64;i++){
01481 disable(tile_win->tile_btn[i%64]);
01482 set_control_image(tile_win->tile_btn[i%64], NULL);
01483 if(tile_array[i].name != NULL){
01484 set_control_image(tile_win->tile_btn[i%64], tile_array[i].img);
01485 enable(tile_win->tile_btn[i%64]);
01486 set_control_value(tile_win->tile_btn[i%64], (i%64)+start);
01487 }
01488 }
01489 }
01490
01491
01492
01493
01494
01495
01496
01497
01498 void choose_tile(Control *c){
01499 int index;
01500 char s[18];
01501 index = (int) get_control_value(c);
01502 if(index < 177){choose_map_level(mwin->showlev0btn);}
01503 if(index > 176){choose_map_level(mwin->showlev1btn);}
01504 mwin->ctile.img = tile_array[index].img;
01505
01506
01507
01508 mwin->ctile.bit = image_to_bitmap(mwin->win, mwin->ctile.img);
01509 mwin->ctile.name = tile_array[index].name;
01510 mwin->ctile.index = index;
01511 set_control_image(mwin->currentimgpic, tile_array[index].img);
01512 set_control_text(mwin->lcurrentimg, tile_array[index].name);
01513 sprintf(s, "%d", index);
01514 set_control_text(mwin->lcurrentimgindex, s);
01515 set_currentimg_props(index);
01516 set_control_background(mwin->currentimgpic, WHITE);
01517
01518
01519
01520
01521 show_control(mwin->lcurrentimgindex);
01522 return;
01523 }
01524
01525
01526
01527
01528
01529
01530
01531
01532 void set_currentimg_props(int index){
01533 tprops tp;
01534 char s[18];
01535 which_tile_props(index, &tp);
01536 if(tp.walkable){
01537 mwin->ctile.walkable = tile_array[index].walkable;
01538 if(tp.hitpoints){
01539 mwin->ctile.hitpoints = tile_array[index].hitpoints;
01540 if(tp.damage){
01541 mwin->ctile.damage = tile_array[index].damage;
01542 sprintf(s, "W(1) H(%d) D(%d)", tile_array[index].hitpoints,
01543 tile_array[index].damage);
01544 }else{
01545 sprintf(s, "W(1) H(%d) D()", tile_array[index].hitpoints);
01546 }
01547 }else{
01548 sprintf(s, "W(1) H( ) D( )");
01549 }
01550 }else{
01551 if(tp.hitpoints){
01552 mwin->ctile.hitpoints = tile_array[index].hitpoints;
01553 if(tp.damage){
01554 mwin->ctile.damage = tile_array[index].damage;
01555 sprintf(s, "W( ) H(%d) D(%d)", tile_array[index].hitpoints,
01556 tile_array[index].damage);
01557 }else{
01558 sprintf(s, "W( ) H(%d) D( )", tile_array[index].hitpoints);
01559 }
01560 }else{
01561 sprintf(s, "W( ) H( ) D( )");
01562 }
01563 }
01564 set_control_text(mwin->lcurrentprop, s);
01565 redraw_control(mwin->lcurrentprop);
01566 return;
01567 }
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577 void get_prop_strings(int index, int win, prop_strings *s){
01578 tprops t;
01579 if(index < 177){
01580 sprintf(s->first, "Walkable");
01581 sprintf(s->second, "damage");
01582 sprintf(s->third, " ");
01583 }else if(index < 193){
01584 sprintf(s->first, "ranged");
01585 sprintf(s->second, "hitpoints");
01586 sprintf(s->third, "damage");
01587 }else if(index < 194){
01588 sprintf(s->first, " ");
01589 sprintf(s->second, " ");
01590 sprintf(s->third, " ");
01591 }else if(index < 195){
01592 sprintf(s->first, " ");
01593 sprintf(s->second, "x coor");
01594 sprintf(s->third, "y coor");
01595 }else if(index < 196){
01596 sprintf(s->first, " ");
01597 sprintf(s->second, "Next Level");
01598 sprintf(s->third, " ");
01599 }else if(index < 197){
01600 sprintf(s->first, " ");
01601 sprintf(s->second, " ");
01602 sprintf(s->third, " ");
01603 }else if(index < 201){
01604 sprintf(s->first, "Need key");
01605 sprintf(s->second, " ");
01606 sprintf(s->third, " ");
01607 }else if(index < 208){
01608 sprintf(s->first, " ");
01609 sprintf(s->second, "Point Change");
01610 sprintf(s->third, " ");
01611 }else if(index < 216){
01612 sprintf(s->first, " ");
01613 sprintf(s->second, "Value");
01614 sprintf(s->third, " ");
01615 }else if(index < 217){
01616 sprintf(s->first, " ");
01617 sprintf(s->second, "Mnstr Index");
01618 sprintf(s->third, "Hitpoints");
01619 }else if(index < 221){
01620 sprintf(s->first, " ");
01621 sprintf(s->second, "Damage");
01622 sprintf(s->third, " ");
01623 }else if(index > 220){
01624 sprintf(s->first, " ");
01625 sprintf(s->second, " ");
01626 sprintf(s->third, " ");
01627 }
01628 which_tile_props(index, &t);
01629 if(win == 1){
01630 if(t.walkable){ show_control(mwin->walkablebox); }else{ hide_control(mwin->walkablebox); }
01631 if(t.hitpoints){ show_control(mwin->hitpointsfield); }else{ hide_control(mwin->hitpointsfield); }
01632 if(t.damage){ show_control(mwin->damagefield); }else{ hide_control(mwin->damagefield); }
01633 }else{
01634 if(t.walkable){ show_control(prop_win->walkablebox); }else{ hide_control(prop_win->walkablebox); }
01635 if(t.hitpoints){ show_control(prop_win->hitpointsfield); }else{ hide_control(prop_win->hitpointsfield); }
01636 if(t.damage){ show_control(prop_win->damagefield); }else{ hide_control(prop_win->damagefield); }
01637 }
01638 return;
01639 }
01640
01641
01642
01643
01644
01645
01646
01647 void ok_sizewin(Control *c){
01648 int x,y,level, width, height;
01649 char tstring[50];
01650 char s[20];
01651 newmap_win->iheight = atoi(get_control_text(newmap_win->heightfield));
01652 newmap_win->iwidth = atoi(get_control_text(newmap_win->widthfield));
01653 if(newmap_win->iheight > MAXMAPHEIGHT){
01654 sprintf(tstring, "Map height must be <= %d", MAXMAPHEIGHT);
01655 ask_ok(app, "", tstring);
01656 return;
01657 }
01658 if(newmap_win->iwidth > MAXMAPWIDTH){
01659 sprintf(tstring, "Map width must be <= %d", MAXMAPWIDTH);
01660 ask_ok(app, "", tstring);
01661 return;
01662 }
01663 for(y=0;y<MAXMAPHEIGHT;y++){
01664 for(x=0;x<MAXMAPWIDTH;x++){
01665 for(level=0;level<2;level++){
01666 map_array->index[x][y][level] = prev_map_array->index[x][y][level] = -1;
01667 map_array->walkable[x][y][level] = prev_map_array->walkable[x][y][level] = -1;
01668 map_array->hitpoints[x][y][level] = prev_map_array->hitpoints[x][y][level] = -1;
01669 map_array->damage[x][y][level] = prev_map_array->damage[x][y][level] = -1;
01670 }
01671 }
01672 }
01673 sprintf(tstring, "Map Size: %dx%d", newmap_win->iwidth, newmap_win->iheight);
01674 set_control_text(mwin->lmapsize, tstring);
01675 mwin->mapheight = newmap_win->iheight;
01676 mwin->mapwidth = newmap_win->iwidth;
01677 mwin->ctile_topleft.x = 0;
01678 mwin->ctile_topleft.y = 0;
01679 del_bitmap(mwin->bit);
01680 del_bitmap(mwin->lev1);
01681 del_bitmap(mwin->grid);
01682 del_graphics(mwin->mapgraphics);
01683 del_graphics(mwin->lev1graphics);
01684 del_graphics(mwin->gridgraphics);
01685 mwin->bit = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
01686 mwin->mapgraphics = get_bitmap_graphics(mwin->bit);
01687 set_color(mwin->mapgraphics, WHITE);
01688 fill_rect(mwin->mapgraphics, get_bitmap_area(mwin->bit));
01689 mwin->lev1 = new_bitmap(mwin->win, mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE);
01690 mwin->lev1graphics = get_bitmap_graphics(mwin->lev1);
01691 set_color(mwin->lev1graphics, CLEAR);
01692 fill_rect(mwin->lev1graphics, get_bitmap_area(mwin->bit));
01693 mwin->grid = new_bitmap(mwin->win, mwin->mapdrawwidth, mwin->mapdrawheight);
01694 mwin->gridgraphics = get_bitmap_graphics(mwin->grid);
01695 set_color(mwin->gridgraphics, CLEAR);
01696 fill_rect(mwin->gridgraphics, get_bitmap_area(mwin->grid));
01697 set_color(mwin->gridgraphics, BLACK);
01698 width = mwin->mapdrawing->area.width;
01699 height = mwin->mapdrawing->area.height;
01700 if(mwin->mapwidth*TILESIZE < mwin->mapdrawing->area.width){ width = mwin->mapwidth * TILESIZE; }
01701 if(mwin->mapheight*TILESIZE < mwin->mapdrawing->area.height){ height = mwin->mapheight * TILESIZE; }
01702 for(x=TILESIZE;x<=width;x+=TILESIZE){
01703 draw_line(mwin->gridgraphics, pt(x,0), pt(x,height));
01704 }
01705 for(y=TILESIZE;y<=height;y+=TILESIZE){
01706 draw_line(mwin->gridgraphics, pt(0,y), pt(width,y));
01707 }
01708 hide_window(newmap_win->win);
01709
01710 del_control(minimap_win->mmap);
01711 if(mwin->mapwidth > mwin->mapheight){
01712 minimap_win->r.width = 300;
01713 minimap_win->r.height = (300 * mwin->mapheight) / mwin->mapwidth;
01714 }else{
01715 minimap_win->r.height = 300;
01716 minimap_win->r.width = (300 * mwin->mapwidth) / mwin->mapheight;
01717 }
01718 minimap_win->frame.width = (minimap_win->r.width * mwin->mapdrawtwidth) / mwin->mapwidth;
01719 minimap_win->frame.height = (minimap_win->r.height * mwin->mapdrawtheight) / mwin->mapheight;
01720 minimap_win->mmap = new_control(minimap_win->win, rect(25,25,minimap_win->r.width, minimap_win->r.height));
01721 on_control_redraw(minimap_win->mmap, redraw_minimap);
01722 on_control_mouse_move(minimap_win->mmap, minimap_coor);
01723 on_control_mouse_down(minimap_win->mmap, minimap_click);
01724 minimap_win->lev0_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
01725 minimap_win->lev1_image = new_image(mwin->mapwidth*TILESIZE, mwin->mapheight*TILESIZE, 32);
01726 for (y=0; y < minimap_win->lev0_image->height; y++){
01727 for (x=0; x < minimap_win->lev0_image->width; x++){
01728 minimap_win->lev0_image->data32[y][x] = CLEAR;
01729 minimap_win->lev1_image->data32[y][x] = CLEAR;
01730 }
01731 }
01732 sprintf(s, "Map size: %d x %d", mwin->mapwidth, mwin->mapheight);
01733 set_control_text(minimap_win->size_label, s);
01734 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01735 if(menu_item_is_checked(mwin->mmap_item)) redraw_minimap(minimap_win->mmap, get_control_graphics(minimap_win->mmap));
01736 return;
01737 }
01738
01739 void ok_propwin(Control *c){
01740 int walkable, hitpoints, damage, x, y, level;
01741 char s[5] = " 0";
01742 char t[5] = " 0";
01743 char str[200];
01744 prop_strings pstring;
01745 minmax pminmax;
01746 tprops tp;
01747 get_tile_prop_minmax(prop_win->index, &pminmax);
01748 get_prop_strings(prop_win->index, 0, &pstring);
01749 which_tile_props(prop_win->index, &tp);
01750 walkable = 0;
01751 if(tp.walkable){ if(is_checked(prop_win->walkablebox)) walkable = 1; }
01752 if(tp.hitpoints) sprintf(s, "%s", get_control_text(prop_win->hitpointsfield));
01753 if(tp.damage) sprintf(t, "%s", get_control_text(prop_win->damagefield));
01754 hitpoints = atoi(s);
01755 damage = atoi(t);
01756 if(tp.hitpoints){
01757 if((pminmax.second.x == 0) && (pminmax.second.y == 0)){
01758 if(hitpoints < pminmax.first.x || hitpoints > pminmax.first.y){
01759 sprintf(str, "%s must be between %d and %d.",
01760 pstring.second, pminmax.first.x, pminmax.first.y);
01761 ask_ok(app, " ", str);
01762 return;
01763 }
01764 }else{
01765 if(hitpoints < pminmax.first.x || hitpoints > pminmax.first.y ||
01766 damage < pminmax.second.x || damage > pminmax.second.y){
01767 sprintf(str, "%s must be between %d and %d.", pstring.second, pminmax.first.x, pminmax.first.y);
01768 sprintf(str, "%s\n%s must be between %d and %d.", str, pstring.third, pminmax.second.x, pminmax.second.y);
01769 ask_ok(app, " ", str);
01770 return;
01771 }
01772 }
01773 }
01774 x = mwin->ctile_edit.x + mwin->ctile_topleft.x;
01775 y = mwin->ctile_edit.y + mwin->ctile_topleft.y;
01776 level = mwin->currentmaplevel;
01777 if(level == 2) level = 0;
01778 map_array->walkable[x][y][level] = walkable;
01779 map_array->hitpoints[x][y][level] = hitpoints;
01780 map_array->damage[x][y][level] = damage;
01781 hide_window(prop_win->win);
01782 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01783 }
01784
01785 void get_tile_prop_minmax(int index, minmax *mm){
01786 mm->first.x = 0;
01787 mm->first.y = 0;
01788 mm->second.x = 0;
01789 mm->second.y = 0;
01790 if(index < 177){
01791 mm->first.x = BG_MIN_DAMAGE;
01792 mm->first.y = BG_MAX_DAMAGE;
01793 }else if(index < 193){
01794 mm->first.x = ENMY_MIN_HTPTS;
01795 mm->first.y = ENMY_MAX_HTPTS;
01796 mm->second.x = ENMY_MIN_DAMAGE;
01797 mm->second.y = ENMY_MAX_DAMAGE;
01798 }else if(index < 194){
01799 mm->first.x = mm->first.y = mm->second.x = mm->second.y = 0;
01800 }else if(index < 195){
01801 mm->first.x = 0;
01802 mm->first.y = mwin->mapwidth;
01803 mm->second.x = 0;
01804 mm->second.y = mwin->mapheight;
01805 }else if(index < 196){
01806 mm->first.x = 0;
01807 mm->first.y = EXIT_MAX;
01808 }else if(index < 197){
01809 mm->first.x = mm->first.y = mm->second.x = mm->second.y = 0;
01810 }else if(index < 201){
01811 mm->first.x = mm->first.y = mm->second.x = mm->second.y = 0;
01812 }else if(index < 208){
01813 mm->first.x = POWERUP_MIN;
01814 mm->first.y = POWERUP_MAX;
01815 }else if(index < 216){
01816 mm->first.x = GOLD_MIN;
01817 mm->first.y = GOLD_MAX;
01818 }else if(index < 217){
01819 mm->first.x = GEN_MIDX_MIN;
01820 mm->first.y = GEN_MIDX_MAX;
01821 mm->second.x = GEN_MIN_HTPTS;
01822 mm->second.y = GEN_MAX_HTPTS;
01823 }else if(index < 221){
01824 mm->first.x = TRAP_MIN_DAMAGE;
01825 mm->first.y = TRAP_MAX_DAMAGE;
01826 }else if(index > 220){
01827 }
01828 return;
01829 }
01830
01831 void cancel_sizewin(Control *c){
01832 exit_sizewin(newmap_win->win);
01833 }
01834 void cancel_propwin(Control *c){
01835 exit_propwin(prop_win->win);
01836 }
01837 void cancel_helpwin(Control *c){
01838 exit_helpwin(help_win->win);
01839 }
01840
01841 void exit_mmapwin(Window *w){
01842 uncheck_menu_item(mwin->mmap_item);
01843 hide_window(minimap_win->win);
01844 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01845 return;
01846 }
01847
01848 void exit_tilewin(Window *w){
01849 uncheck_menu_item(mwin->tilewin_item);
01850 hide_window(tile_win->win);
01851 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01852 redraw_window(mwin->win);
01853 return;
01854 }
01855
01856 void exit_sizewin(Window *w){
01857 set_control_text(newmap_win->heightfield, "20");
01858 set_control_text(newmap_win->widthfield, "20");
01859 hide_window(newmap_win->win);
01860 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01861 return;
01862 }
01863
01864 void exit_propwin(Window *w){
01865 hide_window(prop_win->win);
01866 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01867 return;
01868 }
01869
01870 void exit_helpwin(Window *w){
01871 hide_window(help_win->win);
01872 redraw_map(mwin->mapdrawing, get_control_graphics(mwin->mapdrawing));
01873 return;
01874 }
01875
01876
01877 int app_main(int argc, char *argv[]){
01878 int retval;
01879
01880 ofile = fopen("dmfout.txt", "w");
01881
01882
01883 app = new_app(argc, argv);
01884 if ((app == NULL) || (app->gui_available == 0))
01885 error(app, "Couldn't initialise the graphics library.");
01886
01887 map_array = (map *) malloc(sizeof(map));
01888 prev_map_array = (map *) malloc(sizeof(map));
01889
01890
01891 mwin = NULL;
01892 mwin = (MainWin *) malloc(sizeof(MainWin));
01893 if (!mwin){ printf("ERROR: Could not allocate MainWin memory!\n"); return(1); }
01894 retval = init_main_window(mwin);
01895
01896 tile_win = NULL;
01897 tile_win = (TileWin *) malloc(sizeof(TileWin));
01898 if (!tile_win){ printf("ERROR: Could not allocate TileWin memory!\n"); return(1); }
01899 retval = init_tile_window();
01900
01901 newmap_win = NULL;
01902 newmap_win = (NewMapWin *) malloc(sizeof(NewMapWin));
01903 if (!newmap_win){ printf("ERROR: Could not allocate NewMapWin memory!\n"); return(1); }
01904 retval = init_size_window();
01905
01906 prop_win = NULL;
01907 prop_win = (PropWin *) malloc(sizeof(PropWin));
01908 if (!prop_win){ printf("ERROR: Could not allocate PropWin memory!\n"); return(1); }
01909 retval = init_prop_window();
01910
01911 help_win = NULL;
01912 help_win = (HelpWin *) malloc(sizeof(HelpWin));
01913 if (!help_win){ printf("ERROR: Could not allocate HelpWin memory!\n"); return(1); }
01914 retval = init_help_window();
01915
01916 minimap_win = NULL;
01917 minimap_win = (MMapWin *) malloc(sizeof(MMapWin));
01918 if (!minimap_win){ printf("ERROR: Could not allocate MMapWin memory!\n"); return(1); }
01919 retval = init_minimap_window();
01920
01921 tile_array = (tile *) malloc(256 * sizeof(tile));
01922
01923 show_window(mwin->win);
01924
01925
01926 main_loop(app);
01927 del_app(app);
01928 free(tile_array);
01929 fclose(ofile);
01930 return 0;
01931
01932
01933 }
01934
01935
01936
01937 void copy_rect_image(Image *dest, Point dp, Image *src, Rect sr)
01938 {
01939 int x, y;
01940
01941
01942 if (dest->depth == 8) {
01943 for (y=0; y < sr.height; y++) {
01944 for (x=0; x < sr.width; x++) {
01945 dest->data8[y+dp.y][x+dp.x] = src->data8[y+sr.y][x+sr.x];
01946 }
01947 }
01948
01949 if (src->cmap_size > 0){
01950 app_set_image_cmap(dest, src->cmap_size, src->cmap);
01951 }
01952 }
01953 else if (dest->depth == 32) {
01954 for (y=0; y < sr.height; y++) {
01955 for (x=0; x < sr.width; x++) {
01956 dest->data32[y+dp.y][x+dp.x] = src->data32[y+sr.y][x+sr.x];
01957 }
01958 }
01959 }
01960 }