X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Feditor.c;h=7c453d92dd8f8090959ce9e4f4e85fe5fba48336;hb=6467d24a3a0f19645cd5ea89b4ca18a95021d657;hp=96718762f880db4f65f92143322db6eb5318033b;hpb=4ec434ee1acb955d0e2e8c33558e5f9226904174;p=rocksndiamonds.git diff --git a/src/editor.c b/src/editor.c index 96718762..7c453d92 100644 --- a/src/editor.c +++ b/src/editor.c @@ -17,6 +17,7 @@ #include "misc.h" #include "buttons.h" #include "files.h" +#include "game.h" /* positions in the level editor */ #define ED_WIN_MB_LEFT_XPOS 7 @@ -35,11 +36,25 @@ #define ED_SCROLL_UP 4 #define ED_SCROLL_DOWN 8 -/* delay value to avoid too fast scrolling etc. */ -#define CHOICE_DELAY_VALUE 100 +/* 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 elements with content */ +#define MAX_ELEMCONT 8 /* values for the control window */ -#define ED_CTRL_BUTTONS_GFX_YPOS 236 +#define ED_CTRL_BUTTONS_GFX_YPOS 236 +#define ED_CTRL_BUTTONS_ALT_GFX_YPOS 142 + #define ED_CTRL1_BUTTONS_HORIZ 4 #define ED_CTRL1_BUTTONS_VERT 4 #define ED_CTRL1_BUTTON_XSIZE 22 @@ -56,21 +71,37 @@ #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) -/* control button names */ +/* values for properties window */ +#define ED_PROPERTIES_XPOS (TILEX - MINI_TILEX/2) +/* values for counter gadgets */ +#define ED_COUNT_VALUE_XOFFSET 5 +#define ED_COUNT_VALUE_YOFFSET 3 +#define ED_COUNT_SCORE_XPOS ED_PROPERTIES_XPOS +#define ED_COUNT_SCORE_YPOS (14 * MINI_TILEY) +#define ED_COUNT_ELEMCONT_XPOS ED_PROPERTIES_XPOS +#define ED_COUNT_ELEMCONT_YPOS (17 * MINI_TILEY) + +/* values for element content drawing areas */ +#define ED_AREA_ELEMCONT_XPOS (TILEX) +#define ED_AREA_ELEMCONT_YPOS (10 * TILEY) + +/* control button identifiers */ #define ED_CTRL_ID_SINGLE_ITEMS 0 #define ED_CTRL_ID_CONNECTED_ITEMS 1 -#define ED_CTRL_ID_LINES 2 +#define ED_CTRL_ID_LINE 2 #define ED_CTRL_ID_TEXT 3 #define ED_CTRL_ID_RECTANGLE 4 -#define ED_CTRL_ID_BOX 5 +#define ED_CTRL_ID_FILLED_BOX 5 #define ED_CTRL_ID_WRAP_UP 6 -#define ED_CTRL_ID_ITEM_PROPERTIES 7 +#define ED_CTRL_ID_PROPERTIES 7 #define ED_CTRL_ID_FLOOD_FILL 8 #define ED_CTRL_ID_WRAP_LEFT 9 +#define ED_CTRL_ID_UNUSED1 10 #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_UNUSED2 15 #define ED_CTRL_ID_UNDO 16 #define ED_CTRL_ID_INFO 17 #define ED_CTRL_ID_SAVE 18 @@ -78,22 +109,79 @@ #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 +#define ED_CTRL_ID_ELEMCONT_DOWN 24 +#define ED_CTRL_ID_ELEMCONT_UP 25 + +/* drawing area identifiers */ +#define ED_CTRL_ID_DRAWING_LEVEL 26 +#define ED_CTRL_ID_ELEMCONT_0 27 +#define ED_CTRL_ID_ELEMCONT_7 34 +#define ED_CTRL_ID_AMOEBA_CONTENT 35 + +#define ED_NUM_GADGETS 36 + +/* values for counter gadgets */ +#define ED_COUNTER_SCORE 0 +#define ED_COUNTER_ELEMCONT 1 + +#define ED_NUM_COUNTERS 2 + +static struct +{ + int x, y; + int gadget_id; +} counter_info[ED_NUM_COUNTERS] = +{ + { ED_COUNT_SCORE_XPOS, ED_COUNT_SCORE_YPOS, + ED_CTRL_ID_SCORE_DOWN }, + { ED_COUNT_ELEMCONT_XPOS, ED_COUNT_ELEMCONT_YPOS, + ED_CTRL_ID_ELEMCONT_DOWN } +}; + /* forward declaration for internal use */ -void HandleDrawingFunction(int, int, int); +static void DrawDrawingWindow(); +static void DrawPropertiesWindow(); +static void CopyLevelToUndoBuffer(); +static void HandleDrawingAreas(struct GadgetInfo *); +static void HandleCounterButtons(struct GadgetInfo *); +static void HandleControlButtons(struct GadgetInfo *); -static struct GadgetInfo *control_button_gadget[ED_NUM_CTRL_BUTTONS]; -static boolean control_button_gadgets_created = FALSE; +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 int properties_element = 0; + +static short ElementContent[MAX_ELEMCONT][3][3]; +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 + +/* pointer to score value */ +static int *gadget_score_value; +static int *gadget_areas_value; static int level_xpos,level_ypos; -static boolean edit_mode; +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; -int element_shift; +int element_shift = 0; + int editor_element[] = { EL_CHAR_A + ('B' - 'A'), @@ -117,7 +205,7 @@ int editor_element[] = EL_BETON, EL_FELSBODEN, - EL_SIEB2_LEER, + EL_SIEB2_INAKTIV, EL_AUSGANG_ZU, EL_AUSGANG_AUF, @@ -164,7 +252,7 @@ int editor_element[] = EL_BETON, EL_MAUERWERK, EL_FELSBODEN, - EL_SIEB_LEER, + EL_SIEB_INAKTIV, EL_EDELSTEIN, EL_DIAMANT, @@ -276,6 +364,11 @@ int editor_element[] = EL_MAUER_Y, EL_MAUER_XY, + EL_SPEED_PILL, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + EL_CHAR_A + ('S' - 'A'), EL_CHAR_A + ('O' - 'A'), EL_CHAR_A + ('K' - 'A'), @@ -291,6 +384,71 @@ int editor_element[] = EL_SOKOBAN_FELD_VOLL, EL_BETON, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + EL_LEERRAUM, + + EL_CHAR('S'), + EL_CHAR('U'), + EL_CHAR('P'), + EL_CHAR('A'), + + EL_CHAR('P'), + EL_CHAR('L'), + EL_CHAR('E'), + EL_CHAR('X'), + + EL_SP_EMPTY, + EL_SP_ZONK, + EL_SP_BASE, + EL_SP_MURPHY, + + EL_SP_INFOTRON, + EL_SP_CHIP_SINGLE, + EL_SP_HARD_GRAY, + EL_SP_EXIT, + + EL_SP_DISK_ORANGE, + EL_SP_PORT1_RIGHT, + EL_SP_PORT1_DOWN, + EL_SP_PORT1_LEFT, + + EL_SP_PORT1_UP, + EL_SP_PORT2_RIGHT, + EL_SP_PORT2_DOWN, + EL_SP_PORT2_LEFT, + + EL_SP_PORT2_UP, + EL_SP_SNIKSNAK, + EL_SP_DISK_YELLOW, + EL_SP_TERMINAL, + + EL_SP_DISK_RED, + EL_SP_PORT_Y, + EL_SP_PORT_X, + EL_SP_PORT_XY, + + EL_SP_ELECTRON, + EL_SP_BUG, + EL_SP_CHIP_LEFT, + EL_SP_CHIP_RIGHT, + + EL_SP_HARD_BASE1, + EL_SP_HARD_GREEN, + EL_SP_HARD_BLUE, + EL_SP_HARD_RED, + + EL_SP_HARD_YELLOW, + EL_SP_HARD_BASE2, + EL_SP_HARD_BASE3, + EL_SP_HARD_BASE4, + + EL_SP_HARD_BASE5, + EL_SP_HARD_BASE6, + EL_SP_CHIP_UPPER, + EL_SP_CHIP_LOWER, + /* EL_CHAR_A + ('D' - 'A'), EL_CHAR_A + ('Y' - 'A'), @@ -385,11 +543,12 @@ int editor_element[] = EL_CHAR_OE, EL_CHAR_UE, - EL_CHAR_COPY + EL_CHAR_COPY, + EL_LEERRAUM }; int elements_in_list = sizeof(editor_element)/sizeof(int); -void ScrollMiniLevel(int from_x, int from_y, int scroll) +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); @@ -416,234 +575,61 @@ void ScrollMiniLevel(int from_x, int from_y, int scroll) BackToFront(); } -void HandlePressedControlButtons() -{ - static unsigned long button_delay = 0; - int i = 0; - - /* 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, - -1 - }; - - if (!DelayReached(&button_delay, CHOICE_DELAY_VALUE)) - return; - - while (gadget_id[i] != -1) - { - int id = gadget_id[i++]; - int state = control_button_gadget[id]->state; - int button = control_button_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; - - default: - break; - } - } -} - -void HandleLevelEditorControlButtons(struct GadgetInfo *gi) +void InitLevelEditorGadgets() { - int event_type = gi->event.type; - - /* - int button = gi->event.button; - */ - - int id; - int i, x, y; - - /* get the button id */ - for (i=0; iid == control_button_gadget[i]->id) - id = i; - - switch (id) - { - case ED_CTRL_ID_SINGLE_ITEMS: - case ED_CTRL_ID_CONNECTED_ITEMS: - case ED_CTRL_ID_LINES: - case ED_CTRL_ID_TEXT: - case ED_CTRL_ID_RECTANGLE: - case ED_CTRL_ID_BOX: - case ED_CTRL_ID_FLOOD_FILL: - case ED_CTRL_ID_RANDOM_PLACEMENT: - case ED_CTRL_ID_BRUSH: - drawing_function = id; - break; - - case ED_CTRL_ID_CLEAR: - if (Request("Are you sure to clear this level ?", REQ_ASK)) - { - for(x=0; xlev_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; } @@ -1004,9 +1161,10 @@ void LevelEd(int mx, int my, int button) int y = (my-SY)/MINI_TILEY; */ - + /* HandlePressedControlButtons(); - HandleDrawingFunction(mx, my, button); + HandleDrawingFunctions(mx, my, button); + */ if (use_floodfill) /********** FLOOD FILL **********/ { @@ -1058,13 +1216,20 @@ void LevelEd(int mx, int my, int button) if (((choice == ED_BUTTON_EUP && element_shift>0) || (choice == ED_BUTTON_EDOWN && element_shiftelements_in_list-MAX_ELEM_X*MAX_ELEM_Y) @@ -1104,9 +1269,16 @@ void LevelEd(int mx, int my, int button) DY+ED_WIN_MB_RIGHT_YPOS, el2gfx(new_element3)); redraw_mask |= REDRAW_DOOR_1; + + if (!HAS_CONTENT(properties_element)) + { + properties_element = new_element; + if (edit_mode == ED_MODE_PROPERTIES) + DrawPropertiesWindow(); + } } - if (edit_mode) /********** EDIT-FENSTER **********/ + if (edit_mode == ED_MODE_DRAWING) /********** EDIT-FENSTER **********/ { @@ -1123,7 +1295,7 @@ void LevelEd(int mx, int my, int button) VXSIZE,VYSIZE, DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY2); OpenDoor(DOOR_OPEN_2); - edit_mode = FALSE; + edit_mode = ED_MODE_INFO; break; case ED_BUTTON_FILL: Request("Caution ! Flood fill mode ! Choose area !",REQ_OPEN); @@ -1133,7 +1305,7 @@ void LevelEd(int mx, int my, int button) case ED_BUTTON_LEFT: if (level_xpos>=0) { - if (!DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + if (!DelayReached(&choice_delay, GADGET_FRAME_DELAY)) break; if (lev_fieldx<2*SCR_FIELDX-2) break; @@ -1150,7 +1322,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; @@ -1167,7 +1339,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; @@ -1184,7 +1356,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; @@ -1257,13 +1429,13 @@ void LevelEd(int mx, int my, int button) } - else /********** KONTROLL-FENSTER **********/ + else if (edit_mode == ED_MODE_INFO)/********** KONTROLL-FENSTER **********/ { int choice = CheckCountButtons(mx,my,button); int step = (button==1 ? 1 : button==2 ? 5 : button==3 ? 10 : 0); if (choice >= 0 && choice < 36 && - DelayReached(&choice_delay, CHOICE_DELAY_VALUE)) + DelayReached(&choice_delay, GADGET_FRAME_DELAY)) { if (!(choice % 2)) step = -step; @@ -1403,7 +1575,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)) @@ -1418,7 +1590,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(); } @@ -1456,7 +1628,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(); } @@ -1652,102 +1824,458 @@ void LevelNameTyping(KeySym key) } } -static void swap_numbers(int *i1, int *i2) +static void DrawCounterValueField(int counter_id, int value) { - int help = *i1; + int x = SX + counter_info[counter_id].x + ED_WIN_COUNT_XPOS; + int y = SY + counter_info[counter_id].y; - *i1 = *i2; - *i2 = help; + 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); } -static void swap_number_pairs(int *x1, int *y1, int *x2, int *y2) +static void DrawDrawingWindow() { - int help_x = *x1; - int help_y = *y1; - - *x1 = *x2; - *x2 = help_x; - - *y1 = *y2; - *y2 = help_y; + ClearWindow(); + UnmapLevelEditorWindowGadgets(); + MapMainDrawingArea(); + AdjustLevelScrollPosition(); + DrawMiniLevel(level_xpos, level_ypos); } -static void DrawLineElement(int sx, int sy, int element) +static void DrawElementContentAreas() { - int lx = sx + level_xpos; - int ly = sy + level_ypos; + int *num_areas = &MampferMax; + int area_x = ED_AREA_ELEMCONT_XPOS / MINI_TILEX; + int area_y = ED_AREA_ELEMCONT_YPOS / MINI_TILEY; + int area_sx = SX + ED_AREA_ELEMCONT_XPOS; + int area_sy = SY + ED_AREA_ELEMCONT_YPOS; + int i, x, y; - if (element < 0) - DrawMiniElement(sx, sy, Feld[lx][ly]); - else + for (i=0; i to_x) - swap_numbers(&from_x, &to_x); + DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 0 * MINI_TILEY + 1, + "Content", FS_SMALL, FC_YELLOW); + DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 1 * MINI_TILEY + 1, + "when", FS_SMALL, FC_YELLOW); + DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 2 * MINI_TILEY + 1, + "smashed", FS_SMALL, FC_YELLOW); - for (x=from_x; x<=to_x; x++) - DrawLineElement(x, y, element); - } - else if (from_x == to_x) /* vertical line */ + for (i=0; i<*num_areas; i++) { - 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); + for (y=0; y<3; y++) + for (x=0; x<3; x++) + DrawMiniElement(area_x + 5 * (i % 4) + x, area_y + 6 * (i / 4) + y, + ElementContent[i][x][y]); + + DrawTextF(area_sx - SX + 5 * (i % 4) * MINI_TILEX + MINI_TILEX + 1, + area_sy - SY + 6 * (i / 4) * MINI_TILEY + 4 * MINI_TILEY - 4, + FC_YELLOW, "%d", i + 1); } - 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) /* < 45° */ - { - float a = (float)len_y / (float)len_x; + for (i=0; i<*num_areas; i++) + MapDrawingArea(ED_CTRL_ID_ELEMCONT_0 + i); +} - if (from_x > to_x) +static void DrawAmoebaContentArea() +{ + int area_x = ED_AREA_ELEMCONT_XPOS / MINI_TILEX; + int area_y = ED_AREA_ELEMCONT_YPOS / MINI_TILEY; + int area_sx = SX + ED_AREA_ELEMCONT_XPOS; + int area_sy = SY + ED_AREA_ELEMCONT_YPOS; + int x, y; + + ElementContent[0][0][0] = level.amoebe_inhalt; + + /* draw decorative border for the object */ + for (y=0; y<2; y++) + for (x=0; x<2; x++) + DrawMiniElement(area_x + x, area_y + y, EL_ERDREICH); + + XFillRectangle(display, drawto, gc, + area_sx + MINI_TILEX/2 - 1, area_sy + MINI_TILEY/2 - 1, + MINI_TILEX + 2, MINI_TILEY + 2); + + /* copy border to the right location */ + XCopyArea(display, drawto, drawto, gc, + area_sx, area_sy, 3 * MINI_TILEX, 3 * MINI_TILEY, + area_sx - MINI_TILEX/2, area_sy - MINI_TILEY/2); + + DrawText(area_sx + TILEX, area_sy + 1, "Content of amoeba", + FS_SMALL, FC_YELLOW); + + DrawMiniElement(area_x, area_y, ElementContent[0][0][0]); + + MapDrawingArea(ED_CTRL_ID_AMOEBA_CONTENT); +} + +#define TEXT_COLLECTING "Score for collecting" +#define TEXT_SMASHING "Score for smashing" +#define TEXT_CRACKING "Score for cracking" +#define TEXT_SPEED "Speed of amoeba growth" +#define TEXT_DURATION "Duration when activated" + +static void DrawPropertiesWindow() +{ + 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_INAKTIV, &level.dauer_sieb, TEXT_DURATION }, + { EL_ABLENK_AUS, &level.dauer_ablenk, TEXT_DURATION }, + { -1, NULL, NULL } + }; + + ClearWindow(); + UnmapLevelEditorWindowGadgets(); + + /* draw some decorative border for the object */ + for (y=0; y<3; y++) + for (x=0; x<3; x++) + DrawMiniElement(2 + x , 2 + y, EL_ERDREICH); + + XFillRectangle(display, drawto, gc, + SX + TILEX + MINI_TILEX/2 - 1, + SY + TILEY + MINI_TILEY/2 - 1, + TILEX + 2, TILEY + 2); + + /* copy border to the right location */ + XCopyArea(display, drawto, drawto, gc, + SX + TILEX, SY + TILEY, + 2 * TILEX, 2 * TILEY, + SX + TILEX - MINI_TILEX/2, SY + TILEY - MINI_TILEY/2); + + DrawGraphic(1, 1, el2gfx(properties_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= 45° */ + 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 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 DrawAreaBorder(int from_x, int from_y, int to_x, int to_y) +{ + int from_sx, from_sy; + int to_sx, to_sy; + + if (from_x > to_x) + swap_numbers(&from_x, &to_x); + + if (from_y > to_y) + swap_numbers(&from_y, &to_y); + + from_sx = SX + from_x * MINI_TILEX; + from_sy = SY + from_y * MINI_TILEY; + to_sx = SX + to_x * MINI_TILEX + MINI_TILEX - 1; + to_sy = SY + to_y * MINI_TILEY + MINI_TILEY - 1; + + XSetForeground(display, gc, WhitePixel(display, screen)); + + XDrawLine(display, drawto, gc, from_sx, from_sy, to_sx, from_sy); + XDrawLine(display, drawto, gc, to_sx, from_sy, to_sx, to_sy); + XDrawLine(display, drawto, gc, to_sx, to_sy, from_sx, to_sy); + XDrawLine(display, drawto, gc, from_sx, to_sy, from_sx, from_sy); + + XSetForeground(display, gc, BlackPixel(display, screen)); + + if (from_x == to_x && from_y == to_y) + MarkTileDirty(from_x/2, from_y/2); + else + redraw_mask |= REDRAW_FIELD; +} + +static void SelectArea(int from_x, int from_y, int to_x, int to_y, + int element, boolean change_level) +{ + if (element == -1 || change_level) + DrawRectangle(from_x, from_y, to_x, to_y, -1, FALSE); + else + DrawAreaBorder(from_x, from_y, to_x, to_y); +} + +/* values for CopyBrushExt() */ +#define CB_AREA_TO_BRUSH 0 +#define CB_BRUSH_TO_LEVEL 1 + +static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y, int mode) +{ + static short brush_buffer[MAX_LEV_FIELDX][MAX_LEV_FIELDY]; + static brush_from_x, brush_from_y; + static brush_to_x, brush_to_y; + int x, y; + + if (from_x > to_x) + swap_numbers(&from_x, &to_x); + + if (from_y > to_y) + swap_numbers(&from_y, &to_y); + + if (mode == CB_AREA_TO_BRUSH) + { + for (y=from_y; y<=to_y; y++) + for (x=from_x; x<=to_x; x++) + brush_buffer[x][y] = Feld[x][y]; + + brush_from_x = from_x; + brush_from_y = from_y; + brush_to_x = to_x; + brush_to_y = to_y; + } + else + { + for (y=brush_from_y; y<=brush_to_y; y++) + for (x=brush_from_x; x<=brush_to_x; x++) + Feld[x][y] = brush_buffer[x][y]; + CopyLevelToUndoBuffer(); + } +} + +static void CopyAreaToBrush(int from_x, int from_y, int to_x, int to_y) +{ + CopyBrushExt(from_x, from_y, to_x, to_y, CB_AREA_TO_BRUSH); +} + +#if 0 +static void CopyBrushToLevel() +{ + CopyBrushExt(0, 0, 0, 0, CB_BRUSH_TO_LEVEL); +} +#endif + +static void FloodFill(int from_x, int from_y, int fill_element) { int i,x,y; int old_element; @@ -1778,105 +2306,675 @@ void FloodFill(int from_x, int from_y, int fill_element) safety--; } -void HandleDrawingFunction(int mx, int my, int button) +/* values for DrawLevelText() modes */ +#define TEXT_INIT 0 +#define TEXT_SETCURSOR 1 +#define TEXT_WRITECHAR 2 +#define TEXT_BACKSPACE 3 +#define TEXT_NEWLINE 4 +#define TEXT_END 5 + +static void DrawLevelText(int sx, int sy, char letter, int mode) +{ + static short delete_buffer[MAX_LEV_FIELDX]; + static int start_sx, start_sy; + static int last_sx, last_sy; + static boolean typing = FALSE; + int letter_element = EL_CHAR_ASCII0 + letter; + int lx, ly; + + if (mode != TEXT_INIT) + { + if (!typing) + return; + + if (mode != TEXT_SETCURSOR) + { + sx = last_sx; + sy = last_sy; + } + + lx = last_sx + level_xpos; + ly = last_sy + level_ypos; + } + + switch (mode) + { + case TEXT_INIT: + if (typing) + DrawLevelText(0, 0, 0, TEXT_END); + + typing = TRUE; + start_sx = last_sx = sx; + start_sy = last_sy = sy; + DrawLevelText(sx, sy, 0, TEXT_SETCURSOR); + break; + + case TEXT_SETCURSOR: + DrawMiniElement(last_sx, last_sy, Feld[lx][ly]); + DrawAreaBorder(sx, sy, sx, sy); + last_sx = sx; + last_sy = sy; + break; + + case TEXT_WRITECHAR: + if (letter_element >= EL_CHAR_START && letter_element <= EL_CHAR_END) + { + delete_buffer[sx - start_sx] = Feld[lx][ly]; + Feld[lx][ly] = letter_element; + + if (sx + 1 < 2*SCR_FIELDX && lx + 1 < lev_fieldx) + DrawLevelText(sx + 1, sy, 0, TEXT_SETCURSOR); + else if (sy + 1 < 2*SCR_FIELDY && ly + 1 < lev_fieldy) + DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR); + else + DrawLevelText(0, 0, 0, TEXT_END); + } + break; + + case TEXT_BACKSPACE: + if (sx > start_sx) + { + Feld[lx - 1][ly] = delete_buffer[sx - start_sx - 1]; + DrawMiniElement(sx - 1, sy, new_element3); + DrawLevelText(sx - 1, sy, 0, TEXT_SETCURSOR); + } + break; + + case TEXT_NEWLINE: + if (sy + 1 < 2*SCR_FIELDY - 1 && ly + 1 < lev_fieldy - 1) + DrawLevelText(start_sx, sy + 1, 0, TEXT_SETCURSOR); + else + DrawLevelText(0, 0, 0, TEXT_END); + break; + + case TEXT_END: + CopyLevelToUndoBuffer(); + DrawMiniElement(sx, sy, Feld[lx][ly]); + typing = FALSE; + break; + + default: + break; + } +} + +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= SX + SXSIZE || my < SY || my >= SY + SYSIZE) + new_element = (button == 1 ? new_element1 : + button == 2 ? new_element2 : + button == 3 ? new_element3 : 0); + + if (random_placement_method == RANDOM_USE_PERCENTAGE) + { + 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); + CopyLevelToUndoBuffer(); +} + +static void HandleDrawingAreas(struct GadgetInfo *gi) +{ + static boolean started_inside_drawing_area = FALSE; + static boolean draw_with_brush = FALSE; + int id = gi->custom_id; + boolean inside_drawing_area = !gi->event.off_borders; + boolean button_press_event; + boolean button_release_event; + boolean draw_level = (id == ED_CTRL_ID_DRAWING_LEVEL); + 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); + + if (draw_level) + { + 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; + + lx = (lx < 0 ? 0 : lx > lev_fieldx - 1 ? lev_fieldx - 1 : lx); + ly = (ly < 0 ? 0 : ly > lev_fieldy - 1 ? lev_fieldy - 1 : ly); + sx = lx - level_xpos; + sy = ly - level_ypos; } + else + { + sx = (sx < 0 ? 0 : sx > 2 ? 2 : sx); + sy = (sy < 0 ? 0 : sy > 2 ? 2 : sy); + } + + if (button_press_event) + started_inside_drawing_area = inside_drawing_area; - if (button && !motion_status) - in_field_pressed = TRUE; - - if (!button || - !in_field_pressed || - button < 1 || button > 3 || - 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)) + if (!started_inside_drawing_area) + return; + + if (!button && !button_release_event) return; new_element = (button == 1 ? new_element1 : button == 2 ? new_element2 : button == 3 ? new_element3 : 0); + if (!draw_level && drawing_function != ED_CTRL_ID_SINGLE_ITEMS) + return; + switch (drawing_function) { case ED_CTRL_ID_SINGLE_ITEMS: - if (new_element != Feld[lx][ly]) + if (draw_level) { - if (new_element == EL_SPIELFIGUR) + if (button_release_event) + CopyLevelToUndoBuffer(); + + if (!button) + break; + + if (new_element != Feld[lx][ly]) { - /* 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); + if (Feld[x][y] == EL_SPIELFIGUR || Feld[x][y] == EL_SPIELER1) + { + Feld[x][y] = EL_LEERRAUM; + if (x - level_xpos >= 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); + Feld[lx][ly] = new_element; + DrawMiniElement(sx, sy, new_element); + } + } + else + { + DrawMiniGraphicExt(drawto, gc, + gi->x + sx * MINI_TILEX, + gi->y + sy * MINI_TILEY, + el2gfx(new_element)); + DrawMiniGraphicExt(window, gc, + gi->x + sx * MINI_TILEX, + gi->y + sy * MINI_TILEY, + el2gfx(new_element)); + + if (id == ED_CTRL_ID_AMOEBA_CONTENT) + level.amoebe_inhalt = new_element; + else if (id >= ED_CTRL_ID_ELEMCONT_0 && id <= ED_CTRL_ID_ELEMCONT_7) + level.mampfer_inhalt[id - ED_CTRL_ID_ELEMCONT_0][sx][sy] = + new_element; } break; case ED_CTRL_ID_CONNECTED_ITEMS: { - static int last_x = -1; - static int last_y = -1; + static int last_sx = -1; + static int last_sy = -1; + + if (button_release_event) + CopyLevelToUndoBuffer(); - if (last_x == -1) + if (button) { - Feld[lx][ly] = new_element; - DrawMiniElement(sx, sy, new_element); + if (!button_press_event) + DrawLine(last_sx, last_sy, sx, sy, new_element, TRUE); - last_x = sx; - last_y = sy; + last_sx = sx; + last_sy = sy; } - else if (last_x != sx || last_y != sy) - { - DrawLine(last_x, last_y, sx, sy, new_element); + } + break; - last_x = -1; - last_y = -1; + case ED_CTRL_ID_LINE: + case ED_CTRL_ID_RECTANGLE: + case ED_CTRL_ID_FILLED_BOX: + case ED_CTRL_ID_BRUSH: + { + 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 if (drawing_function == ED_CTRL_ID_FILLED_BOX) + draw_func = DrawFilledBox; + else + draw_func = SelectArea; + + if (button_press_event) + { + draw_func(sx, sy, sx, sy, new_element, FALSE); + start_sx = last_sx = sx; + start_sy = last_sy = sy; } + else if (button_release_event) + { + draw_func(start_sx, start_sy, sx, sy, new_element, TRUE); + if (drawing_function == ED_CTRL_ID_BRUSH) + { + CopyAreaToBrush(start_sx, start_sy, sx, sy); + draw_with_brush = TRUE; + } + else + 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; - /* - last_x = sx; - last_y = sy; - */ + case ED_CTRL_ID_TEXT: + if (button_press_event) + DrawLevelText(sx, sy, 0, TEXT_INIT); + 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; + } +} + +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; + + case ED_CTRL_ID_ELEMCONT_DOWN: + case ED_CTRL_ID_ELEMCONT_UP: + *gadget_areas_value += (id == ED_CTRL_ID_ELEMCONT_DOWN ? -step : step); + if (*gadget_areas_value < 1) + *gadget_areas_value = 1; + else if (*gadget_areas_value > MAX_ELEMCONT) + *gadget_areas_value = MAX_ELEMCONT; + + DrawCounterValueField(ED_COUNTER_ELEMCONT, *gadget_areas_value); + DrawElementContentAreas(); + 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 (edit_mode == ED_MODE_DRAWING && drawing_function == ED_CTRL_ID_TEXT) + DrawLevelText(0, 0, 0, TEXT_END); + + 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: - FloodFill(lx, ly, new_element); + 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: + properties_element = new_element; + DrawPropertiesWindow(); + edit_mode = ED_MODE_PROPERTIES; + break; + + case ED_CTRL_ID_RANDOM_PLACEMENT: + RandomPlacement(button); + 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; } } + +void HandleLevelEditorKeyInput(KeySym key) +{ + if (edit_mode == ED_MODE_DRAWING && drawing_function == ED_CTRL_ID_TEXT) + { + char *keyname = getKeyNameFromKeySym(key); + char letter = 0; + + if (strlen(keyname) == 1) + letter = keyname[0]; + else if (strcmp(keyname, "space") == 0) + letter = ' '; + else if (strcmp(keyname, "less") == 0) + letter = '<'; + else if (strcmp(keyname, "equal") == 0) + letter = '='; + else if (strcmp(keyname, "greater") == 0) + letter = '>'; + + /* map lower case letters to upper case */ + if (letter >= 'a' && letter <= 'z') + letter += (int)('A' - 'a'); + else if (letter == 'ä') + letter = 'Ä'; + else if (letter == 'ä') + letter = 'Ö'; + else if (letter == 'ä') + letter = 'Ü'; + + if (letter) + DrawLevelText(0, 0, letter, TEXT_WRITECHAR); + else if (key == XK_Delete || key == XK_BackSpace) + DrawLevelText(0, 0, 0, TEXT_BACKSPACE); + else if (key == XK_Return) + DrawLevelText(0, 0, 0, TEXT_NEWLINE); + } +}