X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Feditor.c;h=88b7d7dcd7b746b474c2204ef6569920a7c6b6bf;hp=6ec17e91ef08e8cfd5ebbc684f8c601686cf8b1c;hb=65e73b3607d8d4aef09abaf1f44d090197953f21;hpb=59c2e609872b70cb4c458004cd9e2fe22c86a54b diff --git a/src/editor.c b/src/editor.c index 6ec17e91..88b7d7dc 100644 --- a/src/editor.c +++ b/src/editor.c @@ -17,12 +17,138 @@ #include "misc.h" #include "buttons.h" #include "files.h" +#include "game.h" + +/* positions in the level editor */ +#define ED_WIN_MB_LEFT_XPOS 7 +#define ED_WIN_MB_LEFT_YPOS 6 +#define ED_WIN_LEVELNR_XPOS 77 +#define ED_WIN_LEVELNR_YPOS 7 +#define ED_WIN_MB_MIDDLE_XPOS 7 +#define ED_WIN_MB_MIDDLE_YPOS 258 +#define ED_WIN_MB_RIGHT_XPOS 77 +#define ED_WIN_MB_RIGHT_YPOS 258 + +/* other constants for the editor */ +#define ED_SCROLL_NO 0 +#define ED_SCROLL_LEFT 1 +#define ED_SCROLL_RIGHT 2 +#define ED_SCROLL_UP 4 +#define ED_SCROLL_DOWN 8 + +/* screens in the level editor */ +#define ED_MODE_DRAWING 0 +#define ED_MODE_INFO 1 +#define ED_MODE_PROPERTIES 2 + +/* how many steps can be cancelled */ +#define NUM_UNDO_STEPS (10 + 1) + +/* values for random placement */ +#define RANDOM_USE_PERCENTAGE 0 +#define RANDOM_USE_NUM_OBJECTS 1 + +/* values for the control window */ +#define ED_CTRL_BUTTONS_GFX_YPOS 236 +#define ED_CTRL1_BUTTONS_HORIZ 4 +#define ED_CTRL1_BUTTONS_VERT 4 +#define ED_CTRL1_BUTTON_XSIZE 22 +#define ED_CTRL1_BUTTON_YSIZE 22 +#define ED_CTRL1_BUTTONS_XPOS 6 +#define ED_CTRL1_BUTTONS_YPOS 6 +#define ED_CTRL2_BUTTONS_HORIZ 3 +#define ED_CTRL2_BUTTONS_VERT 2 +#define ED_CTRL2_BUTTON_XSIZE 30 +#define ED_CTRL2_BUTTON_YSIZE 20 +#define ED_CTRL2_BUTTONS_XPOS 5 +#define ED_CTRL2_BUTTONS_YPOS 100 +#define ED_NUM_CTRL1_BUTTONS (ED_CTRL1_BUTTONS_HORIZ * ED_CTRL1_BUTTONS_VERT) +#define ED_NUM_CTRL2_BUTTONS (ED_CTRL2_BUTTONS_HORIZ * ED_CTRL2_BUTTONS_VERT) +#define ED_NUM_CTRL_BUTTONS (ED_NUM_CTRL1_BUTTONS + ED_NUM_CTRL2_BUTTONS) + +/* values for other gadgets */ +#define ED_SCORE_XPOS TILEX +#define ED_SCORE_YPOS (7 * TILEY) +#define ED_COUNT_VALUE_XOFFSET 5 +#define ED_COUNT_VALUE_YOFFSET 3 + +/* control button identifiers */ +#define ED_CTRL_ID_SINGLE_ITEMS 0 +#define ED_CTRL_ID_CONNECTED_ITEMS 1 +#define ED_CTRL_ID_LINE 2 +#define ED_CTRL_ID_TEXT 3 +#define ED_CTRL_ID_RECTANGLE 4 +#define ED_CTRL_ID_FILLED_BOX 5 +#define ED_CTRL_ID_WRAP_UP 6 +#define ED_CTRL_ID_PROPERTIES 7 +#define ED_CTRL_ID_FLOOD_FILL 8 +#define ED_CTRL_ID_WRAP_LEFT 9 +#define ED_CTRL_ID_WRAP_RIGHT 11 +#define ED_CTRL_ID_RANDOM_PLACEMENT 12 +#define ED_CTRL_ID_BRUSH 13 +#define ED_CTRL_ID_WRAP_DOWN 14 +#define ED_CTRL_ID_UNDO 16 +#define ED_CTRL_ID_INFO 17 +#define ED_CTRL_ID_SAVE 18 +#define ED_CTRL_ID_CLEAR 19 +#define ED_CTRL_ID_TEST 20 +#define ED_CTRL_ID_EXIT 21 + +/* counter button identifiers */ +#define ED_CTRL_ID_SCORE_DOWN 22 +#define ED_CTRL_ID_SCORE_UP 23 + +/* drawing area identifiers */ +#define ED_CTRL_ID_DRAWING_LEVEL 24 + +#define ED_NUM_GADGETS 25 + +/* values for counter gadgets */ +#define ED_COUNTER_SCORE 0 + +#define ED_NUM_COUNTERS 1 + +static struct +{ + int x, y; + int gadget_id; +} counter_info[ED_NUM_COUNTERS] = +{ + { ED_SCORE_XPOS, ED_SCORE_YPOS, ED_CTRL_ID_SCORE_DOWN } +}; + +/* forward declaration for internal use */ +static void DrawDrawingWindow(); +static void DrawPropertiesWindow(int); +static void CopyLevelToUndoBuffer(); +static void HandleDrawingAreas(struct GadgetInfo *); +static void HandleCounterButtons(struct GadgetInfo *); +static void HandleControlButtons(struct GadgetInfo *); + +static struct GadgetInfo *level_editor_gadget[ED_NUM_GADGETS]; +static boolean level_editor_gadgets_created = FALSE; + +static int drawing_function = ED_CTRL_ID_SINGLE_ITEMS; + +static short OrigBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY]; +static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY]; +static int undo_buffer_position = 0; +static int undo_buffer_steps = 0; + +static int random_placement_percentage = 10; +static int random_placement_num_objects = 10; +#if 0 +static int random_placement_method = RANDOM_USE_PERCENTAGE; +#else +static int random_placement_method = RANDOM_USE_NUM_OBJECTS; +#endif -#define CHOICE_DELAY_VALUE 100 +/* pointer to score value */ +static int *gadget_score_value; static int level_xpos,level_ypos; -static BOOL edit_mode; -static BOOL name_typing; +static int edit_mode; +static boolean name_typing; static int new_element1 = EL_MAUERWERK; static int new_element2 = EL_LEERRAUM; static int new_element3 = EL_ERDREICH; @@ -323,17 +449,277 @@ int editor_element[] = }; int elements_in_list = sizeof(editor_element)/sizeof(int); +static void ScrollMiniLevel(int from_x, int from_y, int scroll) +{ + int x,y; + int dx = (scroll==ED_SCROLL_LEFT ? -1 : scroll==ED_SCROLL_RIGHT ? 1 : 0); + int dy = (scroll==ED_SCROLL_UP ? -1 : scroll==ED_SCROLL_DOWN ? 1 : 0); + + XCopyArea(display,drawto,drawto,gc, + SX+MINI_TILEX*(dx==-1),SY+MINI_TILEY*(dy==-1), + SXSIZE-MINI_TILEX*ABS(dx),SYSIZE-MINI_TILEY*ABS(dy), + SX+MINI_TILEX*(dx==+1),SY+MINI_TILEY*(dy==+1)); + if (dx) + { + x = (dx==1 ? 0 : 2*SCR_FIELDX-1); + for(y=0;y<2*SCR_FIELDY;y++) + DrawMiniElementOrWall(x,y,from_x,from_y); + } + else if (dy) + { + y = (dy==1 ? 0 : 2*SCR_FIELDY-1); + for(x=0;x<2*SCR_FIELDX;x++) + DrawMiniElementOrWall(x,y,from_x,from_y); + } + + redraw_mask |= REDRAW_FIELD; + BackToFront(); +} + +void InitLevelEditorGadgets() +{ + int i; + + for (i=0; ievent.type; + + printf("HandleControlButtons: (%d,%d) (%d,%d) [%d] ", + gi->x, gi->y, + gi->event.x, gi->event.y, gi->event.button); + + if (event_type == GD_EVENT_PRESSED) + printf("GD_EVENT_PRESSED\n"); + else if (event_type == GD_EVENT_RELEASED) + printf("GD_EVENT_RELEASED\n"); + else if (event_type == GD_EVENT_MOVING) + printf("GD_EVENT_MOVING\n"); + else + printf("?\n"); +} + +#endif + + + +static void CreateCounterButtons(int counter_id) +{ + int i; + + for (i=0; i<2; i++) + { + Pixmap gd_pixmap = pix[PIX_DOOR]; + struct GadgetInfo *gi; + int gd_xoffset; + int gd_x1, gd_x2, gd_y; + int id = counter_info[counter_id].gadget_id + i; + unsigned long event_mask; + + event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED; + + gd_xoffset = (i == 0 ? ED_BUTTON_MINUS_XPOS : ED_BUTTON_PLUS_XPOS); + gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset; + gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset; + gd_y = DOOR_GFX_PAGEY1 + ED_BUTTON_COUNT_YPOS; + + gi = CreateGadget(GDI_CUSTOM_ID, id, + GDI_X, SX + counter_info[counter_id].x + gd_xoffset, + GDI_Y, SY + counter_info[counter_id].y, + GDI_WIDTH, ED_BUTTON_COUNT_XSIZE, + GDI_HEIGHT, ED_BUTTON_COUNT_YSIZE, + GDI_TYPE, GD_TYPE_NORMAL_BUTTON, + GDI_STATE, GD_BUTTON_UNPRESSED, + GDI_DESIGN_UNPRESSED, gd_pixmap, gd_x1, gd_y, + GDI_DESIGN_PRESSED, gd_pixmap, gd_x2, gd_y, + GDI_EVENT_MASK, event_mask, + GDI_CALLBACK, HandleCounterButtons, + GDI_END); + + if (gi == NULL) + Error(ERR_EXIT, "cannot create gadget"); + + level_editor_gadget[id] = gi; + } +} + +static void CreateDrawingAreas() +{ + struct GadgetInfo *gi; + unsigned long event_mask; + + event_mask = GD_EVENT_PRESSED | GD_EVENT_RELEASED | GD_EVENT_MOVING; + + gi = CreateGadget(GDI_CUSTOM_ID, ED_CTRL_ID_DRAWING_LEVEL, + GDI_X, SX, + GDI_Y, SY, + GDI_WIDTH, SXSIZE, + GDI_HEIGHT, SYSIZE, + GDI_TYPE, GD_TYPE_DRAWING_AREA, + GDI_ITEM_SIZE, MINI_TILEX, MINI_TILEY, + GDI_EVENT_MASK, event_mask, + GDI_CALLBACK, HandleDrawingAreas, + GDI_END); + + if (gi == NULL) + Error(ERR_EXIT, "cannot create gadget"); + + level_editor_gadget[ED_CTRL_ID_DRAWING_LEVEL] = gi; +} + +static void CreateLevelEditorGadgets() +{ + if (level_editor_gadgets_created) + return; + + CreateControlButtons(); + CreateCounterButtons(ED_COUNTER_SCORE); + CreateDrawingAreas(); + + level_editor_gadgets_created = TRUE; +} + +static void MapControlButtons() +{ + int i; + + for (i=0; ilev_fieldx-2*SCR_FIELDX+1) - level_xpos = lev_fieldx-2*SCR_FIELDX+1; - if (lev_fieldx<2*SCR_FIELDX-2) + if (level_xpos > lev_fieldx - 2*SCR_FIELDX + 1) + level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; + if (lev_fieldx < 2*SCR_FIELDX - 2) level_xpos = -1; - if (level_ypos<-1) + if (level_ypos < -1) level_ypos = -1; - if (level_ypos>lev_fieldy-2*SCR_FIELDY+1) - level_ypos = lev_fieldy-2*SCR_FIELDY+1; - if (lev_fieldy<2*SCR_FIELDY-2) + if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) + level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; + if (lev_fieldy < 2*SCR_FIELDY - 2) level_ypos = -1; } -void FloodFill(int from_x, int from_y, int fill_element) -{ - int i,x,y; - int old_element; - static int check[4][2] = { {-1,0}, {0,-1}, {1,0}, {0,1} }; - static int safety = 0; - - /* check if starting field still has the desired content */ - if (Feld[from_x][from_y] == fill_element) - return; - - safety++; - - if (safety > lev_fieldx*lev_fieldy) - Error(ERR_EXIT, "Something went wrong in 'FloodFill()'. Please debug."); - - old_element = Feld[from_x][from_y]; - Feld[from_x][from_y] = fill_element; - - for(i=0;i<4;i++) - { - x = from_x + check[i][0]; - y = from_y + check[i][1]; - - if (IN_LEV_FIELD(x,y) && Feld[x][y] == old_element) - FloodFill(x, y, fill_element); - } - - safety--; -} - void LevelEd(int mx, int my, int button) { static int last_button = 0; static int in_field_pressed = FALSE; - static BOOL use_floodfill = FALSE; + static boolean use_floodfill = FALSE; + + + /* int x = (mx-SX)/MINI_TILEX; int y = (my-SY)/MINI_TILEY; + */ + + /* + HandlePressedControlButtons(); + HandleDrawingFunctions(mx, my, button); + */ if (use_floodfill) /********** FLOOD FILL **********/ { + + +#if 0 + if (button) { if (mx>=SX && mx=SY && my0) || (choice == ED_BUTTON_EDOWN && element_shift=0) { - if (!DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; if (lev_fieldx<2*SCR_FIELDX-2) break; @@ -770,7 +1149,7 @@ void LevelEd(int mx, int my, int button) case ED_BUTTON_RIGHT: if (level_xpos<=lev_fieldx-2*SCR_FIELDX) { - if (!DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; if (lev_fieldx<2*SCR_FIELDX-2) break; @@ -787,7 +1166,7 @@ void LevelEd(int mx, int my, int button) case ED_BUTTON_UP: if (level_ypos>=0) { - if (!DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; if (lev_fieldy<2*SCR_FIELDY-2) break; @@ -804,7 +1183,7 @@ void LevelEd(int mx, int my, int button) case ED_BUTTON_DOWN: if (level_ypos<=lev_fieldy-2*SCR_FIELDY) { - if (!DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; if (lev_fieldy<2*SCR_FIELDY-2) break; @@ -822,6 +1201,12 @@ void LevelEd(int mx, int my, int button) break; } +#endif + + + +#if 0 + if (mx>=SX && mx=SY && my= 0 && choice < 36 && - DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + DelayReached(&choice_delay, GADGET_FRAME_DELAY)) { if (!(choice % 2)) step = -step; @@ -997,6 +1387,10 @@ void LevelEd(int mx, int my, int button) XFlush(display); } + + +#if 0 + switch(CheckCtrlButtons(mx,my,button)) { case ED_BUTTON_EDIT: @@ -1008,7 +1402,7 @@ void LevelEd(int mx, int my, int button) VXSIZE,VYSIZE, DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY2); OpenDoor(DOOR_OPEN_2); - edit_mode = TRUE; + edit_mode = ED_MODE_DRAWING; break; case ED_BUTTON_CLEAR: if (Request("Are you sure to clear this level ?",REQ_ASK)) @@ -1023,7 +1417,7 @@ void LevelEd(int mx, int my, int button) if (leveldir[leveldir_nr].readonly || Request("Exit without saving ?",REQ_ASK | REQ_STAY_OPEN)) { - CloseDoor(DOOR_CLOSE_BOTH); + CloseDoor(DOOR_CLOSE_ALL); game_status=MAINMENU; DrawMainMenu(); } @@ -1061,7 +1455,7 @@ void LevelEd(int mx, int my, int button) Ur[x][y]=Feld[x][y]; SaveLevel(level_nr); } - CloseDoor(DOOR_CLOSE_BOTH); + CloseDoor(DOOR_CLOSE_ALL); game_status=MAINMENU; DrawMainMenu(); } @@ -1071,6 +1465,10 @@ void LevelEd(int mx, int my, int button) break; } +#endif + + + if (mx>=ED_COUNT_GADGET_XPOS && mx=ED_COUNT_GADGET_YPOS+16*ED_COUNT_GADGET_YSIZE && @@ -1252,3 +1650,873 @@ void LevelNameTyping(KeySym key) name_typing = FALSE; } } + +static void DrawCounterValueField(int counter_id, int value) +{ + int x = SX + counter_info[counter_id].x + ED_WIN_COUNT_XPOS; + int y = SY + counter_info[counter_id].y; + + XCopyArea(display, pix[PIX_DOOR], drawto, gc, + DOOR_GFX_PAGEX4 + ED_WIN_COUNT_XPOS, + DOOR_GFX_PAGEY1 + ED_WIN_COUNT_YPOS, + ED_WIN_COUNT_XSIZE, ED_WIN_COUNT_YSIZE, + x, y); + + DrawText(x + ED_COUNT_VALUE_XOFFSET, y + ED_COUNT_VALUE_YOFFSET, + int2str(value, 3), FS_SMALL, FC_YELLOW); +} + +#define TEXT_COLLECTING "Score for collecting" +#define TEXT_SMASHING "Score for smashing" +#define TEXT_CRACKING "Score for cracking" +#define TEXT_SPEED "Speed of growth" +#define TEXT_DURATION "Duration when activated" + +static void DrawDrawingWindow() +{ + ClearWindow(); + UnmapLevelEditorWindowGadgets(); + MapMainDrawingArea(); + AdjustLevelScrollPosition(); + DrawMiniLevel(level_xpos, level_ypos); +} + +static void DrawPropertiesWindow(int element) +{ + int i, x, y; + int num_elements_in_level; + static struct + { + int element; + int *counter_value; + char *text; + } elements_with_counter[] = + { + { EL_EDELSTEIN, &level.score[0], TEXT_COLLECTING }, + { EL_EDELSTEIN_BD, &level.score[0], TEXT_COLLECTING }, + { EL_EDELSTEIN_GELB,&level.score[0], TEXT_COLLECTING }, + { EL_EDELSTEIN_ROT, &level.score[0], TEXT_COLLECTING }, + { EL_EDELSTEIN_LILA,&level.score[0], TEXT_COLLECTING }, + { EL_DIAMANT, &level.score[1], TEXT_COLLECTING }, + { EL_KAEFER_R, &level.score[2], TEXT_SMASHING }, + { EL_KAEFER_O, &level.score[2], TEXT_SMASHING }, + { EL_KAEFER_L, &level.score[2], TEXT_SMASHING }, + { EL_KAEFER_U, &level.score[2], TEXT_SMASHING }, + { EL_BUTTERFLY_R, &level.score[2], TEXT_SMASHING }, + { EL_BUTTERFLY_O, &level.score[2], TEXT_SMASHING }, + { EL_BUTTERFLY_L, &level.score[2], TEXT_SMASHING }, + { EL_BUTTERFLY_U, &level.score[2], TEXT_SMASHING }, + { EL_FLIEGER_R, &level.score[3], TEXT_SMASHING }, + { EL_FLIEGER_O, &level.score[3], TEXT_SMASHING }, + { EL_FLIEGER_L, &level.score[3], TEXT_SMASHING }, + { EL_FLIEGER_U, &level.score[3], TEXT_SMASHING }, + { EL_FIREFLY_R, &level.score[3], TEXT_SMASHING }, + { EL_FIREFLY_O, &level.score[3], TEXT_SMASHING }, + { EL_FIREFLY_L, &level.score[3], TEXT_SMASHING }, + { EL_FIREFLY_U, &level.score[3], TEXT_SMASHING }, + { EL_MAMPFER, &level.score[4], TEXT_SMASHING }, + { EL_MAMPFER2, &level.score[4], TEXT_SMASHING }, + { EL_ROBOT, &level.score[5], TEXT_SMASHING }, + { EL_PACMAN_R, &level.score[6], TEXT_SMASHING }, + { EL_PACMAN_O, &level.score[6], TEXT_SMASHING }, + { EL_PACMAN_L, &level.score[6], TEXT_SMASHING }, + { EL_PACMAN_U, &level.score[6], TEXT_SMASHING }, + { EL_KOKOSNUSS, &level.score[7], TEXT_CRACKING }, + { EL_DYNAMIT_AUS, &level.score[8], TEXT_COLLECTING }, + { EL_SCHLUESSEL1, &level.score[9], TEXT_COLLECTING }, + { EL_SCHLUESSEL2, &level.score[9], TEXT_COLLECTING }, + { EL_SCHLUESSEL3, &level.score[9], TEXT_COLLECTING }, + { EL_SCHLUESSEL4, &level.score[9], TEXT_COLLECTING }, + { EL_AMOEBE_NASS, &level.tempo_amoebe, TEXT_SPEED }, + { EL_AMOEBE_NORM, &level.tempo_amoebe, TEXT_SPEED }, + { EL_AMOEBE_VOLL, &level.tempo_amoebe, TEXT_SPEED }, + { EL_AMOEBE_BD, &level.tempo_amoebe, TEXT_SPEED }, + { EL_SIEB_LEER, &level.dauer_sieb, TEXT_DURATION }, + { EL_ABLENK_AUS, &level.dauer_ablenk, TEXT_DURATION }, + { -1, NULL, NULL } + }; + + ClearWindow(); + UnmapLevelEditorWindowGadgets(); + + DrawGraphic(1, 1, el2gfx(element)); + DrawText(SX + 3*TILEX, SY + 5*TILEY/4, "Element Properties", + FS_SMALL, FC_YELLOW); + + num_elements_in_level = 0; + for(y=0; y to_x) + swap_numbers(&from_x, &to_x); + + for (x=from_x; x<=to_x; x++) + DrawLineElement(x, y, element, change_level); + } + else if (from_x == to_x) /* vertical line */ + { + int x = from_x; + int y; + + if (from_y > to_y) + swap_numbers(&from_y, &to_y); + + for (y=from_y; y<=to_y; y++) + DrawLineElement(x, y, element, change_level); + } + else /* diagonal line */ + { + int len_x = ABS(to_x - from_x); + int len_y = ABS(to_y - from_y); + int x, y; + + if (len_y < len_x) /* a < 1 */ + { + float a = (float)len_y / (float)len_x; + + if (from_x > to_x) + swap_number_pairs(&from_x, &from_y, &to_x, &to_y); + + for (x=0; x<=len_x; x++) + { + int y = (int)(a * x + 0.5) * (to_y < from_y ? -1 : +1); + + DrawLineElement(from_x + x, from_y + y, element, change_level); + } + } + else /* a >= 1 */ + { + float a = (float)len_x / (float)len_y; + + if (from_y > to_y) + swap_number_pairs(&from_x, &from_y, &to_x, &to_y); + + for (y=0; y<=len_y; y++) + { + int x = (int)(a * y + 0.5) * (to_x < from_x ? -1 : +1); + + DrawLineElement(from_x + x, from_y + y, element, change_level); + } + } + } +} + +static void DrawRectangle(int from_x, int from_y, int to_x, int to_y, + int element, boolean change_level) +{ + DrawLine(from_x, from_y, from_x, to_y, element, change_level); + DrawLine(from_x, to_y, to_x, to_y, element, change_level); + DrawLine(to_x, to_y, to_x, from_y, element, change_level); + DrawLine(to_x, from_y, from_x, from_y, element, change_level); +} + +static void DrawFilledBox(int from_x, int from_y, int to_x, int to_y, + int element, boolean change_level) +{ + int y; + + if (from_y > to_y) + swap_number_pairs(&from_x, &from_y, &to_x, &to_y); + + for (y=from_y; y<=to_y; y++) + DrawLine(from_x, y, to_x, y, element, change_level); +} + +static void FloodFill(int from_x, int from_y, int fill_element) +{ + int i,x,y; + int old_element; + static int check[4][2] = { {-1,0}, {0,-1}, {1,0}, {0,1} }; + static int safety = 0; + + /* check if starting field still has the desired content */ + if (Feld[from_x][from_y] == fill_element) + return; + + safety++; + + if (safety > lev_fieldx*lev_fieldy) + Error(ERR_EXIT, "Something went wrong in 'FloodFill()'. Please debug."); + + old_element = Feld[from_x][from_y]; + Feld[from_x][from_y] = fill_element; + + for(i=0;i<4;i++) + { + x = from_x + check[i][0]; + y = from_y + check[i][1]; + + if (IN_LEV_FIELD(x,y) && Feld[x][y] == old_element) + FloodFill(x, y, fill_element); + } + + safety--; +} + +static void CopyLevelToUndoBuffer() +{ + int x, y; + + undo_buffer_position = (undo_buffer_position + 1) % NUM_UNDO_STEPS; + + if (undo_buffer_steps < NUM_UNDO_STEPS - 1) + undo_buffer_steps++; + + for(x=0; x 0) + { + x = RND(lev_fieldx); + y = RND(lev_fieldy); + + if (Feld[x][y] != new_element) + { + Feld[x][y] = new_element; + elements_left--; + } + } + } + + DrawMiniLevel(level_xpos, level_ypos); +} + +static void HandleDrawingAreas(struct GadgetInfo *gi) +{ + static boolean started_inside_drawing_area = FALSE; + boolean inside_drawing_area = !gi->event.off_borders; + boolean button_press_event; + boolean button_release_event; + int new_element; + int button = gi->event.button; + int sx = gi->event.x, sy = gi->event.y; + int lx, ly; + int x, y; + + if (edit_mode != ED_MODE_DRAWING) + return; + + button_press_event = (gi->event.type == GD_EVENT_PRESSED); + button_release_event = (gi->event.type == GD_EVENT_RELEASED); + + sx = (sx < 0 ? 0 : sx > 2*SCR_FIELDX - 1 ? 2*SCR_FIELDX - 1 : sx); + sy = (sy < 0 ? 0 : sy > 2*SCR_FIELDY - 1 ? 2*SCR_FIELDY - 1 : sy); + lx = sx + level_xpos; + ly = sy + level_ypos; + + if (button_press_event) + started_inside_drawing_area = inside_drawing_area; + + if (!started_inside_drawing_area) + return; + + printf("%d,%d, %d,%d, %d,%d.\n", + gi->event.x, gi->event.y, sx, sy, lx, ly); + + if ((!button && !button_release_event) || + sx > lev_fieldx || sy > lev_fieldy || + (sx == 0 && level_xpos<0) || + (sx == 2*SCR_FIELDX - 1 && level_xpos > lev_fieldx - 2*SCR_FIELDX) || + (sy == 0 && level_ypos < 0) || + (sy == 2*SCR_FIELDY - 1 && level_ypos > lev_fieldy - 2*SCR_FIELDY)) + return; + + new_element = (button == 1 ? new_element1 : + button == 2 ? new_element2 : + button == 3 ? new_element3 : 0); + + switch (drawing_function) + { + case ED_CTRL_ID_SINGLE_ITEMS: + if (button_release_event) + CopyLevelToUndoBuffer(); + + if (!button) + break; + + if (new_element != Feld[lx][ly]) + { + if (new_element == EL_SPIELFIGUR) + { + /* remove player at old position */ + for(y=0; y= 0 && x - level_xpos < 2*SCR_FIELDX && + y - level_ypos >= 0 && y - level_ypos < 2*SCR_FIELDY) + DrawMiniElement(x - level_xpos, y - level_ypos, EL_LEERRAUM); + } + } + } + } + + Feld[lx][ly] = new_element; + DrawMiniElement(sx, sy, new_element); + } + break; + + case ED_CTRL_ID_CONNECTED_ITEMS: + { + static int last_sx = -1; + static int last_sy = -1; + + if (button_release_event) + CopyLevelToUndoBuffer(); + + if (button) + { + if (!button_press_event) + DrawLine(last_sx, last_sy, sx, sy, new_element, TRUE); + + last_sx = sx; + last_sy = sy; + } + } + break; + + case ED_CTRL_ID_LINE: + case ED_CTRL_ID_RECTANGLE: + case ED_CTRL_ID_FILLED_BOX: + { + static int last_sx = -1; + static int last_sy = -1; + static int start_sx = -1; + static int start_sy = -1; + void (*draw_func)(int, int, int, int, int, boolean); + + if (drawing_function == ED_CTRL_ID_LINE) + draw_func = DrawLine; + else if (drawing_function == ED_CTRL_ID_RECTANGLE) + draw_func = DrawRectangle; + else + draw_func = DrawFilledBox; + + if (button_press_event) + { + last_sx = start_sx = sx; + last_sy = start_sy = sy; + draw_func(sx, sy, sx, sy, new_element, FALSE); + } + else if (button_release_event) + { + draw_func(start_sx, start_sy, sx, sy, new_element, TRUE); + CopyLevelToUndoBuffer(); + } + else if (last_sx != sx || last_sy != sy) + { + draw_func(start_sx, start_sy, last_sx, last_sy, -1, FALSE); + draw_func(start_sx, start_sy, sx, sy, new_element, FALSE); + last_sx = sx; + last_sy = sy; + } + } + break; + + case ED_CTRL_ID_FLOOD_FILL: + if (button_press_event && Feld[lx][ly] != new_element) + { + FloodFill(lx, ly, new_element); + DrawMiniLevel(level_xpos, level_ypos); + CopyLevelToUndoBuffer(); + } + break; + + default: + break; + } +} + + + +#if 0 + +static void HandlePressedControlButtons() +{ + static unsigned long button_delay = 0; + int i; + + /* buttons with action when held pressed */ + int gadget_id[] = + { + ED_CTRL_ID_WRAP_UP, + ED_CTRL_ID_WRAP_LEFT, + ED_CTRL_ID_WRAP_RIGHT, + ED_CTRL_ID_WRAP_DOWN, + ED_CTRL_ID_SCORE_DOWN, + ED_CTRL_ID_SCORE_UP, + -1 + }; + + if (!DelayReached(&button_delay, GADGET_FRAME_DELAY)) + return; + + for (i=0; gadget_id[i] != -1; i++) + { + int id = gadget_id[i]; + int state = level_editor_gadget[id]->state; + int button = level_editor_gadget[id]->event.button; + int step = (button == 1 ? 1 : button == 2 ? 5 : 10); + + if (state != GD_BUTTON_PRESSED) + continue; + + switch (id) + { + case ED_CTRL_ID_WRAP_LEFT: + if (level_xpos >= 0) + { + if (lev_fieldx < 2*SCR_FIELDX - 2) + break; + + level_xpos -= step; + if (level_xpos <- 1) + level_xpos = -1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_RIGHT); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_RIGHT: + if (level_xpos <= lev_fieldx - 2*SCR_FIELDX) + { + if (lev_fieldx < 2*SCR_FIELDX - 2) + break; + + level_xpos += step; + if (level_xpos > lev_fieldx - 2*SCR_FIELDX + 1) + level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_LEFT); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_UP: + if (level_ypos >= 0) + { + if (lev_fieldy < 2*SCR_FIELDY - 2) + break; + + level_ypos -= step; + if (level_ypos < -1) + level_ypos = -1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_DOWN); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_DOWN: + if (level_ypos <= lev_fieldy - 2*SCR_FIELDY) + { + if (lev_fieldy < 2*SCR_FIELDY - 2) + break; + + level_ypos += step; + if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) + level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_UP); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_SCORE_DOWN: + case ED_CTRL_ID_SCORE_UP: + *gadget_score_value += (id == ED_CTRL_ID_SCORE_DOWN ? -step : step); + if (*gadget_score_value < 0) + *gadget_score_value = 0; + else if (*gadget_score_value > 255) + *gadget_score_value = 255; + + DrawCounterValueField(ED_COUNTER_SCORE, *gadget_score_value); + break; + + default: + break; + } + } +} + +#endif + + + +static void HandleCounterButtons(struct GadgetInfo *gi) +{ + int id = gi->custom_id; + int button = gi->event.button; + int step = (button == 1 ? 1 : button == 2 ? 5 : 10); + + switch (id) + { + case ED_CTRL_ID_SCORE_DOWN: + case ED_CTRL_ID_SCORE_UP: + *gadget_score_value += (id == ED_CTRL_ID_SCORE_DOWN ? -step : step); + if (*gadget_score_value < 0) + *gadget_score_value = 0; + else if (*gadget_score_value > 255) + *gadget_score_value = 255; + + DrawCounterValueField(ED_COUNTER_SCORE, *gadget_score_value); + break; + + default: + break; + } +} + +static void HandleControlButtons(struct GadgetInfo *gi) +{ + int id = gi->custom_id; + int button = gi->event.button; + int step = (button == 1 ? 1 : button == 2 ? 5 : 10); + int new_element; + int player_present = FALSE; + int level_changed = FALSE; + int x, y; + + new_element = (button == 1 ? new_element1 : + button == 2 ? new_element2 : + button == 3 ? new_element3 : 0); + + if (id < ED_NUM_CTRL1_BUTTONS && edit_mode != ED_MODE_DRAWING) + { + DrawDrawingWindow(); + edit_mode = ED_MODE_DRAWING; + } + + switch (id) + { + case ED_CTRL_ID_SINGLE_ITEMS: + case ED_CTRL_ID_CONNECTED_ITEMS: + case ED_CTRL_ID_LINE: + case ED_CTRL_ID_TEXT: + case ED_CTRL_ID_RECTANGLE: + case ED_CTRL_ID_FILLED_BOX: + case ED_CTRL_ID_FLOOD_FILL: + case ED_CTRL_ID_BRUSH: + drawing_function = id; + break; + + case ED_CTRL_ID_WRAP_LEFT: + if (level_xpos >= 0) + { + if (lev_fieldx < 2*SCR_FIELDX - 2) + break; + + level_xpos -= step; + if (level_xpos <- 1) + level_xpos = -1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_RIGHT); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_RIGHT: + if (level_xpos <= lev_fieldx - 2*SCR_FIELDX) + { + if (lev_fieldx < 2*SCR_FIELDX - 2) + break; + + level_xpos += step; + if (level_xpos > lev_fieldx - 2*SCR_FIELDX + 1) + level_xpos = lev_fieldx - 2*SCR_FIELDX + 1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_LEFT); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_UP: + if (level_ypos >= 0) + { + if (lev_fieldy < 2*SCR_FIELDY - 2) + break; + + level_ypos -= step; + if (level_ypos < -1) + level_ypos = -1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_DOWN); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_WRAP_DOWN: + if (level_ypos <= lev_fieldy - 2*SCR_FIELDY) + { + if (lev_fieldy < 2*SCR_FIELDY - 2) + break; + + level_ypos += step; + if (level_ypos > lev_fieldy - 2*SCR_FIELDY + 1) + level_ypos = lev_fieldy - 2*SCR_FIELDY + 1; + if (button == 1) + ScrollMiniLevel(level_xpos, level_ypos, ED_SCROLL_UP); + else + DrawMiniLevel(level_xpos, level_ypos); + } + break; + + case ED_CTRL_ID_PROPERTIES: + DrawPropertiesWindow(new_element); + edit_mode = ED_MODE_PROPERTIES; + break; + + case ED_CTRL_ID_RANDOM_PLACEMENT: + RandomPlacement(button); + CopyLevelToUndoBuffer(); + break; + + case ED_CTRL_ID_UNDO: + if (undo_buffer_steps == 0) + { + Request("Undo buffer empty !", REQ_CONFIRM); + break; + } + + undo_buffer_position = + (undo_buffer_position - 1 + NUM_UNDO_STEPS) % NUM_UNDO_STEPS; + undo_buffer_steps--; + + for(x=0; xevent.type == GD_EVENT_PRESSED) + printf("default: HandleControlButtons: GD_EVENT_PRESSED\n"); + else if (gi->event.type == GD_EVENT_RELEASED) + printf("default: HandleControlButtons: GD_EVENT_RELEASED\n"); + else if (gi->event.type == GD_EVENT_MOVING) + printf("default: HandleControlButtons: GD_EVENT_MOVING\n"); + else + printf("default: HandleControlButtons: ?\n"); + break; + } +}