// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// editor.c
// ============================================================================
// selectbox identifiers
GADGET_ID_TIME_OR_STEPS,
+ GADGET_ID_TIME_SCORE_BASE,
GADGET_ID_GAME_ENGINE_TYPE,
GADGET_ID_LEVELSET_SAVE_MODE,
GADGET_ID_WIND_DIRECTION,
GADGET_ID_SB_OBJECTS_NEEDED,
GADGET_ID_AUTO_EXIT_SOKOBAN,
GADGET_ID_SOLVED_BY_ONE_PLAYER,
+ GADGET_ID_FINISH_DIG_COLLECT,
GADGET_ID_CONTINUOUS_SNAPPING,
GADGET_ID_BLOCK_SNAP_FIELD,
GADGET_ID_BLOCK_LAST_FIELD,
enum
{
ED_SELECTBOX_ID_TIME_OR_STEPS,
+ ED_SELECTBOX_ID_TIME_SCORE_BASE,
ED_SELECTBOX_ID_GAME_ENGINE_TYPE,
ED_SELECTBOX_ID_LEVELSET_SAVE_MODE,
ED_SELECTBOX_ID_WIND_DIRECTION,
ED_CHECKBUTTON_ID_SB_OBJECTS_NEEDED,
ED_CHECKBUTTON_ID_AUTO_EXIT_SOKOBAN,
ED_CHECKBUTTON_ID_SOLVED_BY_ONE_PLAYER,
+ ED_CHECKBUTTON_ID_FINISH_DIG_COLLECT,
ED_CHECKBUTTON_ID_CONTINUOUS_SNAPPING,
ED_CHECKBUTTON_ID_BLOCK_SNAP_FIELD,
ED_CHECKBUTTON_ID_BLOCK_LAST_FIELD,
GADGET_ID_LEVEL_TIMESCORE_DOWN, GADGET_ID_LEVEL_TIMESCORE_UP,
GADGET_ID_LEVEL_TIMESCORE_TEXT, GADGET_ID_NONE,
&level.score[SC_TIME_BONUS],
- "score for each second/step left:", NULL, NULL
+ "score for time or steps left:", NULL, NULL
},
{
ED_LEVEL_SETTINGS_XPOS(0), ED_LEVEL_SETTINGS_YPOS(12),
{ -1, NULL }
};
+static struct ValueTextInfo options_time_score_base[] =
+{
+ { 1, "per second/step" },
+ { 10, "per 10 seconds/steps" },
+
+ { -1, NULL }
+};
+
static struct ValueTextInfo options_game_engine_type[] =
{
{ GAME_ENGINE_TYPE_RND, "Rocks'n'Diamonds" },
&level.use_step_counter,
NULL, NULL, "(0 => no limit)", "time or step limit"
},
+ {
+ -1, ED_LEVEL_SETTINGS_YPOS(10),
+ GADGET_ID_TIME_SCORE_BASE, GADGET_ID_LEVEL_TIMESCORE_UP,
+ -1,
+ options_time_score_base,
+ &level.time_score_base,
+ NULL, NULL, NULL, "time score for 1 or 10 seconds/steps"
+ },
{
ED_LEVEL_SETTINGS_XPOS(0), ED_LEVEL_SETTINGS_YPOS(11),
GADGET_ID_GAME_ENGINE_TYPE, GADGET_ID_NONE,
NULL, NULL,
"only one player must enter exit", "level solved by first player in exit"
},
+ {
+ ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(3),
+ GADGET_ID_FINISH_DIG_COLLECT, GADGET_ID_NONE,
+ &level.finish_dig_collect,
+ NULL, NULL,
+ "CE action on finished dig/collect", "only finished dig/collect triggers CE"
+ },
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(9),
GADGET_ID_CONTINUOUS_SNAPPING, GADGET_ID_NONE,
static boolean draw_with_brush = FALSE;
static int properties_element = 0;
-static short FieldBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
+static short TileBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY];
static short IntelliDrawBuffer[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
static int undo_buffer_position = 0;
EL_EMC_MAGIC_BALL,
EL_EMC_MAGIC_BALL_SWITCH,
- EL_SPRING,
- EL_EMC_SPRING_BUMPER,
-
EL_EMC_LENSES,
EL_EMC_MAGNIFIER,
- EL_EMPTY,
- EL_EMPTY,
+
+ EL_SPRING_LEFT,
+ EL_SPRING,
+ EL_SPRING_RIGHT,
+ EL_EMC_SPRING_BUMPER,
EL_BALLOON,
EL_YAMYAM_UP,
// find all elements used in current level
for (y = 0; y < lev_fieldy; y++)
for (x = 0; x < lev_fieldx; x++)
- if (Feld[x][y] < NUM_FILE_ELEMENTS) // should always be true
- element_found[Feld[x][y]] = TRUE;
+ if (Tile[x][y] < NUM_FILE_ELEMENTS) // should always be true
+ element_found[Tile[x][y]] = TRUE;
*num_elements = 0;
int element = (*editor_elements_info[i].element_list)[j];
if (element >= NUM_FILE_ELEMENTS)
- Error(ERR_WARN, "editor element %d is runtime element", element);
+ Warn("editor element %d is runtime element", element);
if (strEqual(getElementInfoText(element), INFOTEXT_UNKNOWN_ELEMENT))
- Error(ERR_WARN, "no element description text for element %d", element);
+ Warn("no element description text for element %d", element);
}
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
}
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
GDI_END);
if (gi == NULL)
- Error(ERR_EXIT, "cannot create gadget");
+ Fail("cannot create gadget");
level_editor_gadget[id] = gi;
right_gadget_border[id] =
num_editor_gadgets = NUM_EDITOR_GADGETS;
- // printf("::: allocating %d gadgets ...\n", num_editor_gadgets);
+ // Debug("editor", "allocating %d gadgets ...\n", num_editor_gadgets);
level_editor_gadget =
checked_calloc(num_editor_gadgets * sizeof(struct GadgetInfo *));
{
int i;
- // printf("::: freeing %d gadgets ...\n", num_editor_gadgets);
+ // Debug("editor", "freeing %d gadgets ...\n", num_editor_gadgets);
for (i = 0; i < num_editor_gadgets; i++)
{
for (y = 0; y < lev_fieldy; y++)
for (x = 0; x < lev_fieldx; x++)
- if (Feld[x][y] != level.field[x][y])
+ if (Tile[x][y] != level.field[x][y])
field_changed = TRUE;
return (level.changed || field_changed);
return TRUE;
}
- if (!Request("This level is read only! "
+ if (!Request("This level is read-only! "
"Save into personal level set?", REQ_ASK))
return FALSE;
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
- if (Feld[x][y] == element_from)
- Feld[x][y] = element_to;
+ if (Tile[x][y] == element_from)
+ Tile[x][y] = element_to;
}
static boolean CopyCustomElement(int element_old, int element_new,
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
if (getElementDescriptionFilename(i) == NULL && !IS_OBSOLETE(i))
- Error(ERR_WARN, "no element description file for element '%s'",
- EL_NAME(i));
+ Warn("no element description file for element '%s'", EL_NAME(i));
}
#endif
if (level_editor_test_game)
{
- CopyPlayfield(level.field, Feld);
- CopyPlayfield(FieldBackup, level.field);
+ CopyPlayfield(level.field, Tile);
+ CopyPlayfield(TileBackup, level.field);
level_editor_test_game = FALSE;
}
num_elements_in_level = 0;
for (y = 0; y < lev_fieldy; y++)
for (x = 0; x < lev_fieldx; x++)
- if (Feld[x][y] == properties_element)
+ if (Tile[x][y] == properties_element)
num_elements_in_level++;
percentage = num_elements_in_level * 100.0 / (lev_fieldx * lev_fieldy);
{ EL_EMC_LENSES, &level.lenses_score, TEXT_COLLECTING },
{ EL_EMC_MAGNIFIER, &level.magnify_score, TEXT_COLLECTING },
{ EL_SPRING, &level.slurp_score, TEXT_SLURPING },
+ { EL_SPRING_LEFT, &level.slurp_score, TEXT_SLURPING },
+ { EL_SPRING_RIGHT, &level.slurp_score, TEXT_SLURPING },
{ EL_EMC_LENSES, &level.lenses_time, TEXT_DURATION },
{ EL_EMC_MAGNIFIER, &level.magnify_time, TEXT_DURATION },
{ EL_MM_FUSE_ACTIVE, &level.mm_time_fuse, TEXT_DELAY_OFF },
{
for (y = 0; y < lev_fieldy; y++)
{
- int element = Feld[x][y];
+ int element = Tile[x][y];
switch (element)
{
// draw checkbutton gadgets
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_USE_INITIAL_INVENTORY);
+ MapCheckbuttonGadget(ED_CHECKBUTTON_ID_FINISH_DIG_COLLECT);
// draw counter gadgets
MapCounterButtons(ED_COUNTER_ID_INVENTORY_SIZE);
if (MAYBE_DONT_COLLIDE_WITH(properties_element))
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_DONT_COLLIDE_WITH);
- if (properties_element == EL_SPRING)
+ if (properties_element == EL_SPRING ||
+ properties_element == EL_SPRING_LEFT ||
+ properties_element == EL_SPRING_RIGHT)
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_USE_SPRING_BUG);
if (properties_element == EL_TIME_ORB_FULL)
{
int sx = x - level_xpos;
int sy = y - level_ypos;
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
int new_element = element;
unsigned int new_bitmask = (getDrawModeHiRes() ? (dx + 1) << (dy * 2) : 0x0f);
boolean draw_masked = FALSE;
IntelliDrawBuffer[x][y] = element;
if (change_level)
- Feld[x][y] = element;
+ Tile[x][y] = element;
if (IN_ED_FIELD(sx, sy))
{
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
- IntelliDrawBuffer[x][y] = Feld[x][y];
+ IntelliDrawBuffer[x][y] = Tile[x][y];
SetElementIntelliDraw(-1, -1, EL_UNDEFINED, FALSE, -1);
}
boolean change_level, int button)
{
if (element < 0)
- SetElementSimple(x, y, Feld[x][y], change_level);
+ SetElementSimple(x, y, Tile[x][y], change_level);
else if (GetKeyModState() & KMOD_Shift && !IS_MM_WALL_EDITOR(element))
SetElementIntelliDraw(x, y, element, change_level, button);
else
int ly = ly2 / 2;
int dx = lx2 % 2;
int dy = ly2 % 2;
- int element = Feld[lx][ly];
+ int element = Tile[lx][ly];
unsigned int bitmask = (dx + 1) << (dy * 2);
if (IS_MM_WALL(element))
for (y = 0; y < height; y++)
for (x = 0; x < width; x++)
- if ((draw_with_brush ? brush_buffer[x][y] : Feld[x][y]) > 999)
+ if ((draw_with_brush ? brush_buffer[x][y] : Tile[x][y]) > 999)
format = "%s%04d";
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
- int element = (draw_with_brush ? brush_buffer[x][y] : Feld[x][y]);
+ int element = (draw_with_brush ? brush_buffer[x][y] : Tile[x][y]);
char *prefix = (mode == CB_DUMP_BRUSH ||
mode == CB_BRUSH_TO_CLIPBOARD ? "`" : "ΒΈ");
mode == CB_BRUSH_TO_CLIPBOARD_SMALL)
SDL_SetClipboardText(text);
else
- printf("%s", text);
+ Print("%s", text); // print brush data to console and log file
return;
}
ptr++;
}
+ // remap some (historic, now obsolete) elements
+ element = getMappedElement(element);
+
if (element >= NUM_FILE_ELEMENTS)
element = EL_UNKNOWN;
for (x = 0; x < MAX_LEV_FIELDX; x++)
for (y = 0; y < MAX_LEV_FIELDY; y++)
- Feld[x][y] = brush_buffer[x][y];
+ Tile[x][y] = brush_buffer[x][y];
lev_fieldx = level.fieldx = brush_width;
lev_fieldy = level.fieldy = brush_height;
+ boolean use_em_engine = TRUE;
+ boolean use_sp_engine = TRUE;
+ boolean use_mm_engine = TRUE;
+
+ for (x = 0; x < MAX_LEV_FIELDX; x++)
+ {
+ for (y = 0; y < MAX_LEV_FIELDY; y++)
+ {
+ int element = Tile[x][y];
+
+ if (!IS_EM_ELEMENT(element) && !ELEM_IS_PLAYER(element))
+ use_em_engine = FALSE;
+
+ if (!IS_SP_ELEMENT(element))
+ use_sp_engine = FALSE;
+
+ if (!IS_MM_ELEMENT(element) && element != EL_EMPTY)
+ use_mm_engine = FALSE;
+ }
+ }
+
+ level.game_engine_type = (use_em_engine ? GAME_ENGINE_TYPE_EM :
+ use_sp_engine ? GAME_ENGINE_TYPE_SP :
+ use_mm_engine ? GAME_ENGINE_TYPE_MM :
+ GAME_ENGINE_TYPE_RND);
+
+ // update element selection list
+ ReinitializeElementList();
+ ModifyEditorElementList();
+
SetBorderElement();
DrawEditModeWindow();
{
for (x = 0; x < brush_width; x++)
{
- brush_buffer[x][y] = Feld[from_lx + x][from_ly + y];
+ brush_buffer[x][y] = Tile[from_lx + x][from_ly + y];
if (button != 1)
DrawBrushElement(from_x + x, from_y + y, new_element, TRUE);
static void FloodFill(int from_x, int from_y, int fill_element)
{
- FloodFillLevel(from_x, from_y, fill_element, Feld, lev_fieldx, lev_fieldy);
+ FloodFillLevel(from_x, from_y, fill_element, Tile, lev_fieldx, lev_fieldy);
}
static void FloodFillWall_MM(int from_sx2, int from_sy2, int fill_element)
int from_y = from_sy2 + 2 * level_ypos;
int max_fillx = lev_fieldx * 2;
int max_filly = lev_fieldy * 2;
- short FillFeld[max_fillx][max_filly];
+ short Fill[max_fillx][max_filly];
int x, y;
for (x = 0; x < max_fillx; x++)
for (y = 0; y < max_filly; y++)
- FillFeld[x][y] = getLevelElementHiRes(x, y);
+ Fill[x][y] = getLevelElementHiRes(x, y);
FloodFillLevelExt(from_x, from_y, fill_element, max_fillx, max_filly,
- FillFeld, max_fillx, max_filly);
+ Fill, max_fillx, max_filly);
for (x = 0; x < max_fillx; x++)
for (y = 0; y < max_filly; y++)
- if (FillFeld[x][y] == fill_element)
- SetLevelElementHiRes(x, y, FillFeld[x][y]);
+ if (Fill[x][y] == fill_element)
+ SetLevelElementHiRes(x, y, Fill[x][y]);
}
// values for DrawLevelText() modes
break;
case TEXT_SETCURSOR:
- DrawEditorElement(last_sx, last_sy, Feld[lx][ly]);
+ DrawEditorElement(last_sx, last_sy, Tile[lx][ly]);
DrawAreaBorder(sx, sy, sx, sy);
StartTextInput(SX + sx * ed_tilesize, SY + sy * ed_tilesize,
ed_tilesize, ed_tilesize);
new_element1 <= EL_STEEL_CHAR_END)
letter_element = letter_element - EL_CHAR_START + EL_STEEL_CHAR_START;
- delete_buffer[sx - start_sx] = Feld[lx][ly];
- Feld[lx][ly] = letter_element;
+ delete_buffer[sx - start_sx] = Tile[lx][ly];
+ Tile[lx][ly] = letter_element;
if (sx + 1 < ed_fieldx && lx + 1 < lev_fieldx)
DrawLevelText(sx + 1, sy, 0, TEXT_SETCURSOR);
case TEXT_BACKSPACE:
if (sx > start_sx)
{
- Feld[lx - 1][ly] = delete_buffer[sx - start_sx - 1];
- DrawEditorElement(sx - 1, sy, Feld[lx - 1][ly]);
+ Tile[lx - 1][ly] = delete_buffer[sx - start_sx - 1];
+ DrawEditorElement(sx - 1, sy, Tile[lx - 1][ly]);
DrawLevelText(sx - 1, sy, 0, TEXT_SETCURSOR);
}
break;
case TEXT_END:
CopyLevelToUndoBuffer(UNDO_IMMEDIATE);
- DrawEditorElement(sx, sy, Feld[lx][ly]);
+ DrawEditorElement(sx, sy, Tile[lx][ly]);
StopTextInput();
typing = FALSE;
break;
int ly = sy + level_ypos;
if (element == -1)
- DrawEditorElement(sx, sy, Feld[lx][ly]);
+ DrawEditorElement(sx, sy, Tile[lx][ly]);
else
DrawAreaBorder(sx, sy, sx, sy);
}
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
- UndoBuffer[undo_buffer_position][x][y] = Feld[x][y];
+ UndoBuffer[undo_buffer_position][x][y] = Tile[x][y];
// check if drawing operation forces change of border style
CheckLevelBorderElement(TRUE);
{
free_position[x][y] =
(random_placement_background_restricted ?
- Feld[x][y] == random_placement_background_element :
- Feld[x][y] != new_element);
+ Tile[x][y] == random_placement_background_element :
+ Tile[x][y] != new_element);
if (free_position[x][y])
num_free_positions++;
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
- FieldBackup[x][y] = Feld[x][y];
+ TileBackup[x][y] = Tile[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];
+ Tile[x][y] =
+ TileBackup[(x + wrap_dx) % lev_fieldx][(y + wrap_dy) % lev_fieldy];
DrawEditorLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
CopyLevelToUndoBuffer(UNDO_ACCUMULATE);
}
+static void DrawAreaElementHighlight(boolean highlighted)
+{
+ DrawEditorLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
+
+ if (!highlighted)
+ return;
+
+ int x, y;
+
+ for (x = 0; x < ed_fieldx; x++)
+ {
+ for (y = 0; y < ed_fieldy; y++)
+ {
+ int lx = x + level_xpos;
+ int ly = y + level_ypos;
+
+ if (!IN_LEV_FIELD(lx, ly))
+ continue;
+
+ if (Tile[lx][ly] != new_element1)
+ continue;
+
+ int sx = SX + x * ed_tilesize;
+ int sy = SY + y * ed_tilesize;
+ int from_sx = sx;
+ int from_sy = sy;
+ int to_sx = sx + ed_tilesize - 1;
+ int to_sy = sy + ed_tilesize - 1;
+
+ DrawSimpleWhiteLine(drawto, from_sx, from_sy, to_sx, from_sy);
+ DrawSimpleWhiteLine(drawto, to_sx, from_sy, to_sx, to_sy);
+ DrawSimpleWhiteLine(drawto, to_sx, to_sy, from_sx, to_sy);
+ DrawSimpleWhiteLine(drawto, from_sx, to_sy, from_sx, from_sy);
+ }
+ }
+}
+
static void CopyLevelTemplateToUserLevelSet(char *levelset_subdir)
{
char *template_filename_old = getLocalLevelTemplateFilename();
}
else if (!button_press_event)
{
- int old_element = (IN_LEV_FIELD(lx, ly) ? Feld[lx][ly] : EL_UNDEFINED);
+ int old_element = (IN_LEV_FIELD(lx, ly) ? Tile[lx][ly] : EL_UNDEFINED);
boolean hires_drawing = (level.game_engine_type == GAME_ENGINE_TYPE_MM &&
isHiresTileElement(old_element) &&
isHiresDrawElement(new_element));
{
for (x = 0; x < lev_fieldx; x++)
{
- int old_element = Feld[x][y];
+ int old_element = Tile[x][y];
if (ELEM_IS_PLAYER(old_element))
{
break;
case GADGET_ID_FLOOD_FILL:
- if (button_press_event && Feld[lx][ly] != new_element)
+ if (button_press_event && Tile[lx][ly] != new_element)
{
if (IS_MM_WALL_EDITOR(new_element))
FloodFillWall_MM(sx2, sy2, new_element);
ClickOnGadget(level_editor_gadget[last_drawing_function],
MB_LEFTBUTTON);
else if (draw_level)
- PickDrawingElement(button, Feld[lx][ly]);
+ PickDrawingElement(button, Tile[lx][ly]);
else
{
int pos = sx * drawingarea_info[type_id].area_ysize + sy;
boolean new_template = !fileExists(getLocalLevelTemplateFilename());
// backup original "level.field" (needed to track playfield changes)
- CopyPlayfield(level.field, FieldBackup);
+ CopyPlayfield(level.field, TileBackup);
// "SaveLevelTemplate()" uses "level.field", so copy editor playfield
- CopyPlayfield(Feld, level.field);
+ CopyPlayfield(Tile, level.field);
if (new_template ||
Request("Save this template and kill the old?", REQ_ASK))
Request("Template saved!", REQ_CONFIRM);
// restore original "level.field" (needed to track playfield changes)
- CopyPlayfield(FieldBackup, level.field);
+ CopyPlayfield(TileBackup, level.field);
}
else if (type_id == ED_TEXTBUTTON_ID_SAVE_LEVELSET)
{
if (levelset_save_mode == LEVELSET_SAVE_MODE_UPDATE &&
leveldir_current->readonly)
{
- Request("This level set is read only!", REQ_CONFIRM);
+ Request("This level set is read-only!", REQ_CONFIRM);
return;
}
}
else
{
- ChangeEditModeWindow(last_edit_mode);
+ ChangeEditModeWindow(ED_MODE_DRAWING);
ClickOnGadget(level_editor_gadget[last_level_drawing_function],
MB_LEFTBUTTON);
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
- Feld[x][y] = UndoBuffer[undo_buffer_position][x][y];
+ Tile[x][y] = UndoBuffer[undo_buffer_position][x][y];
// check if undo operation forces change of border style
CheckLevelBorderElement(FALSE);
}
else
{
- ChangeEditModeWindow(last_edit_mode);
+ ChangeEditModeWindow(ED_MODE_DRAWING);
}
break;
for (x = 0; x < MAX_LEV_FIELDX; x++)
for (y = 0; y < MAX_LEV_FIELDY; y++)
- Feld[x][y] = (button == 1 ? EL_EMPTY : new_element);
+ Tile[x][y] = (button == 1 ? EL_EMPTY : new_element);
CopyLevelToUndoBuffer(GADGET_ID_CLEAR);
SetAutomaticNumberOfGemsNeeded();
- CopyPlayfield(Feld, level.field);
+ CopyPlayfield(Tile, level.field);
SaveLevel(level_nr);
level.changed = FALSE;
if (LevelChanged())
level.game_version = GAME_VERSION_ACTUAL;
- CopyPlayfield(level.field, FieldBackup);
- CopyPlayfield(Feld, level.field);
+ CopyPlayfield(level.field, TileBackup);
+ CopyPlayfield(Tile, level.field);
CopyNativeLevel_RND_to_Native(&level);
}
#ifdef DEBUG
else if (gi->event.type == GD_EVENT_PRESSED)
- printf("default: HandleControlButtons: GD_EVENT_PRESSED(%d)\n", id);
+ Debug("editor", "default: HandleControlButtons: GD_EVENT_PRESSED(%d)", id);
else if (gi->event.type == GD_EVENT_RELEASED)
- printf("default: HandleControlButtons: GD_EVENT_RELEASED(%d)\n", id);
+ Debug("editor", "default: HandleControlButtons: GD_EVENT_RELEASED(%d)", id);
else if (gi->event.type == GD_EVENT_MOVING)
- printf("default: HandleControlButtons: GD_EVENT_MOVING(%d)\n", id);
+ Debug("editor", "default: HandleControlButtons: GD_EVENT_MOVING(%d)", id);
else
- printf("default: HandleControlButtons: ? (id == %d)\n", id);
+ Debug("editor", "default: HandleControlButtons: ? (id == %d)", id);
#endif
break;
}
ClickOnGadget(level_editor_gadget[i], button);
}
-void HandleLevelEditorIdle(void)
+static void HandleLevelEditorIdle_Properties(void)
{
int element_border = graphic_info[IMG_EDITOR_ELEMENT_BORDER].border_size;
int x = editor.settings.element_graphic.x + element_border;
unsigned int action_delay_value = GameFrameDelay;
int i;
- if (edit_mode != ED_MODE_PROPERTIES)
- return;
-
if (!DelayReached(&action_delay, action_delay_value))
return;
FrameCounter++; // increase animation frame counter
}
+static void HandleLevelEditorIdle_Drawing(void)
+{
+ static boolean last_highlighted = FALSE;
+ boolean highlighted = (GetKeyModState() & KMOD_Alt);
+
+ if (highlighted != last_highlighted)
+ {
+ DrawAreaElementHighlight(highlighted);
+
+ last_highlighted = highlighted;
+
+ redraw_mask |= REDRAW_FIELD;
+ }
+}
+
+void HandleLevelEditorIdle(void)
+{
+ if (edit_mode == ED_MODE_PROPERTIES)
+ HandleLevelEditorIdle_Properties();
+ else if (edit_mode == ED_MODE_DRAWING)
+ HandleLevelEditorIdle_Drawing();
+}
+
static void ClearEditorGadgetInfoText(void)
{
DrawBackground(INFOTEXT_XPOS, INFOTEXT_YPOS, INFOTEXT_XSIZE, INFOTEXT_YSIZE);
ABS(lx - start_lx) + 1, ABS(ly - start_ly) + 1);
}
else if (actual_drawing_function == GADGET_ID_PICK_ELEMENT)
- strncpy(infotext, getElementInfoText(Feld[lx][ly]), max_infotext_len);
+ strncpy(infotext, getElementInfoText(Tile[lx][ly]), max_infotext_len);
else
sprintf(infotext, "Level position: %d, %d", lx, ly);
}
projects / rocksndiamonds.git / blobdiff