#define MIN_SCORE 0
#define MAX_SCORE 255
-/* values for elements with content */
-#define MIN_ELEM_CONTENT 1
-#define MAX_ELEM_CONTENT 8
-
/* values for the control window */
#define ED_CTRL_BUTTONS_GFX_YPOS 236
#define ED_CTRL_BUTTONS_ALT_GFX_YPOS 142
{ 'E', "exit level editor" }
};
-/* pointers to counter values */
-static int *gadget_elem_score_value = NULL;
-static int *gadget_elem_content_value = NULL;
-static int *gadget_level_xsize_value = NULL;
-static int *gadget_level_ysize_value = NULL;
-static int *gadget_level_random_value = NULL;
-static int *gadget_level_collect_value = NULL;
-static int *gadget_level_timelimit_value = NULL;
-static int *gadget_level_timescore_value = NULL;
+/* values for random placement */
+#define RANDOM_USE_PERCENTAGE 0
+#define RANDOM_USE_QUANTITY 1
+
+static int random_placement_value = 10;
+static int random_placement_method = RANDOM_USE_QUANTITY;
+static int random_placement_background_element = EL_ERDREICH;
+static boolean random_placement_background_restricted = FALSE;
+static boolean stick_element_properties_window = FALSE;
static struct
{
int min_value, max_value;
int gadget_id_down, gadget_id_up;
int gadget_id_text;
- int **counter_value;
+ int *value;
char *infotext_above, *infotext_right;
} counterbutton_info[ED_NUM_COUNTERBUTTONS] =
{
MIN_SCORE, MAX_SCORE,
GADGET_ID_ELEM_SCORE_DOWN, GADGET_ID_ELEM_SCORE_UP,
GADGET_ID_ELEM_SCORE_TEXT,
- &gadget_elem_score_value,
+ NULL, /* will be set when used */
"element score", NULL
},
{
ED_COUNT_ELEM_CONTENT_XPOS, ED_COUNT_ELEM_CONTENT_YPOS,
- MIN_ELEM_CONTENT, MAX_ELEM_CONTENT,
+ MIN_ELEMENT_CONTENTS, MAX_ELEMENT_CONTENTS,
GADGET_ID_ELEM_CONTENT_DOWN, GADGET_ID_ELEM_CONTENT_UP,
GADGET_ID_ELEM_CONTENT_TEXT,
- &gadget_elem_content_value,
+ &level.num_yam_contents,
"element content", NULL
},
{
MIN_LEV_FIELDX, MAX_LEV_FIELDX,
GADGET_ID_LEVEL_XSIZE_DOWN, GADGET_ID_LEVEL_XSIZE_UP,
GADGET_ID_LEVEL_XSIZE_TEXT,
- &gadget_level_xsize_value,
+ &level.fieldx,
"playfield size", "width",
},
{
MIN_LEV_FIELDY, MAX_LEV_FIELDY,
GADGET_ID_LEVEL_YSIZE_DOWN, GADGET_ID_LEVEL_YSIZE_UP,
GADGET_ID_LEVEL_YSIZE_TEXT,
- &gadget_level_ysize_value,
+ &level.fieldy,
NULL, "height",
},
{
0, 999,
GADGET_ID_LEVEL_COLLECT_DOWN, GADGET_ID_LEVEL_COLLECT_UP,
GADGET_ID_LEVEL_COLLECT_TEXT,
- &gadget_level_collect_value,
+ &level.gems_needed,
"number of emeralds to collect", NULL
},
{
0, 999,
GADGET_ID_LEVEL_TIMELIMIT_DOWN, GADGET_ID_LEVEL_TIMELIMIT_UP,
GADGET_ID_LEVEL_TIMELIMIT_TEXT,
- &gadget_level_timelimit_value,
+ &level.time,
"time available to solve level", "(0 => no time limit)"
},
{
0, 255,
GADGET_ID_LEVEL_TIMESCORE_DOWN, GADGET_ID_LEVEL_TIMESCORE_UP,
GADGET_ID_LEVEL_TIMESCORE_TEXT,
- &gadget_level_timescore_value,
+ &level.score[SC_ZEITBONUS],
"score for each 10 seconds left", NULL
},
{
1, 100,
GADGET_ID_LEVEL_RANDOM_DOWN, GADGET_ID_LEVEL_RANDOM_UP,
GADGET_ID_LEVEL_RANDOM_TEXT,
- &gadget_level_random_value,
+ &random_placement_value,
"random element placement", "in"
}
};
}
};
-/* values for random placement */
-#define RANDOM_USE_PERCENTAGE 0
-#define RANDOM_USE_QUANTITY 1
-
-static int random_placement_value = 10;
-static int random_placement_method = RANDOM_USE_QUANTITY;
-static int random_placement_background_element = EL_ERDREICH;
-static boolean random_placement_background_restricted = FALSE;
-static boolean stick_element_properties_window = FALSE;
-
static struct
{
int x, y;
#define BUTTON_ELEMENT(button) (button == 1 ? new_element1 : \
button == 2 ? new_element2 : \
button == 3 ? new_element3 : EL_LEERRAUM)
+#define BUTTON_STEPSIZE(button) (button == 1 ? 1 : button == 2 ? 5 : 10)
/* forward declaration for internal use */
static void DrawDrawingWindow();
static void DrawLevelInfoWindow();
static void DrawPropertiesWindow();
static void CopyLevelToUndoBuffer(int);
-static void HandleControlButtons(struct GadgetInfo *);
-static void HandleCounterButtons(struct GadgetInfo *);
static void HandleDrawingAreas(struct GadgetInfo *);
-static void HandleDrawingAreaInfo(struct GadgetInfo *);
+static void HandleCounterButtons(struct GadgetInfo *);
static void HandleTextInputGadgets(struct GadgetInfo *);
+static void HandleRadiobuttons(struct GadgetInfo *);
+static void HandleCheckbuttons(struct GadgetInfo *);
+static void HandleControlButtons(struct GadgetInfo *);
+static void HandleDrawingAreaInfo(struct GadgetInfo *);
static struct GadgetInfo *level_editor_gadget[NUM_EDITOR_GADGETS];
static boolean draw_with_brush = FALSE;
static int properties_element = 0;
-static short ElementContent[MAX_ELEM_CONTENT][3][3];
+static short ElementContent[MAX_ELEMENT_CONTENTS][3][3];
static short FieldBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY];
static int undo_buffer_position = 0;
gd_y2 = DOOR_GFX_PAGEY1 + ED_CTRL_BUTTONS_ALT_GFX_YPOS + gd_yoffset;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, control_info[i].text,
GDI_X, EX + gd_xoffset,
GDI_Y, EY + gd_yoffset,
gd_y1 = DOOR_GFX_PAGEY1 + scrollbutton_info[i].ypos;
gd_x2 = gd_x1 - ED_SCROLLBUTTON_XSIZE;
gd_y2 = gd_y1;
- }
+ }
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, scrollbutton_info[i].infotext,
GDI_X, x,
GDI_Y, y,
deco_ypos = (ED_ELEMENTLIST_YSIZE - MINI_TILEY) / 2;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, element_info[editor_element[i]],
GDI_X, DX + gd_xoffset,
GDI_Y, DY + gd_yoffset,
(j == 0 ? "decrease" : "increase"));
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, infotext,
GDI_X, xpos,
GDI_Y, ypos,
gd_y = DOOR_GFX_PAGEY1 + ED_WIN_COUNT_YPOS;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, "enter counter value",
GDI_X, xpos,
GDI_Y, ypos,
level_editor_gadget[id] = gi;
/* ... up to eight areas for element content ... */
- for (i=0; i<MAX_ELEM_CONTENT; i++)
+ for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
{
int gx = SX + ED_AREA_ELEM_CONTENT_XPOS + 5 * (i % 4) * MINI_TILEX;
int gy = SX + ED_AREA_ELEM_CONTENT_YPOS + 6 * (i / 4) * MINI_TILEY;
id = GADGET_ID_ELEM_CONTENT_0 + i;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_X, gx,
GDI_Y, gy,
GDI_WIDTH, 3 * MINI_TILEX,
infotext[MAX_INFOTEXT_LEN] = '\0';
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, infotext,
GDI_X, SX + textinput_info[i].x,
GDI_Y, SY + textinput_info[i].y,
gd_y2 = DOOR_GFX_PAGEY1 + scrollbar_info[i].ypos;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, scrollbar_info[i].infotext,
GDI_X, SX + scrollbar_info[i].x,
GDI_Y, SY + scrollbar_info[i].y,
(*radiobutton_info[i].value == radiobutton_info[i].checked_value);
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, radiobutton_info[i].infotext,
GDI_X, SX + radiobutton_info[i].x,
GDI_Y, SY + radiobutton_info[i].y,
GDI_ALT_DESIGN_UNPRESSED, gd_pixmap, gd_x3, gd_y,
GDI_ALT_DESIGN_PRESSED, gd_pixmap, gd_x4, gd_y,
GDI_EVENT_MASK, event_mask,
- GDI_CALLBACK_ACTION, HandleControlButtons,
+ GDI_CALLBACK_ACTION, HandleRadiobuttons,
GDI_END);
if (gi == NULL)
gd_y = DOOR_GFX_PAGEY1 + ED_CHECKBUTTON_YPOS;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_CUSTOM_TYPE_ID, i,
GDI_INFO_TEXT, checkbutton_info[i].infotext,
GDI_X, SX + checkbutton_info[i].x,
GDI_Y, SY + checkbutton_info[i].y,
GDI_ALT_DESIGN_UNPRESSED, gd_pixmap, gd_x3, gd_y,
GDI_ALT_DESIGN_PRESSED, gd_pixmap, gd_x4, gd_y,
GDI_EVENT_MASK, event_mask,
- GDI_CALLBACK_ACTION, HandleControlButtons,
+ GDI_CALLBACK_ACTION, HandleCheckbuttons,
GDI_END);
if (gi == NULL)
static void ModifyEditorCounter(int counter_id, int new_value)
{
- int *counter_value = *counterbutton_info[counter_id].counter_value;
+ int *counter_value = counterbutton_info[counter_id].value;
int gadget_id = counterbutton_info[counter_id].gadget_id_text;
struct GadgetInfo *gi = level_editor_gadget[gadget_id];
DrawText(SX + ED_SETTINGS2_XPOS, SY + ED_SETTINGS2_YPOS,
"Editor Settings", FS_BIG, FC_YELLOW);
- gadget_level_xsize_value = &lev_fieldx;
- gadget_level_ysize_value = &lev_fieldy;
- gadget_level_random_value = &random_placement_value;
- gadget_level_collect_value = &level.edelsteine;
- gadget_level_timelimit_value = &level.time;
- gadget_level_timescore_value = &level.score[10];
-
/* draw counter gadgets */
for (i=ED_COUNTER_ID_LEVEL_FIRST; i<=ED_COUNTER_ID_LEVEL_LAST; i++)
{
DrawTextF(x, y, font_color, infotext);
}
- ModifyEditorCounter(i, **counterbutton_info[i].counter_value);
+ ModifyEditorCounter(i, *counterbutton_info[i].value);
MapCounterButtons(i);
}
int font_color = FC_GREEN;
int x, y;
- ElementContent[0][0][0] = level.amoebe_inhalt;
+ ElementContent[0][0][0] = level.amoeba_content;
/* draw decorative border for the object */
for (y=0; y<2; y++)
static void DrawElementContentAreas()
{
- int *num_areas = &MampferMax;
+ int counter_id = ED_COUNTER_ID_ELEM_CONTENT;
int area_x = ED_AREA_ELEM_CONTENT_XPOS / MINI_TILEX;
int area_y = ED_AREA_ELEM_CONTENT_YPOS / MINI_TILEY;
int area_sx = SX + ED_AREA_ELEM_CONTENT_XPOS;
int font_color = FC_GREEN;
int i, x, y;
- for (i=0; i<MAX_ELEM_CONTENT; i++)
+ for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
for (y=0; y<3; y++)
for (x=0; x<3; x++)
- ElementContent[i][x][y] = level.mampfer_inhalt[i][x][y];
+ ElementContent[i][x][y] = level.yam_content[i][x][y];
- for (i=0; i<MAX_ELEM_CONTENT; i++)
+ for (i=0; i<MAX_ELEMENT_CONTENTS; i++)
UnmapDrawingArea(GADGET_ID_ELEM_CONTENT_0 + i);
/* display counter to choose number of element content areas */
- gadget_elem_content_value = num_areas;
-
- x = counterbutton_info[ED_COUNTER_ID_ELEM_CONTENT].x + xoffset_right;
- y = counterbutton_info[ED_COUNTER_ID_ELEM_CONTENT].y + yoffset_right;
+ x = counterbutton_info[counter_id].x + xoffset_right;
+ y = counterbutton_info[counter_id].y + yoffset_right;
DrawTextF(x, y, font_color, "number of content areas");
- ModifyEditorCounter(ED_COUNTER_ID_ELEM_CONTENT, *gadget_elem_content_value);
- MapCounterButtons(ED_COUNTER_ID_ELEM_CONTENT);
+
+ ModifyEditorCounter(counter_id, *counterbutton_info[counter_id].value);
+ MapCounterButtons(counter_id);
/* delete content areas in case of reducing number of them */
XFillRectangle(display, backbuffer, gc,
SXSIZE, 12 * MINI_TILEY);
/* draw some decorative border for the objects */
- for (i=0; i<*num_areas; i++)
+ for (i=0; i<level.num_yam_contents; i++)
{
for (y=0; y<4; y++)
for (x=0; x<4; x++)
DrawText(area_sx + (5 * 4 - 1) * MINI_TILEX, area_sy + 2 * MINI_TILEY + 1,
"smashed", FS_SMALL, font_color);
- for (i=0; i<*num_areas; i++)
+ for (i=0; i<level.num_yam_contents; i++)
{
for (y=0; y<3; y++)
for (x=0; x<3; x++)
font_color, "%d", i + 1);
}
- for (i=0; i<*num_areas; i++)
+ for (i=0; i<level.num_yam_contents; i++)
MapDrawingArea(GADGET_ID_ELEM_CONTENT_0 + i);
}
static void DrawPropertiesWindow()
{
+ int counter_id = ED_COUNTER_ID_ELEM_SCORE;
int num_elements_in_level;
float percentage;
int xoffset_right = counter_xsize;
static struct
{
int element;
- int *counter_value;
+ int *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_EM_KEY_1_FILE, &level.score[9], TEXT_COLLECTING },
- { EL_EM_KEY_2_FILE, &level.score[9], TEXT_COLLECTING },
- { EL_EM_KEY_3_FILE, &level.score[9], TEXT_COLLECTING },
- { EL_EM_KEY_4_FILE, &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 },
+ { EL_EDELSTEIN, &level.score[SC_EDELSTEIN], TEXT_COLLECTING },
+ { EL_EDELSTEIN_BD, &level.score[SC_EDELSTEIN], TEXT_COLLECTING },
+ { EL_EDELSTEIN_GELB,&level.score[SC_EDELSTEIN], TEXT_COLLECTING },
+ { EL_EDELSTEIN_ROT, &level.score[SC_EDELSTEIN], TEXT_COLLECTING },
+ { EL_EDELSTEIN_LILA,&level.score[SC_EDELSTEIN], TEXT_COLLECTING },
+ { EL_DIAMANT, &level.score[SC_DIAMANT], TEXT_COLLECTING },
+ { EL_KAEFER_R, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_KAEFER_O, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_KAEFER_L, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_KAEFER_U, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_BUTTERFLY_R, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_BUTTERFLY_O, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_BUTTERFLY_L, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_BUTTERFLY_U, &level.score[SC_KAEFER], TEXT_SMASHING },
+ { EL_FLIEGER_R, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FLIEGER_O, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FLIEGER_L, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FLIEGER_U, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FIREFLY_R, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FIREFLY_O, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FIREFLY_L, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_FIREFLY_U, &level.score[SC_FLIEGER], TEXT_SMASHING },
+ { EL_MAMPFER, &level.score[SC_MAMPFER], TEXT_SMASHING },
+ { EL_MAMPFER2, &level.score[SC_MAMPFER], TEXT_SMASHING },
+ { EL_ROBOT, &level.score[SC_ROBOT], TEXT_SMASHING },
+ { EL_PACMAN_R, &level.score[SC_PACMAN], TEXT_SMASHING },
+ { EL_PACMAN_O, &level.score[SC_PACMAN], TEXT_SMASHING },
+ { EL_PACMAN_L, &level.score[SC_PACMAN], TEXT_SMASHING },
+ { EL_PACMAN_U, &level.score[SC_PACMAN], TEXT_SMASHING },
+ { EL_KOKOSNUSS, &level.score[SC_KOKOSNUSS], TEXT_CRACKING },
+ { EL_DYNAMIT_AUS, &level.score[SC_DYNAMIT], TEXT_COLLECTING },
+ { EL_SCHLUESSEL1, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_SCHLUESSEL2, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_SCHLUESSEL3, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_SCHLUESSEL4, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_EM_KEY_1_FILE, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_EM_KEY_2_FILE, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_EM_KEY_3_FILE, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_EM_KEY_4_FILE, &level.score[SC_SCHLUESSEL], TEXT_COLLECTING },
+ { EL_AMOEBE_NASS, &level.amoeba_speed, TEXT_SPEED },
+ { EL_AMOEBE_NORM, &level.amoeba_speed, TEXT_SPEED },
+ { EL_AMOEBE_VOLL, &level.amoeba_speed, TEXT_SPEED },
+ { EL_AMOEBE_BD, &level.amoeba_speed, TEXT_SPEED },
+ { EL_SIEB_INAKTIV, &level.time_magic_wall, TEXT_DURATION },
+ { EL_ABLENK_AUS, &level.time_wheel, TEXT_DURATION },
{ -1, NULL, NULL }
};
{
if (elements_with_counter[i].element == properties_element)
{
- int x = counterbutton_info[ED_COUNTER_ID_ELEM_SCORE].x + xoffset_right;
- int y = counterbutton_info[ED_COUNTER_ID_ELEM_SCORE].y + yoffset_right;
-
- gadget_elem_score_value = elements_with_counter[i].counter_value;
+ int x = counterbutton_info[counter_id].x + xoffset_right;
+ int y = counterbutton_info[counter_id].y + yoffset_right;
+ counterbutton_info[counter_id].value = elements_with_counter[i].value;
DrawTextF(x, y, font_color, elements_with_counter[i].text);
- ModifyEditorCounter(ED_COUNTER_ID_ELEM_SCORE, *gadget_elem_score_value);
- MapCounterButtons(ED_COUNTER_ID_ELEM_SCORE);
+
+ ModifyEditorCounter(counter_id, *counterbutton_info[counter_id].value);
+ MapCounterButtons(counter_id);
break;
}
}
el2gfx(new_element));
if (id == GADGET_ID_AMOEBA_CONTENT)
- level.amoebe_inhalt = new_element;
+ level.amoeba_content = new_element;
else if (id == GADGET_ID_RANDOM_BACKGROUND)
random_placement_background_element = new_element;
else if (id >= GADGET_ID_ELEM_CONTENT_0 &&
id <= GADGET_ID_ELEM_CONTENT_7)
- level.mampfer_inhalt[id - GADGET_ID_ELEM_CONTENT_0][sx][sy] =
+ level.yam_content[id - GADGET_ID_ELEM_CONTENT_0][sx][sy] =
new_element;
}
break;
static void HandleCounterButtons(struct GadgetInfo *gi)
{
- int id = gi->custom_id;
+ int gadget_id = gi->custom_id;
+ int counter_id = gi->custom_type_id;
int button = gi->event.button;
- int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
-
- switch (id)
- {
- case GADGET_ID_ELEM_SCORE_DOWN:
- case GADGET_ID_ELEM_SCORE_UP:
- step *= (id == GADGET_ID_ELEM_SCORE_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_ELEM_SCORE,
- *gadget_elem_score_value + step);
- break;
- case GADGET_ID_ELEM_SCORE_TEXT:
- *gadget_elem_score_value = gi->text.number_value;
- break;
-
- case GADGET_ID_ELEM_CONTENT_DOWN:
- case GADGET_ID_ELEM_CONTENT_UP:
- step *= (id == GADGET_ID_ELEM_CONTENT_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_ELEM_CONTENT,
- *gadget_elem_content_value + step);
- DrawElementContentAreas();
- break;
- case GADGET_ID_ELEM_CONTENT_TEXT:
- *gadget_elem_content_value = gi->text.number_value;
- DrawElementContentAreas();
- break;
-
- case GADGET_ID_LEVEL_XSIZE_DOWN:
- case GADGET_ID_LEVEL_XSIZE_UP:
- step *= (id == GADGET_ID_LEVEL_XSIZE_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_XSIZE,
- *gadget_level_xsize_value + step);
- level.fieldx = lev_fieldx;
- break;
- case GADGET_ID_LEVEL_XSIZE_TEXT:
- *gadget_level_xsize_value = gi->text.number_value;
- level.fieldx = lev_fieldx;
- break;
-
- case GADGET_ID_LEVEL_YSIZE_DOWN:
- case GADGET_ID_LEVEL_YSIZE_UP:
- step *= (id == GADGET_ID_LEVEL_YSIZE_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_YSIZE,
- *gadget_level_ysize_value + step);
- level.fieldy = lev_fieldy;
- break;
- case GADGET_ID_LEVEL_YSIZE_TEXT:
- *gadget_level_ysize_value = gi->text.number_value;
- level.fieldy = lev_fieldy;
- break;
-
- case GADGET_ID_LEVEL_RANDOM_DOWN:
- case GADGET_ID_LEVEL_RANDOM_UP:
- step *= (id == GADGET_ID_LEVEL_RANDOM_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_RANDOM,
- *gadget_level_random_value + step);
- break;
- case GADGET_ID_LEVEL_RANDOM_TEXT:
- *gadget_level_random_value = gi->text.number_value;
- break;
-
- case GADGET_ID_LEVEL_COLLECT_DOWN:
- case GADGET_ID_LEVEL_COLLECT_UP:
- step *= (id == GADGET_ID_LEVEL_COLLECT_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_COLLECT,
- *gadget_level_collect_value + step);
- break;
- case GADGET_ID_LEVEL_COLLECT_TEXT:
- *gadget_level_collect_value = gi->text.number_value;
- break;
-
- case GADGET_ID_LEVEL_TIMELIMIT_DOWN:
- case GADGET_ID_LEVEL_TIMELIMIT_UP:
- step *= (id == GADGET_ID_LEVEL_TIMELIMIT_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMELIMIT,
- *gadget_level_timelimit_value + step);
- break;
- case GADGET_ID_LEVEL_TIMELIMIT_TEXT:
- *gadget_level_timelimit_value = gi->text.number_value;
- break;
-
- case GADGET_ID_LEVEL_TIMESCORE_DOWN:
- case GADGET_ID_LEVEL_TIMESCORE_UP:
- step *= (id == GADGET_ID_LEVEL_TIMESCORE_DOWN ? -1 : 1);
- ModifyEditorCounter(ED_COUNTER_ID_LEVEL_TIMESCORE,
- *gadget_level_timescore_value + step);
- break;
- case GADGET_ID_LEVEL_TIMESCORE_TEXT:
- *gadget_level_timescore_value = gi->text.number_value;
- break;
+ int *counter_value = counterbutton_info[counter_id].value;
+ int step = BUTTON_STEPSIZE(button) *
+ (gadget_id == counterbutton_info[counter_id].gadget_id_down ? -1 : +1);
- default:
- break;
- }
+ if (gadget_id == counterbutton_info[counter_id].gadget_id_text)
+ *counter_value = gi->text.number_value;
+ else
+ ModifyEditorCounter(counter_id, *counter_value + step);
+
+ if (counter_id == ED_COUNTER_ID_ELEM_CONTENT)
+ DrawElementContentAreas();
+ else if (counter_id == ED_COUNTER_ID_LEVEL_XSIZE)
+ lev_fieldx = level.fieldx;
+ else if (counter_id == ED_COUNTER_ID_LEVEL_YSIZE)
+ lev_fieldy = level.fieldy;
}
static void HandleTextInputGadgets(struct GadgetInfo *gi)
{
- int id = gi->custom_id;
-
- switch (id)
- {
- case GADGET_ID_LEVEL_NAME:
- strcpy(level.name, gi->text.value);
- break;
+ strcpy(textinput_info[gi->custom_type_id].value, gi->text.value);
+}
- case GADGET_ID_LEVEL_AUTHOR:
- strcpy(level.author, gi->text.value);
- break;
+static void HandleRadiobuttons(struct GadgetInfo *gi)
+{
+ *radiobutton_info[gi->custom_type_id].value =
+ radiobutton_info[gi->custom_type_id].checked_value;
+}
- default:
- break;
- }
+static void HandleCheckbuttons(struct GadgetInfo *gi)
+{
+ *checkbutton_info[gi->custom_type_id].value ^= TRUE;
}
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 step = BUTTON_STEPSIZE(button);
int new_element = BUTTON_ELEMENT(button);
int player_present = FALSE;
int level_changed = FALSE;
}
break;
- case GADGET_ID_RANDOM_PERCENTAGE:
- *radiobutton_info[ED_RADIOBUTTON_ID_PERCENTAGE].value =
- radiobutton_info[ED_RADIOBUTTON_ID_PERCENTAGE].checked_value;
- break;
-
- case GADGET_ID_RANDOM_QUANTITY:
- *radiobutton_info[ED_RADIOBUTTON_ID_QUANTITY].value =
- radiobutton_info[ED_RADIOBUTTON_ID_QUANTITY].checked_value;
- break;
-
- case GADGET_ID_RANDOM_RESTRICTED:
- *checkbutton_info[ED_CHECKBUTTON_ID_RANDOM_RESTRICTED].value ^= TRUE;
- break;
-
- case GADGET_ID_DOUBLE_SPEED:
- *checkbutton_info[ED_CHECKBUTTON_ID_DOUBLE_SPEED].value ^= TRUE;
- break;
-
- case GADGET_ID_GRAVITY:
- *checkbutton_info[ED_CHECKBUTTON_ID_GRAVITY].value ^= TRUE;
- break;
-
- case GADGET_ID_STICK_ELEMENT:
- *checkbutton_info[ED_CHECKBUTTON_ID_STICK_ELEMENT].value ^= TRUE;
- break;
-
default:
if (id >= GADGET_ID_ELEMENTLIST_FIRST &&
id <= GADGET_ID_ELEMENTLIST_LAST)
projects / rocksndiamonds.git / blobdiff