+
+ 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 < ED_FIELDX && lx + 1 < lev_fieldx)
+ DrawLevelText(sx + 1, sy, 0, TEXT_SETCURSOR);
+ else if (sy + 1 < ED_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 < ED_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(UNDO_IMMEDIATE);
+ DrawMiniElement(sx, sy, Feld[lx][ly]);
+ typing = FALSE;
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void SetTextCursor(int unused_sx, int unused_sy, int sx, int sy,
+ int element, boolean change_level)
+{
+ int lx = sx + level_xpos;
+ int ly = sy + level_ypos;
+
+ if (element == -1)
+ DrawMiniElement(sx, sy, Feld[lx][ly]);
+ else
+ DrawAreaBorder(sx, sy, sx, sy);
+}
+
+static void CopyLevelToUndoBuffer(int mode)
+{
+ static boolean accumulated_undo = FALSE;
+ boolean new_undo_buffer_position = TRUE;
+ int x, y;
+
+ switch (mode)
+ {
+ case UNDO_IMMEDIATE:
+ accumulated_undo = FALSE;
+ break;
+
+ case UNDO_ACCUMULATE:
+ if (accumulated_undo)
+ new_undo_buffer_position = FALSE;
+ accumulated_undo = TRUE;
+ break;
+
+ default:
+ break;
+ }
+
+ if (new_undo_buffer_position)
+ {
+ /* new position in undo buffer ring */
+ 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<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ UndoBuffer[undo_buffer_position][x][y] = Feld[x][y];
+#if 0
+#ifdef DEBUG
+ printf("level saved to undo buffer\n");
+#endif
+#endif
+}
+
+static void RandomPlacement(int button)
+{
+ int new_element;
+ int x, y;
+
+ 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<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ if (RND(100) < random_placement_percentage)
+ Feld[x][y] = new_element;
+ }
+ else
+ {
+ int elements_left = random_placement_num_objects;
+
+ while (elements_left > 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(UNDO_IMMEDIATE);
+}
+
+void WrapLevel(int dx, int dy)
+{
+ int wrap_dx = lev_fieldx - dx;
+ int wrap_dy = lev_fieldy - dy;
+ int x, y;
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ FieldBackup[x][y] = Feld[x][y];
+
+ for(x=0; x<lev_fieldx; x++)
+ for(y=0; y<lev_fieldy; y++)
+ Feld[x][y] =
+ FieldBackup[(x + wrap_dx) % lev_fieldx][(y + wrap_dy) % lev_fieldy];
+
+ DrawMiniLevel(level_xpos, level_ypos);
+ CopyLevelToUndoBuffer(UNDO_ACCUMULATE);
+}
+
+static void HandleDrawingAreas(struct GadgetInfo *gi)
+{
+ static boolean started_inside_drawing_area = 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 min_sx = 0, min_sy = 0;
+ int max_sx = gi->drawing.area_xsize - 1, max_sy = gi->drawing.area_ysize - 1;
+ int lx, ly;
+ int min_lx = 0, min_ly = 0;
+ int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
+ int x, y;
+
+ /* handle info callback for each invocation of action callback */
+ gi->callback_info(gi);
+
+ /*
+ 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);
+
+ /* make sure to stay inside drawing area boundaries */
+ sx = (sx < min_sx ? min_sx : sx > max_sx ? max_sx : sx);
+ sy = (sy < min_sy ? min_sy : sy > max_sy ? max_sy : sy);
+
+ if (draw_level)
+ {
+ /* get positions inside level field */
+ lx = sx + level_xpos;
+ ly = sy + level_ypos;
+
+ /* make sure to stay inside level field boundaries */
+ lx = (lx < min_lx ? min_lx : lx > max_lx ? max_lx : lx);
+ ly = (ly < min_ly ? min_ly : ly > max_ly ? max_ly : ly);
+
+ /* correct drawing area positions accordingly */
+ sx = lx - level_xpos;
+ sy = ly - level_ypos;
+ }
+
+ if (button_press_event)
+ started_inside_drawing_area = inside_drawing_area;
+
+ 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 0
+ if (button_release_event)
+ button = 0;
+#endif
+
+
+ if (!draw_level && drawing_function != ED_CTRL_ID_SINGLE_ITEMS)
+ return;
+
+ switch (drawing_function)
+ {
+ case ED_CTRL_ID_SINGLE_ITEMS:
+ if (draw_level)
+ {
+ if (button_release_event)
+ {
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+
+ if (edit_mode == ED_MODE_DRAWING && draw_with_brush &&
+ !inside_drawing_area)
+ DeleteBrushFromCursor();
+ }
+
+ if (!button)
+ break;
+
+ if (draw_with_brush)
+ {
+ if (!button_release_event)
+ CopyBrushToLevel(sx, sy, button);
+ }
+ else if (new_element != Feld[lx][ly])
+ {
+ if (new_element == EL_SPIELFIGUR)
+ {
+ /* remove player at old position */
+ for(y=0; y<lev_fieldy; y++)
+ {
+ for(x=0; x<lev_fieldx; x++)
+ {
+ if (Feld[x][y] == EL_SPIELFIGUR || Feld[x][y] == EL_SPIELER1)
+ {
+ Feld[x][y] = EL_LEERRAUM;
+ if (x - level_xpos >= 0 && x - level_xpos < ED_FIELDX &&
+ y - level_ypos >= 0 && y - level_ypos < ED_FIELDY)
+ DrawMiniElement(x - level_xpos, y - level_ypos,
+ EL_LEERRAUM);
+ }
+ }
+ }
+ }
+
+ 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_ELEM_CONTENT_0 &&
+ id <= ED_CTRL_ID_ELEM_CONTENT_7)
+ level.mampfer_inhalt[id - ED_CTRL_ID_ELEM_CONTENT_0][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(UNDO_IMMEDIATE);
+
+ 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_ARC:
+ case ED_CTRL_ID_RECTANGLE:
+ case ED_CTRL_ID_FILLED_BOX:
+ case ED_CTRL_ID_GRAB_BRUSH:
+ case ED_CTRL_ID_TEXT:
+ {
+ 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_ARC)
+ draw_func = DrawArc;
+ else if (drawing_function == ED_CTRL_ID_RECTANGLE)
+ draw_func = DrawRectangle;
+ else if (drawing_function == ED_CTRL_ID_FILLED_BOX)
+ draw_func = DrawFilledBox;
+ else if (drawing_function == ED_CTRL_ID_GRAB_BRUSH)
+ draw_func = SelectArea;
+ else /* (drawing_function == ED_CTRL_ID_TEXT) */
+ draw_func = SetTextCursor;
+
+ if (button_press_event)
+ {
+ draw_func(sx, sy, sx, sy, new_element, FALSE);
+ start_sx = last_sx = sx;
+ start_sy = last_sy = sy;
+
+ if (drawing_function == ED_CTRL_ID_TEXT)
+ DrawLevelText(0, 0, 0, TEXT_END);
+ }
+ else if (button_release_event)
+ {
+ draw_func(start_sx, start_sy, sx, sy, new_element, TRUE);
+ if (drawing_function == ED_CTRL_ID_GRAB_BRUSH)
+ {
+ CopyAreaToBrush(start_sx, start_sy, sx, sy, button);
+ CopyBrushToCursor(sx, sy);
+ ClickOnGadget(level_editor_gadget[ED_CTRL_ID_SINGLE_ITEMS]);
+ draw_with_brush = TRUE;
+ }
+ else if (drawing_function == ED_CTRL_ID_TEXT)
+ DrawLevelText(sx, sy, 0, TEXT_INIT);
+ else
+ CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
+ }
+ 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;
+
+
+
+#if 0
+ case ED_CTRL_ID_TEXT:
+ /*
+ DrawMiniElement(last_sx, last_sy, Feld[lx][ly]);
+ DrawAreaBorder(sx, sy, sx, sy);
+ last_sx = sx;
+ last_sy = sy;
+ */
+
+ if (button_press_event)
+ DrawLevelText(sx, sy, 0, TEXT_INIT);
+ break;
+#endif
+
+
+
+ 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(UNDO_IMMEDIATE);
+ }
+ break;
+
+ case ED_CTRL_ID_PICK_ELEMENT:
+ if (button_press_event)
+ PickDrawingElement(button, Feld[lx][ly]);
+ if (button_release_event)
+ ClickOnGadget(level_editor_gadget[last_drawing_function]);
+ 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_ELEM_SCORE_DOWN:
+ case ED_CTRL_ID_ELEM_SCORE_UP:
+ step *= (id == ED_CTRL_ID_ELEM_SCORE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_ELEM_SCORE,
+ *gadget_elem_score_value + step);
+ break;
+ case ED_CTRL_ID_ELEM_SCORE_TEXT:
+ *gadget_elem_score_value = gi->text.number_value;
+ break;
+
+ case ED_CTRL_ID_ELEM_CONTENT_DOWN:
+ case ED_CTRL_ID_ELEM_CONTENT_UP:
+ step *= (id == ED_CTRL_ID_ELEM_CONTENT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_ELEM_CONTENT,
+ *gadget_elem_content_value + step);
+ DrawElementContentAreas();
+ break;
+ case ED_CTRL_ID_ELEM_CONTENT_TEXT:
+ *gadget_elem_content_value = gi->text.number_value;
+ DrawElementContentAreas();
+ break;
+
+ case ED_CTRL_ID_LEVEL_XSIZE_DOWN:
+ case ED_CTRL_ID_LEVEL_XSIZE_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_XSIZE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_XSIZE,
+ *gadget_level_xsize_value + step);
+ level.fieldx = lev_fieldx;
+ break;
+ case ED_CTRL_ID_LEVEL_XSIZE_TEXT:
+ *gadget_level_xsize_value = gi->text.number_value;
+ level.fieldx = lev_fieldx;
+ break;
+
+ case ED_CTRL_ID_LEVEL_YSIZE_DOWN:
+ case ED_CTRL_ID_LEVEL_YSIZE_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_YSIZE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_YSIZE,
+ *gadget_level_ysize_value + step);
+ level.fieldy = lev_fieldy;
+ break;
+ case ED_CTRL_ID_LEVEL_YSIZE_TEXT:
+ *gadget_level_ysize_value = gi->text.number_value;
+ level.fieldy = lev_fieldy;
+ break;
+
+ case ED_CTRL_ID_LEVEL_RANDOM_DOWN:
+ case ED_CTRL_ID_LEVEL_RANDOM_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_RANDOM_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_RANDOM,
+ *gadget_level_random_value + step);
+ break;
+ case ED_CTRL_ID_LEVEL_RANDOM_TEXT:
+ *gadget_level_random_value = gi->text.number_value;
+ break;
+
+ case ED_CTRL_ID_LEVEL_COLLECT_DOWN:
+ case ED_CTRL_ID_LEVEL_COLLECT_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_COLLECT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_COLLECT,
+ *gadget_level_collect_value + step);
+ break;
+ case ED_CTRL_ID_LEVEL_COLLECT_TEXT:
+ *gadget_level_collect_value = gi->text.number_value;
+ break;
+
+ case ED_CTRL_ID_LEVEL_TIMELIMIT_DOWN:
+ case ED_CTRL_ID_LEVEL_TIMELIMIT_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_TIMELIMIT_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMELIMIT,
+ *gadget_level_timelimit_value + step);
+ break;
+ case ED_CTRL_ID_LEVEL_TIMELIMIT_TEXT:
+ *gadget_level_timelimit_value = gi->text.number_value;
+ break;
+
+ case ED_CTRL_ID_LEVEL_TIMESCORE_DOWN:
+ case ED_CTRL_ID_LEVEL_TIMESCORE_UP:
+ step *= (id == ED_CTRL_ID_LEVEL_TIMESCORE_DOWN ? -1 : 1);
+ ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMESCORE,
+ *gadget_level_timescore_value + step);
+ break;
+ case ED_CTRL_ID_LEVEL_TIMESCORE_TEXT:
+ *gadget_level_timescore_value = gi->text.number_value;
+ break;
+
+ default:
+ break;