-----------------------------------------------------------------------------
*/
-/* values for the control window */
-#define ED_CTRL1_BUTTONS_HORIZ 4 /* toolbox */
+// values for the control window
+#define ED_CTRL1_BUTTONS_HORIZ 4 // toolbox
#define ED_CTRL1_BUTTONS_VERT 4
-#define ED_CTRL2_BUTTONS_HORIZ 3 /* level */
+#define ED_CTRL2_BUTTONS_HORIZ 3 // level
#define ED_CTRL2_BUTTONS_VERT 2
-#define ED_CTRL3_BUTTONS_HORIZ 3 /* CE and GE */
+#define ED_CTRL3_BUTTONS_HORIZ 3 // CE and GE
#define ED_CTRL3_BUTTONS_VERT 1
-#define ED_CTRL4_BUTTONS_HORIZ 2 /* CE and GE */
+#define ED_CTRL4_BUTTONS_HORIZ 2 // CE and GE
#define ED_CTRL4_BUTTONS_VERT 1
-#define ED_CTRL5_BUTTONS_HORIZ 1 /* properties */
+#define ED_CTRL5_BUTTONS_HORIZ 1 // properties
#define ED_CTRL5_BUTTONS_VERT 1
-#define ED_CTRL6_BUTTONS_HORIZ 3 /* properties */
+#define ED_CTRL6_BUTTONS_HORIZ 3 // properties
#define ED_CTRL6_BUTTONS_VERT 1
-#define ED_CTRL7_BUTTONS_HORIZ 1 /* palette */
+#define ED_CTRL7_BUTTONS_HORIZ 1 // palette
#define ED_CTRL7_BUTTONS_VERT 1
#define ED_NUM_CTRL1_BUTTONS (ED_CTRL1_BUTTONS_HORIZ * ED_CTRL1_BUTTONS_VERT)
#define ED_NUM_CTRL1_7_BUTTONS (ED_NUM_CTRL1_6_BUTTONS + ED_NUM_CTRL7_BUTTONS)
#define ED_NUM_CTRL_BUTTONS ED_NUM_CTRL1_7_BUTTONS
-/* values for the element list */
+// values for the element list
#define ED_ELEMENTLIST_XPOS (editor.palette.x)
#define ED_ELEMENTLIST_YPOS (editor.palette.y)
#define ED_ELEMENTLIST_XSIZE (graphic_info[IMG_EDITOR_PALETTE_BUTTON].width)
#define ED_NUM_ELEMENTLIST_BUTTONS (ED_ELEMENTLIST_BUTTONS_HORIZ * \
ED_ELEMENTLIST_BUTTONS_VERT)
-/* standard distances */
+// standard distances
#define ED_GADGET_NORMAL_DISTANCE (editor.gadget.normal_spacing)
#define ED_GADGET_SMALL_DISTANCE (editor.gadget.small_spacing)
#define ED_GADGET_TINY_DISTANCE (editor.gadget.tiny_spacing)
ED_DRAWINGAREA_BORDER_SIZE)
#define ED_GADGET_SPACE_DISTANCE (getFontWidth(FONT_TEXT_1))
-/* values for drawingarea gadgets */
+// values for drawingarea gadgets
#define IMG_BORDER_1 IMG_EDITOR_ELEMENT_BORDER
#define IMG_BORDER_2 IMG_EDITOR_ELEMENT_BORDER_INPUT
#define ED_ELEMENT_BORDER (graphic_info[IMG_BORDER_1].border_size)
#define ED_DRAWINGAREA_BORDER_SIZE (graphic_info[IMG_BORDER_2].border_size)
#define ED_DRAWINGAREA_TILE_SIZE (editor.drawingarea.tile_size)
-/* values for checkbutton gadgets */
+// values for checkbutton gadgets
#define ED_CHECKBUTTON_XSIZE (graphic_info[IMG_EDITOR_CHECKBOX].width)
#define ED_CHECKBUTTON_YSIZE (graphic_info[IMG_EDITOR_CHECKBOX].height)
ED_AREA_YOFFSET_1((i).y) - \
ED_AREA_YOFFSET_2((i).area_ysize))
-/* values for element content drawing areas */
+// values for element content drawing areas
#define ED_AREA_1X1_LSETTINGS_XPOS(n) ED_LEVEL_SETTINGS_XPOS(n)
#define ED_AREA_1X1_LSETTINGS_YPOS(n) ED_LEVEL_SETTINGS_YPOS(n)
#define ED_AREA_1X1_LSETTINGS_XOFF (0)
#define ED_AREA_3X3_SETTINGS_XOFF (0)
#define ED_AREA_3X3_SETTINGS_YOFF (0)
-/* element content */
+// element content
#define ED_AREA_ELEMENT_CONTENT_XOFF(n) (n)
#define ED_AREA_ELEMENT_CONTENT_YOFF(n) (n)
-/* yamyam content */
+// yamyam content
#define ED_XPOS_YAM 0
#define ED_YPOS_YAM 5
#define ED_AREA_YAMYAM_CONTENT_XPOS ED_ELEMENT_SETTINGS_XPOS(ED_XPOS_YAM)
ED_AREA_YOFFSET_1(ED_YPOS_YAM) - \
ED_AREA_YOFFSET_2(3))
-/* magic ball content */
+// magic ball content
#define ED_XPOS_BALL 0
#define ED_YPOS_BALL 6
#define ED_AREA_MAGIC_BALL_CONTENT_XPOS ED_ELEMENT_SETTINGS_XPOS(ED_XPOS_BALL)
ED_AREA_YOFFSET_1(ED_YPOS_BALL) - \
ED_AREA_YOFFSET_2(3))
-/* values for scrolling gadgets for drawing area */
+// values for scrolling gadgets for drawing area
#define ED_SCROLLBUTTON_XSIZE (graphic_info[IMG_EDITOR_PLAYFIELD_SCROLLBAR].width)
#define ED_SCROLLBUTTON_YSIZE (graphic_info[IMG_EDITOR_PLAYFIELD_SCROLLBAR].height)
#define ED_SCROLL_VERTICAL_XSIZE ED_SCROLLBUTTON_XSIZE
#define ED_SCROLL_VERTICAL_YSIZE (SYSIZE - 4 * ED_SCROLLBUTTON_YSIZE)
-/* values for scrolling gadgets for element list */
+// values for scrolling gadgets for element list
#define ED_SCROLLBUTTON2_XSIZE (graphic_info[IMG_EDITOR_PALETTE_SCROLL_UP].width)
#define ED_SCROLLBUTTON2_YSIZE (graphic_info[IMG_EDITOR_PALETTE_SCROLL_UP].height)
ED_ELEMENTLIST_YSIZE - \
2 * ED_SCROLLBUTTON2_YSIZE)
-/* values for ClearEditorGadgetInfoText() and HandleEditorGadgetInfoText() */
+// values for ClearEditorGadgetInfoText() and HandleEditorGadgetInfoText()
#define INFOTEXT_FONT FONT_TEXT_2
#define INFOTEXT_XSIZE SXSIZE
#define INFOTEXT_YSIZE getFontHeight(INFOTEXT_FONT)
{
GADGET_ID_NONE = -1,
- /* drawing toolbox buttons */
+ // drawing toolbox buttons
GADGET_ID_SINGLE_ITEMS,
GADGET_ID_CONNECTED_ITEMS,
GADGET_ID_ELEMENT_RIGHT,
GADGET_ID_PALETTE,
- /* counter gadget identifiers */
+ // counter gadget identifiers
GADGET_ID_SELECT_LEVEL_DOWN,
GADGET_ID_SELECT_LEVEL_TEXT,
GADGET_ID_GROUP_CONTENT_TEXT,
GADGET_ID_GROUP_CONTENT_UP,
- /* drawing area identifiers */
+ // drawing area identifiers
GADGET_ID_DRAWING_LEVEL,
GADGET_ID_YAMYAM_CONTENT_0,
GADGET_ID_GROUP_CONTENT,
GADGET_ID_RANDOM_BACKGROUND,
- /* text input identifiers */
+ // text input identifiers
GADGET_ID_LEVEL_NAME,
GADGET_ID_LEVEL_AUTHOR,
GADGET_ID_LEVELSET_AUTHOR,
GADGET_ID_ELEMENT_NAME,
- /* text area identifiers */
+ // text area identifiers
GADGET_ID_ENVELOPE_INFO,
- /* selectbox identifiers */
+ // selectbox identifiers
GADGET_ID_TIME_OR_STEPS,
GADGET_ID_GAME_ENGINE_TYPE,
GADGET_ID_SELECT_CHANGE_PAGE,
GADGET_ID_GROUP_CHOICE_MODE,
- /* textbutton identifiers */
+ // textbutton identifiers
GADGET_ID_LEVELINFO_LEVEL,
GADGET_ID_LEVELINFO_LEVELSET,
GADGET_ID_ADD_CHANGE_PAGE,
GADGET_ID_DEL_CHANGE_PAGE,
- /* graphicbutton identifiers */
+ // graphicbutton identifiers
GADGET_ID_PREV_CHANGE_PAGE,
GADGET_ID_NEXT_CHANGE_PAGE,
GADGET_ID_COPY_CHANGE_PAGE,
GADGET_ID_PASTE_CHANGE_PAGE,
- /* gadgets for scrolling of drawing area */
+ // gadgets for scrolling of drawing area
GADGET_ID_SCROLL_UP,
GADGET_ID_SCROLL_DOWN,
GADGET_ID_SCROLL_HORIZONTAL,
GADGET_ID_SCROLL_VERTICAL,
- /* gadgets for scrolling element list */
+ // gadgets for scrolling element list
GADGET_ID_SCROLL_LIST_UP,
GADGET_ID_SCROLL_LIST_DOWN,
GADGET_ID_SCROLL_LIST_VERTICAL,
- /* checkbuttons/radiobuttons for level/element properties */
+ // checkbuttons/radiobuttons for level/element properties
GADGET_ID_AUTO_COUNT_GEMS,
GADGET_ID_USE_LEVELSET_ARTWORK,
NUM_STATIC_GADGET_IDS
};
-/* gadgets for buttons in element list (dynamic) */
+// gadgets for buttons in element list (dynamic)
#define GADGET_ID_ELEMENTLIST_FIRST (NUM_STATIC_GADGET_IDS)
#define GADGET_ID_ELEMENTLIST_LAST (GADGET_ID_ELEMENTLIST_FIRST + \
ED_NUM_ELEMENTLIST_BUTTONS - 1)
#define NUM_EDITOR_GADGETS (GADGET_ID_ELEMENTLIST_LAST + 1)
-/* radio button numbers */
+// radio button numbers
enum
{
RADIO_NR_NONE,
RADIO_NR_RANDOM_ELEMENTS
};
-/* values for counter gadgets */
+// values for counter gadgets
enum
{
ED_COUNTER_ID_SELECT_LEVEL,
#define ED_COUNTER_ID_CHANGE_FIRST ED_COUNTER_ID_CHANGE_DELAY_FIX
#define ED_COUNTER_ID_CHANGE_LAST ED_COUNTER_ID_CHANGE_CONT_RND
-/* values for scrollbutton gadgets */
+// values for scrollbutton gadgets
enum
{
ED_SCROLLBUTTON_ID_AREA_UP,
#define ED_SCROLLBUTTON_ID_AREA_FIRST ED_SCROLLBUTTON_ID_AREA_UP
#define ED_SCROLLBUTTON_ID_AREA_LAST ED_SCROLLBUTTON_ID_AREA_RIGHT
-/* values for scrollbar gadgets */
+// values for scrollbar gadgets
enum
{
ED_SCROLLBAR_ID_AREA_HORIZONTAL,
#define ED_SCROLLBAR_ID_AREA_FIRST ED_SCROLLBAR_ID_AREA_HORIZONTAL
#define ED_SCROLLBAR_ID_AREA_LAST ED_SCROLLBAR_ID_AREA_VERTICAL
-/* values for text input gadgets */
+// values for text input gadgets
enum
{
ED_TEXTINPUT_ID_LEVEL_NAME,
#define ED_TEXTINPUT_ID_LEVELSET_FIRST ED_TEXTINPUT_ID_LEVELSET_NAME
#define ED_TEXTINPUT_ID_LEVELSET_LAST ED_TEXTINPUT_ID_LEVELSET_AUTHOR
-/* values for text area gadgets */
+// values for text area gadgets
enum
{
ED_TEXTAREA_ID_ENVELOPE_INFO,
#define ED_TEXTAREA_ID_LEVEL_FIRST ED_TEXTAREA_ID_ENVELOPE
#define ED_TEXTAREA_ID_LEVEL_LAST ED_TEXTAREA_ID_ENVELOPE
-/* values for selectbox gadgets */
+// values for selectbox gadgets
enum
{
ED_SELECTBOX_ID_TIME_OR_STEPS,
#define ED_SELECTBOX_ID_CHANGE_FIRST ED_SELECTBOX_ID_CHANGE_TIME_UNITS
#define ED_SELECTBOX_ID_CHANGE_LAST ED_SELECTBOX_ID_SELECT_CHANGE_PAGE
-/* values for textbutton gadgets */
+// values for textbutton gadgets
enum
{
ED_TEXTBUTTON_ID_LEVELINFO_LEVEL,
#define ED_TEXTBUTTON_ID_CHANGE_FIRST ED_TEXTBUTTON_ID_ADD_CHANGE_PAGE
#define ED_TEXTBUTTON_ID_CHANGE_LAST ED_TEXTBUTTON_ID_DEL_CHANGE_PAGE
-/* values for graphicbutton gadgets */
+// values for graphicbutton gadgets
enum
{
ED_GRAPHICBUTTON_ID_PREV_CHANGE_PAGE,
#define ED_GRAPHICBUTTON_ID_CHANGE_FIRST ED_GRAPHICBUTTON_ID_PREV_CHANGE_PAGE
#define ED_GRAPHICBUTTON_ID_CHANGE_LAST ED_GRAPHICBUTTON_ID_PASTE_CHANGE_PAGE
-/* values for checkbutton gadgets */
+// values for checkbutton gadgets
enum
{
ED_CHECKBUTTON_ID_AUTO_COUNT_GEMS,
#define ED_CHECKBUTTON_ID_CHANGE_FIRST ED_CHECKBUTTON_ID_CUSTOM_CAN_CHANGE
#define ED_CHECKBUTTON_ID_CHANGE_LAST ED_CHECKBUTTON_ID_CHANGE_HAS_ACTION
-/* values for radiobutton gadgets */
+// values for radiobutton gadgets
enum
{
ED_RADIOBUTTON_ID_PERCENTAGE,
#define ED_RADIOBUTTON_ID_EDITOR_FIRST ED_RADIOBUTTON_ID_PERCENTAGE
#define ED_RADIOBUTTON_ID_EDITOR_LAST ED_RADIOBUTTON_ID_QUANTITY
-/* values for drawing area gadgets */
+// values for drawing area gadgets
enum
{
ED_DRAWING_ID_DRAWING_LEVEL,
-----------------------------------------------------------------------------
*/
-/* values for CopyLevelToUndoBuffer() */
+// values for CopyLevelToUndoBuffer()
#define UNDO_IMMEDIATE 0
#define UNDO_ACCUMULATE 1
-/* values for scrollbars */
+// values for scrollbars
#define ED_SCROLL_NO 0
#define ED_SCROLL_LEFT 1
#define ED_SCROLL_RIGHT 2
#define ED_SCROLL_UP 4
#define ED_SCROLL_DOWN 8
-/* screens in the level editor */
+// screens in the level editor
#define ED_MODE_DRAWING 0
#define ED_MODE_INFO 1
#define ED_MODE_PROPERTIES 2
#define ED_MODE_PALETTE 3
-/* sub-screens in the global settings section */
+// sub-screens in the global settings section
#define ED_MODE_LEVELINFO_LEVEL ED_TEXTBUTTON_ID_LEVELINFO_LEVEL
#define ED_MODE_LEVELINFO_LEVELSET ED_TEXTBUTTON_ID_LEVELINFO_LEVELSET
#define ED_MODE_LEVELINFO_EDITOR ED_TEXTBUTTON_ID_LEVELINFO_EDITOR
-/* sub-screens in the element properties section */
+// sub-screens in the element properties section
#define ED_MODE_PROPERTIES_INFO ED_TEXTBUTTON_ID_PROPERTIES_INFO
#define ED_MODE_PROPERTIES_CONFIG ED_TEXTBUTTON_ID_PROPERTIES_CONFIG
#define ED_MODE_PROPERTIES_CONFIG_1 ED_TEXTBUTTON_ID_PROPERTIES_CONFIG_1
#define ED_MODE_PROPERTIES_CONFIG_2 ED_TEXTBUTTON_ID_PROPERTIES_CONFIG_2
#define ED_MODE_PROPERTIES_CHANGE ED_TEXTBUTTON_ID_PROPERTIES_CHANGE
-/* how many steps can be cancelled */
+// how many steps can be cancelled
#define NUM_UNDO_STEPS (64 + 1)
-/* values for elements with score for certain actions */
+// values for elements with score for certain actions
#define MIN_SCORE 0
#define MAX_SCORE 999
-/* values for elements with count for collecting */
+// values for elements with count for collecting
#define MIN_COLLECT_COUNT 0
#define MAX_COLLECT_COUNT 999
-/* values for random placement */
+// values for random placement
#define RANDOM_USE_PERCENTAGE 0
#define RANDOM_USE_QUANTITY 1
-/* values for level set save mode */
+// values for level set save mode
#define LEVELSET_SAVE_MODE_UPDATE 0
#define LEVELSET_SAVE_MODE_CREATE 1
-/* default value for element tile size in drawing area */
+// default value for element tile size in drawing area
#define DEFAULT_EDITOR_TILESIZE MINI_TILESIZE
#define DEFAULT_EDITOR_TILESIZE_MM TILESIZE
/* note: some additional characters are already reserved for "cheat mode"
shortcuts (":XYZ" style) -- for details, see "events.c" */
- /* ---------- toolbox control buttons ------------------------------------ */
+ // ---------- toolbox control buttons ---------------------------------------
{
IMG_GFX_EDITOR_BUTTON_DRAW_SINGLE, GADGET_ID_SINGLE_ITEMS,
"pick drawing element", ','
},
- /* ---------- level control buttons -------------------------------------- */
+ // ---------- level control buttons -----------------------------------------
{
IMG_GFX_EDITOR_BUTTON_UNDO, GADGET_ID_UNDO,
"exit level editor", 'E'
},
- /* ---------- CE and GE control buttons ---------------------------------- */
+ // ---------- CE and GE control buttons -------------------------------------
{
IMG_GFX_EDITOR_BUTTON_CE_COPY_FROM, GADGET_ID_CUSTOM_COPY_FROM,
"paste settings to this element", 0
},
- /* ---------- palette control buttons ------------------------------------ */
+ // ---------- palette control buttons ---------------------------------------
{
IMG_GFX_EDITOR_BUTTON_PROPERTIES, GADGET_ID_PROPERTIES,
char *text_above, *text_left, *text_right;
} counterbutton_info[ED_NUM_COUNTERBUTTONS] =
{
- /* ---------- current level number --------------------------------------- */
+ // ---------- current level number ------------------------------------------
{
- -1, -1, /* these values are not constant, but can change at runtime */
+ -1, -1, // these values are not constant, but can change at runtime
1, 100,
GADGET_ID_SELECT_LEVEL_DOWN, GADGET_ID_SELECT_LEVEL_UP,
GADGET_ID_SELECT_LEVEL_TEXT, GADGET_ID_NONE,
NULL, NULL, NULL
},
- /* ---------- level and editor settings ---------------------------------- */
+ // ---------- level and editor settings -------------------------------------
{
ED_LEVEL_SETTINGS_XPOS(0), ED_LEVEL_SETTINGS_YPOS(4),
"random element placement:", NULL, "in"
},
- /* ---------- element settings: configure (various elements) ------------- */
+ // ---------- element settings: configure (various elements) ----------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(0),
MIN_SCORE, MAX_SCORE,
GADGET_ID_ELEMENT_VALUE1_DOWN, GADGET_ID_ELEMENT_VALUE1_UP,
GADGET_ID_ELEMENT_VALUE1_TEXT, GADGET_ID_NONE,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, NULL, NULL
},
{
MIN_SCORE, MAX_SCORE,
GADGET_ID_ELEMENT_VALUE2_DOWN, GADGET_ID_ELEMENT_VALUE2_UP,
GADGET_ID_ELEMENT_VALUE2_TEXT, GADGET_ID_NONE,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, NULL, NULL
},
{
MIN_SCORE, MAX_SCORE,
GADGET_ID_ELEMENT_VALUE3_DOWN, GADGET_ID_ELEMENT_VALUE3_UP,
GADGET_ID_ELEMENT_VALUE3_TEXT, GADGET_ID_NONE,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, NULL, NULL
},
{
MIN_SCORE, MAX_SCORE,
GADGET_ID_ELEMENT_VALUE4_DOWN, GADGET_ID_ELEMENT_VALUE4_UP,
GADGET_ID_ELEMENT_VALUE4_TEXT, GADGET_ID_NONE,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, NULL, NULL
},
{
MIN_ENVELOPE_XSIZE, MAX_ENVELOPE_XSIZE,
GADGET_ID_ENVELOPE_XSIZE_DOWN, GADGET_ID_ENVELOPE_XSIZE_UP,
GADGET_ID_ENVELOPE_XSIZE_TEXT, GADGET_ID_NONE,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, NULL, "width",
},
{
MIN_ENVELOPE_YSIZE, MAX_ENVELOPE_YSIZE,
GADGET_ID_ENVELOPE_YSIZE_DOWN, GADGET_ID_ENVELOPE_YSIZE_UP,
GADGET_ID_ENVELOPE_YSIZE_TEXT, GADGET_ID_ENVELOPE_XSIZE_UP,
- NULL, /* will be set when used */
+ NULL, // will be set when used
NULL, " ", "height",
},
{
NULL, NULL, "number of inventory elements"
},
- /* ---------- element settings: configure 1 (custom elements) ------------ */
+ // ---------- element settings: configure 1 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(1), ED_ELEMENT_SETTINGS_YPOS(5),
NULL, "+random", NULL
},
- /* ---------- element settings: configure 2 (custom elements) ------------ */
+ // ---------- element settings: configure 2 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(1), ED_ELEMENT_SETTINGS_YPOS(5),
NULL, "ignition delay", "(by fire)"
},
- /* ---------- element settings: configure (group elements) --------------- */
+ // ---------- element settings: configure (group elements) ------------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(3),
NULL, NULL, "number of elements in group"
},
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
{
ED_ELEMENT_SETTINGS_XPOS(2), ED_ELEMENT_SETTINGS_YPOS(2),
"Author:", "Author for this or new level set"
},
{
- -1, -1, /* these values are not constant, but can change at runtime */
+ -1, -1, // these values are not constant, but can change at runtime
GADGET_ID_ELEMENT_NAME,
- MAX_ELEMENT_NAME_LEN - 2, /* currently 2 chars less editable */
+ MAX_ELEMENT_NAME_LEN - 2, // currently 2 chars less editable
custom_element.description,
NULL, "Element name"
}
int x, y;
int gadget_id;
int gadget_id_align;
- int size; /* char size of selectbox or '-1' (dynamically determined) */
+ int size; // char size of selectbox or '-1' (dynamically determined)
struct ValueTextInfo *options;
int *value;
char *text_above, *text_left, *text_right, *infotext;
} selectbox_info[ED_NUM_SELECTBOX] =
{
- /* ---------- level and editor settings ---------------------------------- */
+ // ---------- level and editor settings -------------------------------------
{
-1, ED_LEVEL_SETTINGS_YPOS(8),
"Action:", NULL, NULL, "action when saving level set"
},
- /* ---------- element settings: configure (several elements) ------------- */
+ // ---------- element settings: configure (several elements) ----------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(0),
NULL, "initial player speed:", NULL, "initial player speed"
},
- /* ---------- element settings: configure 1 (custom elements) ------------ */
+ // ---------- element settings: configure 1 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(1), ED_ELEMENT_SETTINGS_YPOS(2),
NULL, NULL, NULL, "diggable/collectible/pushable"
},
- /* ---------- element settings: configure 2 (custom elements) ------------ */
+ // ---------- element settings: configure 2 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(1), ED_ELEMENT_SETTINGS_YPOS(1),
NULL, "can explode", NULL, "explosion type"
},
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
{
ED_ELEMENT_SETTINGS_XPOS(2), ED_ELEMENT_SETTINGS_YPOS(3),
NULL, NULL, NULL, "element change page"
},
- /* ---------- element settings: configure (group elements) --------------- */
+ // ---------- element settings: configure (group elements) ------------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(4),
char *text_above, *text_left, *text_right, *infotext;
} textbutton_info[ED_NUM_TEXTBUTTONS] =
{
- /* ---------- level and editor settings (tabs) --------------------------- */
+ // ---------- level and editor settings (tabs) ------------------------------
{
ED_LEVEL_TABS_XPOS(0), ED_LEVEL_TABS_YPOS(0),
NULL, NULL, NULL, "Configure editor properties"
},
- /* ---------- element settings (tabs) ------------------------------------ */
+ // ---------- element settings (tabs) ---------------------------------------
{
ED_ELEMENT_TABS_XPOS(0), ED_ELEMENT_TABS_YPOS(0),
NULL, NULL, NULL, "Configure custom element change pages"
},
- /* ---------- level and editor settings (buttons) ------------------------ */
+ // ---------- level and editor settings (buttons) ---------------------------
{
ED_LEVEL_SETTINGS_XPOS(0), ED_LEVEL_SETTINGS_YPOS(10),
"Save current settings as new template"
},
- /* ---------- element settings (buttons) --------------------------------- */
+ // ---------- element settings (buttons) ------------------------------------
{
-1, -1,
char *text_above, *text_left, *text_right, *infotext;
} checkbutton_info[ED_NUM_CHECKBUTTONS] =
{
- /* ---------- level and editor settings ---------------------------------- */
+ // ---------- level and editor settings -------------------------------------
{
ED_LEVEL_SETTINGS_XPOS(0), ED_LEVEL_SETTINGS_YPOS(6),
"use template for custom elements", "use template for custom properties"
},
- /* ---------- element settings: configure (various elements) ------------- */
+ // ---------- element settings: configure (various elements) ----------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(0),
"blue", "use blue color components in laser"
},
- /* ---------- element settings: configure 1 (custom elements) ----------- */
+ // ---------- element settings: configure 1 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(1),
"indestructible", "element is indestructible"
},
- /* ---------- element settings: configure 2 (custom elements) ----------- */
+ // ---------- element settings: configure 2 (custom elements) ---------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(1),
"impact", "element can explode on impact"
},
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
{
ED_ELEMENT_SETTINGS_XPOS(0), ED_ELEMENT_SETTINGS_YPOS(1),
char *text_left, *text_right, *text_below, *infotext;
} drawingarea_info[ED_NUM_DRAWING_AREAS] =
{
- /* ---------- level playfield content ------------------------------------ */
+ // ---------- level playfield content ---------------------------------------
{
0, 0,
0, 0,
GADGET_ID_DRAWING_LEVEL, GADGET_ID_NONE,
NULL,
- -1, -1, /* these values are not constant, but can change at runtime */
+ -1, -1, // these values are not constant, but can change at runtime
NULL, NULL, NULL, NULL
},
- /* ---------- yam yam content -------------------------------------------- */
+ // ---------- yam yam content -----------------------------------------------
{
ED_AREA_YAMYAM_CONTENT_XPOS, ED_AREA_YAMYAM_CONTENT_YPOS,
NULL, NULL, "8", NULL
},
- /* ---------- magic ball content ----------------------------------------- */
+ // ---------- magic ball content --------------------------------------------
{
ED_AREA_MAGIC_BALL_CONTENT_XPOS, ED_AREA_MAGIC_BALL_CONTENT_YPOS,
NULL, NULL, "8", NULL
},
- /* ---------- android content -------------------------------------------- */
+ // ---------- android content -----------------------------------------------
{
ED_AREA_1X1_SETTINGS_XPOS(0), ED_AREA_1X1_SETTINGS_YPOS(5),
"elements:", NULL, NULL, "elements android can clone"
},
- /* ---------- amoeba content --------------------------------------------- */
+ // ---------- amoeba content ------------------------------------------------
{
ED_AREA_1X1_SETTINGS_XPOS(0), ED_AREA_1X1_SETTINGS_YPOS(3),
"content:", NULL, NULL, "amoeba content"
},
- /* ---------- level start element ---------------------------------------- */
+ // ---------- level start element -------------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(10),
NULL, NULL, NULL, "level start element"
},
- /* ---------- player artwork element ------------------------------------- */
+ // ---------- player artwork element ----------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(11),
NULL, NULL, NULL, "element for player artwork"
},
- /* ---------- player explosion element ----------------------------------- */
+ // ---------- player explosion element --------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(12),
NULL, NULL, NULL, "element for player explosion"
},
- /* ---------- player initial inventory ----------------------------------- */
+ // ---------- player initial inventory --------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(1),
NULL, NULL, NULL, "content for initial inventory"
},
- /* ---------- element settings: configure 1 (custom elements) ----------- */
+ // ---------- element settings: configure 1 (custom elements) ---------------
- /* ---------- custom graphic --------------------------------------------- */
+ // ---------- custom graphic ------------------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(1),
NULL, NULL, NULL, "custom graphic element"
},
- /* ---------- element settings: configure 2 (custom elements) ----------- */
+ // ---------- element settings: configure 2 (custom elements) ---------------
- /* ---------- custom content (when exploding) ---------------------------- */
+ // ---------- custom content (when exploding) -------------------------------
{
-1, ED_AREA_3X3_SETTINGS_YPOS(10),
0, ED_AREA_3X3_SETTINGS_YOFF,
- GADGET_ID_CUSTOM_CONTENT, GADGET_ID_NONE, /* align three rows */
+ GADGET_ID_CUSTOM_CONTENT, GADGET_ID_NONE, // align three rows
&custom_element.content.e[0][0], 3, 3,
"content:", NULL, NULL, NULL
},
- /* ---------- custom enter and leave element (when moving) --------------- */
+ // ---------- custom enter and leave element (when moving) ------------------
{
ED_AREA_1X1_SETTINGS_XPOS(1), ED_AREA_1X1_SETTINGS_YPOS(3),
NULL, NULL, NULL, "element that will be left behind"
},
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
- /* ---------- custom change target --------------------------------------- */
+ // ---------- custom change target ------------------------------------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(1),
NULL, "after/when:", NULL, "new target element after change"
},
- /* ---------- custom change content (extended change target) ------------- */
+ // ---------- custom change content (extended change target) ----------------
{
-1, ED_AREA_3X3_SETTINGS_YPOS(9),
0, ED_AREA_3X3_SETTINGS_YOFF,
- GADGET_ID_CUSTOM_CHANGE_CONTENT, GADGET_ID_NONE, /* align three rows */
+ GADGET_ID_CUSTOM_CHANGE_CONTENT, GADGET_ID_NONE, // align three rows
&custom_element_change.target_content.e[0][0], 3, 3,
NULL, NULL, NULL, "new extended elements after change"
},
- /* ---------- custom change trigger (element causing change) ------------- */
+ // ---------- custom change trigger (element causing change) ----------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(5),
NULL, NULL, NULL, "other element triggering change"
},
- /* ---------- custom change action (element used for action) ------------- */
+ // ---------- custom change action (element used for action) ----------------
{
-1, ED_AREA_1X1_SETTINGS_YPOS(13),
NULL, NULL, NULL, "element used as action parameter"
},
- /* ---------- group element content -------------------------------------- */
+ // ---------- group element content -----------------------------------------
{
ED_AREA_1X1_SETTINGS_XPOS(0), ED_AREA_1X1_SETTINGS_YPOS(2),
"content:", NULL, NULL, NULL
},
- /* ---------- random background (for random painting) -------------------- */
+ // ---------- random background (for random painting) -----------------------
{
-1, ED_AREA_1X1_LSETTINGS_YPOS(1),
-----------------------------------------------------------------------------
*/
-/* maximal size of level editor drawing area */
+// maximal size of level editor drawing area
static int MAX_ED_FIELDX, MAX_ED_FIELDY;
-/* actual size of level editor drawing area */
+// actual size of level editor drawing area
static int ed_fieldx, ed_fieldy;
-/* actual position of level editor drawing area in level playfield */
+// actual position of level editor drawing area in level playfield
static int level_xpos = -1, level_ypos = -1;
-/* actual tile size used to display playfield drawing area */
+// actual tile size used to display playfield drawing area
static int ed_tilesize = DEFAULT_EDITOR_TILESIZE;
static int ed_tilesize_default = DEFAULT_EDITOR_TILESIZE;
#define IN_ED_FIELD(x,y) IN_FIELD(x, y, ed_fieldx, ed_fieldy)
-/* drawing elements on the three mouse buttons */
+// drawing elements on the three mouse buttons
static int new_element1 = EL_WALL;
static int new_element2 = EL_EMPTY;
static int new_element3 = EL_SAND;
#define PXSIZE (use_permanent_palette ? DXSIZE : SXSIZE)
#define PYSIZE (use_permanent_palette ? DYSIZE : SYSIZE)
-/* forward declaration for internal use */
+// forward declaration for internal use
static void ModifyEditorCounterValue(int, int);
static void ModifyEditorCounterLimits(int, int, int);
static void ModifyEditorSelectboxValue(int, int);
static int getTabulatorBarHeight(void);
static Pixel getTabulatorBarColor(void);
-static int num_editor_gadgets = 0; /* dynamically determined */
+static int num_editor_gadgets = 0; // dynamically determined
static struct GadgetInfo **level_editor_gadget = NULL;
static int *right_gadget_border = NULL;
static int editor_el_rnd[] =
{
- EL_DYNAMITE, /* RND */
- EL_DYNAMITE_ACTIVE, /* RND */
+ EL_DYNAMITE, // RND
+ EL_DYNAMITE_ACTIVE, // RND
EL_EMPTY,
EL_EMPTY,
EL_PACMAN_LEFT,
EL_DARK_YAMYAM,
EL_PACMAN_RIGHT,
- EL_YAMYAM, /* RND */
+ EL_YAMYAM, // RND
EL_BLACK_ORB,
EL_PACMAN_DOWN,
static int editor_el_diamond_caves[] =
{
- EL_EM_STEEL_EXIT_CLOSED, /* DC2 */
- EL_EM_STEEL_EXIT_OPEN, /* DC2 */
- EL_WALL_EMERALD, /* DC2 */
- EL_WALL_DIAMOND, /* DC2 */
+ EL_EM_STEEL_EXIT_CLOSED, // DC2
+ EL_EM_STEEL_EXIT_OPEN, // DC2
+ EL_WALL_EMERALD, // DC2
+ EL_WALL_DIAMOND, // DC2
EL_PEARL,
EL_CRYSTAL,
static int num_editor_el_dynamic = 0;
static int editor_hl_empty[] = { EL_EMPTY };
-static int *editor_el_empty = NULL; /* dynamically allocated */
+static int *editor_el_empty = NULL; // dynamically allocated
static int *editor_hl_empty_ptr = editor_hl_empty;
static int *editor_el_empty_ptr = NULL;
static int num_editor_hl_empty = 0;
-static int num_editor_el_empty = 0; /* dynamically determined, if needed */
+static int num_editor_el_empty = 0; // dynamically determined, if needed
static boolean use_el_empty = FALSE;
-static int *editor_elements = NULL; /* dynamically allocated */
-static int num_editor_elements = 0; /* dynamically determined */
+static int *editor_elements = NULL; // dynamically allocated
+static int num_editor_elements = 0; // dynamically determined
static boolean setup_editor_cascade_never = FALSE;
checked_free(filename);
- /* 1st try: look for element description in current level set directory */
+ // 1st try: look for element description in current level set directory
filename = getPath3(getCurrentLevelDir(), elements_subdir2, basename);
if (fileExists(filename))
return filename;
free(filename);
- /* 2nd try: look for element description in the game's base directory */
+ // 2nd try: look for element description in the game's base directory
filename = getPath3(options.docs_directory, elements_subdir, basename);
if (fileExists(filename))
return filename;
char basename[MAX_FILENAME_LEN];
char *filename;
- /* 1st try: look for element description file for exactly this element */
+ // 1st try: look for element description file for exactly this element
sprintf(basename, "%s.txt", element_info[element].token_name);
filename = getElementDescriptionFilenameExt(basename);
if (filename != NULL)
return filename;
- /* 2nd try: look for element description file for this element's class */
+ // 2nd try: look for element description file for this element's class
sprintf(basename, "%s.txt", element_info[element].class_name);
filename = getElementDescriptionFilenameExt(basename);
if (filename != NULL)
boolean element_found[NUM_FILE_ELEMENTS];
int i, x, y;
- /* initialize list of used elements to "not used" */
+ // initialize list of used elements to "not used"
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
element_found[i] = FALSE;
- /* find all elements used in current level */
+ // 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 */
+ if (Feld[x][y] < NUM_FILE_ELEMENTS) // should always be true
element_found[Feld[x][y]] = TRUE;
*num_elements = 0;
- /* count number of elements used in current level */
+ // count number of elements used in current level
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
if (element_found[i])
(*num_elements)++;
- /* add space for up to 3 more elements for padding that may be needed */
+ // add space for up to 3 more elements for padding that may be needed
*num_elements += 3;
- /* free memory for old list of elements, if needed */
+ // free memory for old list of elements, if needed
checked_free(*elements);
- /* allocate memory for new list of elements */
+ // allocate memory for new list of elements
*elements = checked_malloc(*num_elements * sizeof(int));
*num_elements = 0;
- /* add all elements used in current level (non-custom/group elements) */
+ // add all elements used in current level (non-custom/group elements)
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
if (element_found[i] && !(IS_CUSTOM_ELEMENT(i) || IS_GROUP_ELEMENT(i)))
(*elements)[(*num_elements)++] = i;
- /* add all elements used in current level (custom/group elements) */
+ // add all elements used in current level (custom/group elements)
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
if (element_found[i] && (IS_CUSTOM_ELEMENT(i) || IS_GROUP_ELEMENT(i)))
(*elements)[(*num_elements)++] = i;
- while (*num_elements % 4) /* pad with empty elements, if needed */
+ while (*num_elements % 4) // pad with empty elements, if needed
(*elements)[(*num_elements)++] = EL_EMPTY;
}
static void ReinitializeElementList_EnableSections(void)
{
- /* default: enable all element sections */
+ // default: enable all element sections
setup_editor_el_players = TRUE;
setup_editor_el_boulderdash = TRUE;
setup_editor_el_user_defined = TRUE;
setup_editor_el_dynamic = TRUE;
- /* now disable all element sections not to be displayed */
+ // now disable all element sections not to be displayed
if (!setup.editor.el_classic)
{
if (initialization_needed)
{
- LoadSetup_EditorCascade(); /* load last editor cascade state */
+ LoadSetup_EditorCascade(); // load last editor cascade state
- /* initialize editor cascade element from saved cascade state */
+ // initialize editor cascade element from saved cascade state
for (i = 0; editor_elements_info[i].setup_value != NULL; i++)
{
int *cascade_element = &(*editor_elements_info[i].headline_list)[0];
checked_free(editor_elements);
- /* reload optional user defined element list for each invocation of editor */
+ // reload optional user defined element list for each invocation of editor
LoadUserDefinedEditorElementList(&editor_el_user_defined_ptr,
&num_editor_el_user_defined);
- /* initialize dynamic level element list for each invocation of editor */
+ // initialize dynamic level element list for each invocation of editor
InitDynamicEditorElementList(&editor_el_dynamic_ptr,
&num_editor_el_dynamic);
- /* initialize list of empty elements (used for padding, if needed) */
+ // initialize list of empty elements (used for padding, if needed)
for (i = 0; i < ED_NUM_ELEMENTLIST_BUTTONS; i++)
editor_el_empty[i] = EL_EMPTY;
- /* do some sanity checks for each element from element list */
+ // do some sanity checks for each element from element list
for (i = 0; editor_elements_info[i].setup_value != NULL; i++)
{
for (j = 0; j < *editor_elements_info[i].element_list_size; j++)
num_editor_elements = 0;
use_el_empty = FALSE;
- /* determine size of element list */
+ // determine size of element list
for (i = 0; editor_elements_info[i].setup_value != NULL; i++)
{
boolean found_inactive_cascade = FALSE;
if (num_editor_elements < ED_NUM_ELEMENTLIST_BUTTONS)
{
- /* offer at least as many elements as element buttons exist */
+ // offer at least as many elements as element buttons exist
use_el_empty = TRUE;
num_editor_el_empty = ED_NUM_ELEMENTLIST_BUTTONS - num_editor_elements;
editor_elements = checked_malloc(num_editor_elements * sizeof(int));
- /* fill element list */
+ // fill element list
for (i = 0; editor_elements_info[i].setup_value != NULL; i++)
{
boolean found_inactive_cascade = FALSE;
}
}
- /* (this function is also called before editor gadgets are initialized!) */
+ // (this function is also called before editor gadgets are initialized!)
AdjustElementListScrollbar();
}
static boolean initialization_needed = TRUE;
int i;
- if (!initialization_needed) /* check if editor element setup has changed */
+ if (!initialization_needed) // check if editor element setup has changed
{
if (last_setup_value_headlines != setup.editor.el_headlines)
initialization_needed = TRUE;
FreeLevelEditorGadgets();
CreateLevelEditorGadgets();
- /* store current setup values for next invocation of this function */
+ // store current setup values for next invocation of this function
last_setup_value_headlines = setup.editor.el_headlines;
for (i = 0; editor_elements_info[i].setup_value != NULL; i++)
editor_elements_info[i].last_setup_value =
int ysize_thin = (ysize < ed_tilesize ? 1 : ysize);
Pixel line_color = getTabulatorBarColor();
- if (line_color == BLACK_PIXEL) /* black => transparent */
+ if (line_color == BLACK_PIXEL) // black => transparent
return;
FillRectangle(drawto, SX + x, SY + y, xsize_tile, ysize_tile, BLACK_PIXEL);
if (!suppressBorderElement())
return;
- /* draw little border line around editable level playfield */
+ // draw little border line around editable level playfield
if (xsize < SXSIZE)
DrawEditorLevelBorderLine(xsize, 0, line_size, ysize);
struct GadgetInfo *gi;
int i;
- /* create toolbox buttons */
+ // create toolbox buttons
for (i = 0; i < ED_NUM_CTRL_BUTTONS; i++)
{
int id = controlbutton_info[i].gadget_id;
level_editor_gadget[id] = gi;
}
- /* these values are not constant, but can change at runtime */
+ // these values are not constant, but can change at runtime
scrollbutton_pos[ED_SCROLLBUTTON_ID_AREA_UP].x = ED_SCROLL_UP_XPOS;
scrollbutton_pos[ED_SCROLLBUTTON_ID_AREA_UP].y = ED_SCROLL_UP_YPOS;
scrollbutton_pos[ED_SCROLLBUTTON_ID_AREA_DOWN].x = ED_SCROLL_DOWN_XPOS;
scrollbutton_pos[ED_SCROLLBUTTON_ID_LIST_DOWN].x = ED_SCROLL2_DOWN_XPOS;
scrollbutton_pos[ED_SCROLLBUTTON_ID_LIST_DOWN].y = ED_SCROLL2_DOWN_YPOS;
- /* create buttons for scrolling of drawing area and element list */
+ // create buttons for scrolling of drawing area and element list
for (i = 0; i < ED_NUM_SCROLLBUTTONS; i++)
{
int id = scrollbutton_info[i].gadget_id;
level_editor_gadget[id] = gi;
}
- /* create buttons for element list */
+ // create buttons for element list
for (i = 0; i < ED_NUM_ELEMENTLIST_BUTTONS; i++)
{
int id = GADGET_ID_ELEMENTLIST_FIRST + i;
for (i = 0; i < ED_NUM_COUNTERBUTTONS; i++)
{
int j;
- int x = SX + ED_SETTINGS_X(counterbutton_info[i].x); /* down count button */
+ int x = SX + ED_SETTINGS_X(counterbutton_info[i].x); // down count button
int y = SY + ED_SETTINGS_Y(counterbutton_info[i].y);
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (counterbutton_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[counterbutton_info[i].gadget_id_align] +
ED_GADGET_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (counterbutton_info[i].text_left != NULL)
x += getTextWidthForGadget(counterbutton_info[i].text_left);
right_gadget_border[id] =
getRightGadgetBorder(gi, counterbutton_info[i].text_right);
- x += gi->width + ED_GADGET_SMALL_DISTANCE; /* text count button */
+ x += gi->width + ED_GADGET_SMALL_DISTANCE; // text count button
if (j == 0)
{
GDI_NUMBER_VALUE, 0,
GDI_NUMBER_MIN, counterbutton_info[i].min_value,
GDI_NUMBER_MAX, counterbutton_info[i].max_value,
- GDI_TEXT_SIZE, 3, /* minimal counter text size */
+ GDI_TEXT_SIZE, 3, // minimal counter text size
GDI_TEXT_FONT, font_type,
GDI_TEXT_FONT_ACTIVE, font_type_active,
GDI_DESIGN_UNPRESSED, gd->bitmap, gd_x1, gd_y1,
right_gadget_border[id] =
getRightGadgetBorder(gi, counterbutton_info[i].text_right);
- x += gi->width + ED_GADGET_SMALL_DISTANCE; /* up count button */
+ x += gi->width + ED_GADGET_SMALL_DISTANCE; // up count button
}
}
}
{
int i;
- /* these values are not constant, but can change at runtime */
+ // these values are not constant, but can change at runtime
drawingarea_info[ED_DRAWING_ID_DRAWING_LEVEL].area_xsize = MAX_ED_FIELDX;
drawingarea_info[ED_DRAWING_ID_DRAWING_LEVEL].area_ysize = MAX_ED_FIELDY;
GD_EVENT_PRESSED | GD_EVENT_RELEASED | GD_EVENT_MOVING |
GD_EVENT_OFF_BORDERS | GD_EVENT_PIXEL_PRECISE;
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (drawingarea_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[drawingarea_info[i].gadget_id_align] +
ED_DRAWINGAREA_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (drawingarea_info[i].text_left != NULL)
x += getTextWidthForDrawingArea(drawingarea_info[i].text_left);
int x = SX + ED_SETTINGS_X(selectbox_info[i].x);
int y = SY + ED_SETTINGS_Y(selectbox_info[i].y);
- if (selectbox_info[i].size == -1) /* dynamically determine size */
+ if (selectbox_info[i].size == -1) // dynamically determine size
{
/* (we cannot use -1 for uninitialized values if we directly compare
with results from strlen(), because the '<' and '>' operation will
if (strlen(selectbox_info[i].options[j].text) > selectbox_info[i].size)
selectbox_info[i].size = strlen(selectbox_info[i].options[j].text);
- selectbox_info[i].size++; /* add one character empty space */
+ selectbox_info[i].size++; // add one character empty space
}
event_mask = GD_EVENT_RELEASED |
GD_EVENT_TEXT_RETURN | GD_EVENT_TEXT_LEAVING;
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (selectbox_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[selectbox_info[i].gadget_id_align] +
ED_GADGET_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (selectbox_info[i].text_left != NULL)
x += getTextWidthForGadget(selectbox_info[i].text_left);
int x = SX + ED_SETTINGS_X(textbutton_info[i].x);
int y = SY + ED_SETTINGS_Y(textbutton_info[i].y);
- if (textbutton_info[i].size == -1) /* dynamically determine size */
+ if (textbutton_info[i].size == -1) // dynamically determine size
textbutton_info[i].size = strlen(textbutton_info[i].text);
event_mask = GD_EVENT_RELEASED;
sprintf(infotext, "%s", textbutton_info[i].infotext);
infotext[max_infotext_len] = '\0';
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (textbutton_info[i].gadget_id_align != GADGET_ID_NONE)
{
int gadget_id_align = textbutton_info[i].gadget_id_align;
y = level_editor_gadget[gadget_id_align]->y;
}
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (textbutton_info[i].text_left != NULL)
x += getTextWidthForGadget(textbutton_info[i].text_left);
unsigned int event_mask;
int i;
- /* create buttons for scrolling of drawing area and element list */
+ // create buttons for scrolling of drawing area and element list
for (i = 0; i < ED_NUM_GRAPHICBUTTONS; i++)
{
int id = graphicbutton_info[i].gadget_id;
event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (graphicbutton_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[graphicbutton_info[i].gadget_id_align] +
ED_GADGET_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (graphicbutton_info[i].text_left != NULL)
x += getTextWidthForGadget(graphicbutton_info[i].text_left);
{
int i;
- /* these values are not constant, but can change at runtime */
+ // these values are not constant, but can change at runtime
scrollbar_pos[ED_SCROLLBAR_ID_AREA_HORIZONTAL].x =
SX + ED_SCROLL_HORIZONTAL_XPOS;
scrollbar_pos[ED_SCROLLBAR_ID_AREA_HORIZONTAL].y =
items_visible = ED_ELEMENTLIST_BUTTONS_VERT;
item_position = element_shift / ED_ELEMENTLIST_BUTTONS_HORIZ;
}
- else /* drawing area scrollbars */
+ else // drawing area scrollbars
{
if (scrollbar_info[i].type == GD_TYPE_SCROLLBAR_HORIZONTAL)
{
int x = SX + ED_SETTINGS_X(checkbutton_info[i].x);
int y = SY + ED_SETTINGS_Y(checkbutton_info[i].y);
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (checkbutton_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[checkbutton_info[i].gadget_id_align] +
ED_GADGET_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (checkbutton_info[i].text_left != NULL)
x += getTextWidthForGadget(checkbutton_info[i].text_left);
int checked =
(*radiobutton_info[i].value == radiobutton_info[i].checked_value);
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (radiobutton_info[i].gadget_id_align != GADGET_ID_NONE)
x = (right_gadget_border[radiobutton_info[i].gadget_id_align] +
ED_GADGET_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (radiobutton_info[i].text_left != NULL)
x += getTextWidthForGadget(radiobutton_info[i].text_left);
void CreateLevelEditorGadgets(void)
{
- /* force EDITOR font inside level editor */
+ // force EDITOR font inside level editor
SetFontStatus(GAME_MODE_EDITOR);
- /* these values are not constant, but can change at runtime */
+ // these values are not constant, but can change at runtime
ed_fieldx = MAX_ED_FIELDX - 1;
ed_fieldy = MAX_ED_FIELDY - 1;
CreateControlButtons();
CreateScrollbarGadgets();
- /* order of function calls is important because of cross-references */
+ // order of function calls is important because of cross-references
CreateCheckbuttonGadgets();
CreateCounterButtons();
CreateRadiobuttonGadgets();
int yoffset_above = font_height + ED_GADGET_LINE_DISTANCE;
int yoffset = (gi_down->height - font_height) / 2;
int x_left = gi_down->x - xoffset_left;
- int x_right; /* set after gadget position was modified */
+ int x_right; // set after gadget position was modified
int y_above = gi_down->y - yoffset_above;
int x = gi_down->x;
- int y; /* set after gadget position was modified */
+ int y; // set after gadget position was modified
- /* counter limits must be changed first to prevent value truncation */
+ // counter limits must be changed first to prevent value truncation
ModifyEditorCounterLimits(id, counterbutton_info[id].min_value,
counterbutton_info[id].max_value);
- /* right text position might have changed after setting position above */
+ // right text position might have changed after setting position above
x_right = gi_up->x + gi_up->width + xoffset_right;
ModifyEditorCounterValue(id, *counterbutton_info[id].value);
- /* set position for "value[1,2,3,4]" counter gadgets (score in most cases) */
+ // set position for "value[1,2,3,4]" counter gadgets (score in most cases)
if (id >= ED_COUNTER_ID_ELEMENT_VALUE1 &&
id <= ED_COUNTER_ID_ELEMENT_VALUE4)
{
SY + ED_SETTINGS_Y(counterbutton_info[id].y), GDI_END);
}
- /* vertical position might have changed after setting position above */
+ // vertical position might have changed after setting position above
y = gi_up->y + yoffset;
if (counterbutton_info[id].text_above)
int counter_id;
int i;
- /* map toolbox buttons (excluding special CE toolbox buttons) */
+ // map toolbox buttons (excluding special CE toolbox buttons)
for (i = 0; i < ED_NUM_CTRL1_2_BUTTONS; i++)
MapGadget(level_editor_gadget[i]);
- /* map toolbox buttons (element properties buttons) */
+ // map toolbox buttons (element properties buttons)
for (i = ED_NUM_CTRL1_4_BUTTONS; i < ED_NUM_CTRL1_7_BUTTONS; i++)
MapGadget(level_editor_gadget[i]);
if (use_permanent_palette)
{
- /* map buttons to select elements */
+ // map buttons to select elements
for (i = 0; i < ED_NUM_ELEMENTLIST_BUTTONS; i++)
MapGadget(level_editor_gadget[GADGET_ID_ELEMENTLIST_FIRST + i]);
MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL]);
MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_DOWN]);
}
- /* map buttons to select level */
+ // map buttons to select level
counter_id = ED_COUNTER_ID_SELECT_LEVEL;
counterbutton_info[counter_id].min_value = leveldir_current->first_level;
counterbutton_info[counter_id].max_value = leveldir_current->last_level;
int x = gi->x;
int y = gi->y + yoffset;
- /* only show button to delete change pages when more than minimum pages */
+ // only show button to delete change pages when more than minimum pages
if (id == ED_TEXTBUTTON_ID_DEL_CHANGE_PAGE &&
custom_element.num_change_pages == MIN_CHANGE_PAGES)
return;
int yoffset = (gi->height - font_height) / 2;
int y_above = gi->y - yoffset_above;
int x = gi->x;
- int x_left, x_right, y; /* set after gadget position was modified */
+ int x_left, x_right, y; // set after gadget position was modified
- /* set position for gadgets with dynamically determined position */
- if (checkbutton_info[id].x != -1) /* do not change dynamic positions */
+ // set position for gadgets with dynamically determined position
+ if (checkbutton_info[id].x != -1) // do not change dynamic positions
ModifyGadget(gi, GDI_X, SX + ED_SETTINGS_X(checkbutton_info[id].x),GDI_END);
ModifyGadget(gi, GDI_Y, SY + ED_SETTINGS_Y(checkbutton_info[id].y), GDI_END);
DrawPropertiesWindow();
else if (edit_mode == ED_MODE_PALETTE)
DrawPaletteWindow();
- else /* edit_mode == ED_MODE_DRAWING */
+ else // edit_mode == ED_MODE_DRAWING
DrawDrawingWindowExt(remap_toolbox_gadgets);
}
{
int i;
- /* change action mode and arg variables according to action type variable */
+ // change action mode and arg variables according to action type variable
for (i = 0; action_arg_options[i].value != -1; i++)
{
if (action_arg_options[i].value == custom_element_change.action_type)
{
int mode = action_arg_options[i].mode;
- /* only change if corresponding selectbox has changed */
+ // only change if corresponding selectbox has changed
if (selectbox_info[ED_SELECTBOX_ID_ACTION_MODE].options !=
action_arg_modes[mode])
custom_element_change.action_mode = -1;
- /* only change if corresponding selectbox has changed */
+ // only change if corresponding selectbox has changed
if (selectbox_info[ED_SELECTBOX_ID_ACTION_ARG].options !=
action_arg_options[i].options)
custom_element_change.action_arg = -1;
{
int i;
- /* change action mode and arg selectbox according to action type selectbox */
+ // change action mode and arg selectbox according to action type selectbox
for (i = 0; action_arg_options[i].value != -1; i++)
{
if (action_arg_options[i].value == custom_element_change.action_type)
change->target_content.e[x][y] = element_to;
}
- if (ei->group != NULL) /* group or internal */
+ if (ei->group != NULL) // group or internal
for (j = 0; j < MAX_ELEMENTS_IN_GROUP; j++)
if (ei->group->element[j] == element_from)
ei->group->element[j] = element_to;
level.changed = TRUE;
}
- /* when modifying custom/group element, ask for copying level template */
+ // when modifying custom/group element, ask for copying level template
if (copy_mode_orig != GADGET_ID_CUSTOM_COPY && level.use_custom_template)
{
if (!AskToCopyAndModifyLevelTemplate())
int i;
int current_change_page = element_info[element].current_change_page;
- /* dynamically (re)build selectbox for selecting change page */
+ // dynamically (re)build selectbox for selecting change page
for (i = 0; i < element_info[element].num_change_pages; i++)
{
sprintf(options_change_page_strings[i], "%d", i + 1);
options_change_page[i].value = -1;
options_change_page[i].text = NULL;
- /* needed here to initialize combined element properties */
+ // needed here to initialize combined element properties
InitElementPropertiesEngine(level.game_version);
element_info[element].change =
custom_element = element_info[element];
custom_element_change = *element_info[element].change;
- /* needed to initially set selectbox options for special action options */
+ // needed to initially set selectbox options for special action options
setSelectboxSpecialActionOptions();
- /* needed to initially set selectbox value variables to reliable defaults */
+ // needed to initially set selectbox value variables to reliable defaults
for (i = 0; i < ED_NUM_SELECTBOX; i++)
setSelectboxValue(i, *selectbox_info[i].value);
for (i = 0; i < NUM_CHANGE_EVENTS; i++)
custom_element_change_events[i] = HAS_CHANGE_EVENT(element, i);
- /* ---------- element settings: configure (custom elements) ------------- */
+ // ---------- element settings: configure (custom elements) -----------------
- /* set accessible layer selectbox help value */
+ // set accessible layer selectbox help value
custom_element.access_type =
(IS_WALKABLE(element) ? EP_WALKABLE :
IS_PASSABLE(element) ? EP_PASSABLE :
IS_ACCESSIBLE_INSIDE(element) ||
IS_ACCESSIBLE_UNDER(element));
- /* set walk-to-object action selectbox help value */
+ // set walk-to-object action selectbox help value
custom_element.walk_to_action =
(IS_DIGGABLE(element) ? EP_DIGGABLE :
IS_COLLECTIBLE_ONLY(element) ? EP_COLLECTIBLE_ONLY :
IS_THROWABLE(element) ||
IS_PUSHABLE(element));
- /* set smash targets selectbox help value */
+ // set smash targets selectbox help value
custom_element.smash_targets =
(CAN_SMASH_EVERYTHING(element) ? EP_CAN_SMASH_EVERYTHING :
CAN_SMASH_ENEMIES(element) ? EP_CAN_SMASH_ENEMIES :
CAN_SMASH_ENEMIES(element) ||
CAN_SMASH_PLAYER(element));
- /* set deadliness selectbox help value */
+ // set deadliness selectbox help value
custom_element.deadliness =
(DONT_TOUCH(element) ? EP_DONT_TOUCH :
DONT_GET_HIT_BY(element) ? EP_DONT_GET_HIT_BY :
DONT_COLLIDE_WITH(element) ||
DONT_RUN_INTO(element));
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
- /* set "change by direct action" selectbox help value */
+ // set "change by direct action" selectbox help value
custom_element_change.direct_action =
(HAS_CHANGE_EVENT(element, CE_TOUCHED_BY_PLAYER) ? CE_TOUCHED_BY_PLAYER :
HAS_CHANGE_EVENT(element, CE_PRESSED_BY_PLAYER) ? CE_PRESSED_BY_PLAYER :
HAS_CHANGE_EVENT(element, CE_SCORE_GETS_ZERO) ? CE_SCORE_GETS_ZERO :
custom_element_change.direct_action);
- /* set "change by other element action" selectbox help value */
+ // set "change by other element action" selectbox help value
custom_element_change.other_action =
(HAS_CHANGE_EVENT(element, CE_PLAYER_TOUCHES_X) ? CE_PLAYER_TOUCHES_X :
HAS_CHANGE_EVENT(element, CE_PLAYER_PRESSES_X) ? CE_PLAYER_PRESSES_X :
static void CopyGroupElementPropertiesToEditor(int element)
{
group_element_info = *element_info[element].group;
- custom_element = element_info[element]; /* needed for description */
+ custom_element = element_info[element]; // needed for description
}
static void CopyClassicElementPropertiesToEditor(int element)
}
else
{
- LoadLevelTemplate(-1); /* this resets all element modifications ... */
+ LoadLevelTemplate(-1); // this resets all element modifications ...
- DrawEditModeWindow(); /* ... and copies them to 'custom_element' */
+ DrawEditModeWindow(); // ... and copies them to 'custom_element'
return FALSE;
}
int i;
int access_type_and_layer;
- /* mark that this custom element has been modified */
+ // mark that this custom element has been modified
custom_element.modified_settings = TRUE;
level.changed = TRUE;
element_info[element] = custom_element;
*element_info[element].change = custom_element_change;
- /* ---------- element settings: configure (custom elements) ------------- */
+ // ---------- element settings: configure (custom elements) -----------------
- /* set accessible property from checkbox and selectbox */
+ // set accessible property from checkbox and selectbox
custom_element_properties[EP_WALKABLE_OVER] = FALSE;
custom_element_properties[EP_WALKABLE_INSIDE] = FALSE;
custom_element_properties[EP_WALKABLE_UNDER] = FALSE;
(custom_element.access_protected != 0 &&
custom_element_properties[EP_ACCESSIBLE]);
- /* set walk-to-object property from checkbox and selectbox */
+ // set walk-to-object property from checkbox and selectbox
custom_element_properties[EP_DIGGABLE] = FALSE;
custom_element_properties[EP_COLLECTIBLE_ONLY] = FALSE;
custom_element_properties[EP_DROPPABLE] = FALSE;
custom_element_properties[custom_element.walk_to_action] =
custom_element_properties[EP_WALK_TO_OBJECT];
- /* set smash property from checkbox and selectbox */
+ // set smash property from checkbox and selectbox
custom_element_properties[EP_CAN_SMASH_PLAYER] = FALSE;
custom_element_properties[EP_CAN_SMASH_ENEMIES] = FALSE;
custom_element_properties[EP_CAN_SMASH_EVERYTHING] = FALSE;
custom_element_properties[custom_element.smash_targets] =
custom_element_properties[EP_CAN_SMASH];
- /* set deadliness property from checkbox and selectbox */
+ // set deadliness property from checkbox and selectbox
custom_element_properties[EP_DONT_RUN_INTO] = FALSE;
custom_element_properties[EP_DONT_COLLIDE_WITH] = FALSE;
custom_element_properties[EP_DONT_GET_HIT_BY] = FALSE;
custom_element_properties[custom_element.deadliness] =
custom_element_properties[EP_DEADLY];
- /* ---------- element settings: advanced (custom elements) --------------- */
+ // ---------- element settings: advanced (custom elements) ------------------
- /* set player change event from checkbox and selectbox */
+ // set player change event from checkbox and selectbox
custom_element_change_events[CE_TOUCHED_BY_PLAYER] = FALSE;
custom_element_change_events[CE_PRESSED_BY_PLAYER] = FALSE;
custom_element_change_events[CE_SWITCHED_BY_PLAYER] = FALSE;
custom_element_change_events[custom_element_change.direct_action] =
custom_element_change_events[CE_BY_DIRECT_ACTION];
- /* set other element action change event from checkbox and selectbox */
+ // set other element action change event from checkbox and selectbox
custom_element_change_events[CE_PLAYER_TOUCHES_X] = FALSE;
custom_element_change_events[CE_PLAYER_PRESSES_X] = FALSE;
custom_element_change_events[CE_PLAYER_SWITCHES_X] = FALSE;
for (i = 0; i < NUM_CHANGE_EVENTS; i++)
SET_CHANGE_EVENT(element, i, custom_element_change_events[i]);
- /* copy change events also to special level editor variable */
+ // copy change events also to special level editor variable
custom_element = element_info[element];
custom_element_change = *element_info[element].change;
}
static void CopyGroupElementPropertiesToGame(int element)
{
- /* mark that this group element has been modified */
+ // mark that this group element has been modified
custom_element.modified_settings = TRUE;
level.changed = TRUE;
static void DrawEditorDoorContent(void)
{
- /* needed for gadgets drawn on background (like palette scrollbar) */
+ // needed for gadgets drawn on background (like palette scrollbar)
SetDoorBackgroundImage(IMG_UNDEFINED);
- /* copy default editor door content to main double buffer */
+ // copy default editor door content to main double buffer
BlitBitmap(graphic_info[IMG_BACKGROUND_PALETTE].bitmap, drawto,
graphic_info[IMG_BACKGROUND_PALETTE].src_x,
graphic_info[IMG_BACKGROUND_PALETTE].src_y,
MIN(DYSIZE, graphic_info[IMG_BACKGROUND_PALETTE].height),
DX, DY);
- /* draw bigger door */
+ // draw bigger door
DrawSpecialEditorDoor();
- /* draw new control window */
+ // draw new control window
BlitBitmap(graphic_info[IMG_BACKGROUND_TOOLBOX].bitmap, drawto,
graphic_info[IMG_BACKGROUND_TOOLBOX].src_x,
graphic_info[IMG_BACKGROUND_TOOLBOX].src_y,
MIN(EYSIZE, graphic_info[IMG_BACKGROUND_TOOLBOX].height),
EX, EY);
- /* draw all toolbox gadgets to editor doors */
+ // draw all toolbox gadgets to editor doors
MapControlButtons();
- /* draw all palette gadgets to editor doors */
+ // draw all palette gadgets to editor doors
ModifyEditorElementList();
RedrawDrawingElements();
- /* copy actual editor door content to door double buffer for OpenDoor() */
+ // copy actual editor door content to door double buffer for OpenDoor()
BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
}
FadeOut(fade_mask);
- /* needed if different viewport properties defined for editor */
+ // needed if different viewport properties defined for editor
ChangeViewportPropertiesIfNeeded();
ClearField();
FreeLevelEditorGadgets();
CreateLevelEditorGadgets();
- ReinitializeElementList(); /* update dynamic level element list */
- ReinitializeElementListButtons(); /* custom element may look different */
+ ReinitializeElementList(); // update dynamic level element list
+ ReinitializeElementListButtons(); // custom element may look different
InitElementPropertiesGfxElement();
ed_ysize = max_ed_fieldy;
}
- /* check if we need any scrollbars */
+ // check if we need any scrollbars
horizontal_scrollbar_needed = (ed_xsize > max_ed_fieldx);
vertical_scrollbar_needed = (ed_ysize > max_ed_fieldy);
- /* check if we have a smaller editor field because of scrollbars */
+ // check if we have a smaller editor field because of scrollbars
max_ed_fieldx = getMaxEdFieldX(vertical_scrollbar_needed);
max_ed_fieldy = getMaxEdFieldY(horizontal_scrollbar_needed);
- /* check again if we now need more scrollbars because of less space */
+ // check again if we now need more scrollbars because of less space
horizontal_scrollbar_needed = (ed_xsize > max_ed_fieldx);
vertical_scrollbar_needed = (ed_ysize > max_ed_fieldy);
- /* check if editor field gets even smaller after adding new scrollbars */
+ // check if editor field gets even smaller after adding new scrollbars
max_ed_fieldx = getMaxEdFieldX(vertical_scrollbar_needed);
max_ed_fieldy = getMaxEdFieldY(horizontal_scrollbar_needed);
width = ed_fieldx * ed_tilesize - 2 * ED_SCROLLBUTTON_XSIZE;
height = ed_fieldy * ed_tilesize - 2 * ED_SCROLLBUTTON_YSIZE;
- /* adjust drawing area gadget */
+ // adjust drawing area gadget
ModifyGadget(level_editor_gadget[GADGET_ID_DRAWING_LEVEL],
GDI_AREA_SIZE, ed_fieldx, ed_fieldy,
GDI_ITEM_SIZE, ed_tilesize, ed_tilesize,
GDI_END);
- /* adjust horizontal scrollbar gadgets */
+ // adjust horizontal scrollbar gadgets
ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_LEFT],
GDI_Y, y,
GDI_END);
GDI_SCROLLBAR_ITEMS_VISIBLE, ed_fieldx,
GDI_END);
- /* adjust vertical scrollbar gadgets */
+ // adjust vertical scrollbar gadgets
ModifyGadget(level_editor_gadget[GADGET_ID_SCROLL_UP],
GDI_X, x,
GDI_END);
struct GadgetInfo *gi = level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL];
int items_max, items_visible, item_position;
- /* correct position of element list scrollbar */
+ // correct position of element list scrollbar
if (element_shift < 0)
element_shift = 0;
if (element_shift > num_editor_elements - ED_NUM_ELEMENTLIST_BUTTONS)
selectbox_info[selectbox_id].options = options;
- /* set index to zero -- list may be shorter now (correct later, if needed) */
+ // set index to zero -- list may be shorter now (correct later, if needed)
ModifyGadget(gi, GDI_SELECTBOX_INDEX, 0,
GDI_SELECTBOX_OPTIONS, options, GDI_END);
}
struct GadgetInfo *gi = level_editor_gadget[gadget_id];
boolean active = (i != edit_mode_levelinfo);
- /* draw background line below tabulator button */
+ // draw background line below tabulator button
ClearRectangleOnBackground(drawto, gi->x, gi->y + gi->height, gi->width, 1);
- /* draw solid line below inactive tabulator buttons */
- if (!active && tab_color != BLACK_PIXEL) /* black => transparent */
+ // draw solid line below inactive tabulator buttons
+ if (!active && tab_color != BLACK_PIXEL) // black => transparent
FillRectangle(drawto, gi->x, gi->y + gi->height, gi->width,
ED_GADGET_TINY_DISTANCE, tab_color);
MapTextbuttonGadget(i);
}
- /* draw little border line below tabulator buttons */
- if (tab_color != BLACK_PIXEL) /* black => transparent */
+ // draw little border line below tabulator buttons
+ if (tab_color != BLACK_PIXEL) // black => transparent
FillRectangle(drawto, gd_gi1->x, gd_gi1->y + gd_gi1->height +
ED_GADGET_TINY_DISTANCE,
getTabulatorBarWidth(), getTabulatorBarHeight(), tab_color);
int id_last = ED_TEXTBUTTON_ID_PROPERTIES_CONFIG;
int i;
- /* draw two config tabulators for player elements */
+ // draw two config tabulators for player elements
if (ELEM_IS_PLAYER(properties_element))
id_last = ED_TEXTBUTTON_ID_PROPERTIES_CONFIG_2;
- /* draw two config and one "change" tabulator for custom elements */
+ // draw two config and one "change" tabulator for custom elements
if (IS_CUSTOM_ELEMENT(properties_element))
id_last = ED_TEXTBUTTON_ID_PROPERTIES_CHANGE;
struct GadgetInfo *gi = level_editor_gadget[gadget_id];
boolean active = (i != edit_mode_properties);
- /* use "config 1" and "config 2" instead of "config" for players and CEs */
+ // use "config 1" and "config 2" instead of "config" for players and CEs
if (i == ED_TEXTBUTTON_ID_PROPERTIES_CONFIG &&
(ELEM_IS_PLAYER(properties_element) ||
IS_CUSTOM_ELEMENT(properties_element)))
continue;
- /* draw background line below tabulator button */
+ // draw background line below tabulator button
ClearRectangleOnBackground(drawto, gi->x, gi->y + gi->height, gi->width, 1);
- /* draw solid line below inactive tabulator buttons */
- if (!active && tab_color != BLACK_PIXEL) /* black => transparent */
+ // draw solid line below inactive tabulator buttons
+ if (!active && tab_color != BLACK_PIXEL) // black => transparent
FillRectangle(drawto, gi->x, gi->y + gi->height, gi->width,
ED_GADGET_TINY_DISTANCE, tab_color);
MapTextbuttonGadget(i);
}
- /* draw little border line below tabulator buttons */
- if (tab_color != BLACK_PIXEL) /* black => transparent */
+ // draw little border line below tabulator buttons
+ if (tab_color != BLACK_PIXEL) // black => transparent
FillRectangle(drawto, gd_gi1->x, gd_gi1->y + gd_gi1->height +
ED_GADGET_TINY_DISTANCE,
getTabulatorBarWidth(), getTabulatorBarHeight(), tab_color);
{
int i;
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_LEVEL_FIRST; i <= ED_COUNTER_ID_LEVEL_LAST; i++)
MapCounterButtons(i);
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i = ED_CHECKBUTTON_ID_LEVEL_FIRST; i<= ED_CHECKBUTTON_ID_LEVEL_LAST; i++)
MapCheckbuttonGadget(i);
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
for (i = ED_SELECTBOX_ID_LEVEL_FIRST; i <= ED_SELECTBOX_ID_LEVEL_LAST; i++)
MapSelectboxGadget(i);
- /* draw text input gadgets */
+ // draw text input gadgets
for (i = ED_TEXTINPUT_ID_LEVEL_FIRST; i <= ED_TEXTINPUT_ID_LEVEL_LAST; i++)
MapTextInputGadget(i);
}
boolean template_exists = fileExists(getLocalLevelTemplateFilename());
int i;
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_LEVELSET_FIRST; i <= ED_COUNTER_ID_LEVELSET_LAST; i++)
MapCounterButtons(i);
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i = ED_CHECKBUTTON_ID_LEVELSET_FIRST; i <= ED_CHECKBUTTON_ID_LEVELSET_LAST; i++)
{
if (levelset_save_mode == LEVELSET_SAVE_MODE_UPDATE ||
MapCheckbuttonGadget(i);
}
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
for (i = ED_SELECTBOX_ID_LEVELSET_FIRST; i <= ED_SELECTBOX_ID_LEVELSET_LAST; i++)
MapSelectboxGadget(i);
- /* draw text input gadgets */
+ // draw text input gadgets
for (i = ED_TEXTINPUT_ID_LEVELSET_FIRST; i <= ED_TEXTINPUT_ID_LEVELSET_LAST; i++)
MapTextInputGadget(i);
- /* draw textbutton gadgets */
+ // draw textbutton gadgets
MapTextbuttonGadget(ED_TEXTBUTTON_ID_SAVE_LEVELSET);
- /* draw info text */
+ // draw info text
DrawLevelInfoLevelSet_DirectoryInfo();
}
{
int i;
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_EDITOR_FIRST; i <= ED_COUNTER_ID_EDITOR_LAST; i++)
MapCounterButtons(i);
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i=ED_CHECKBUTTON_ID_EDITOR_FIRST; i<= ED_CHECKBUTTON_ID_EDITOR_LAST; i++)
MapCheckbuttonGadget(i);
- /* draw radiobutton gadgets */
+ // draw radiobutton gadgets
for (i=ED_RADIOBUTTON_ID_EDITOR_FIRST; i<= ED_RADIOBUTTON_ID_EDITOR_LAST; i++)
MapRadiobuttonGadget(i);
- /* draw drawing area */
+ // draw drawing area
MapDrawingArea(ED_DRAWING_ID_RANDOM_BACKGROUND);
- /* draw textbutton gadgets */
+ // draw textbutton gadgets
MapTextbuttonGadget(ED_TEXTBUTTON_ID_SAVE_AS_TEMPLATE_2);
}
int x3 = right_gadget_border[GADGET_ID_CUSTOM_EXPLODE_IMPACT];
int xoffset = ED_GADGET_SPACE_DISTANCE;
- /* add distance for potential left text (without drawing area border) */
+ // add distance for potential left text (without drawing area border)
x2 += getTextWidthForGadget(drawingarea_info[id].text_left);
ModifyGadget(gi, GDI_X, MAX(x1, MAX(x2, x3)) + xoffset, GDI_END);
int y = SY + ED_AREA_YAMYAM_CONTENT_Y(3) + yoffset;
int i;
- /* display counter to choose number of element content areas */
+ // display counter to choose number of element content areas
MapCounterButtons(ED_COUNTER_ID_YAMYAM_CONTENT);
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
{
UnmapDrawingArea(id);
- /* delete content areas in case of reducing number of them */
+ // delete content areas in case of reducing number of them
RemoveElementContentArea(id, font_height);
}
}
int y = SY + ED_AREA_MAGIC_BALL_CONTENT_Y(3) + yoffset;
int i;
- /* display counter to choose number of element content areas */
+ // display counter to choose number of element content areas
MapCounterButtons(ED_COUNTER_ID_BALL_CONTENT);
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
{
UnmapDrawingArea(id);
- /* delete content areas in case of reducing number of them */
+ // delete content areas in case of reducing number of them
RemoveElementContentArea(id, font_height);
}
}
int xsize = MAX_ANDROID_ELEMENTS;
int ysize = 1;
- /* display counter to choose number of element areas */
+ // display counter to choose number of element areas
MapCounterButtons(ED_COUNTER_ID_ANDROID_CONTENT);
if (drawingarea_info[id].text_left != NULL)
ModifyEditorDrawingArea(id, num_elements, 1);
- /* delete content areas in case of reducing number of them */
+ // delete content areas in case of reducing number of them
DrawBackground(sx, sy,
xsize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size,
ysize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size);
ModifyEditorDrawingArea(id, num_elements, 1);
- /* delete content areas in case of reducing number of them */
+ // delete content areas in case of reducing number of them
DrawBackground(sx, sy,
xsize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size,
ysize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size);
int xsize = MAX_INITIAL_INVENTORY_SIZE;
int ysize = 1;
- /* determine horizontal position to the right of specified gadget */
+ // determine horizontal position to the right of specified gadget
if (drawingarea_info[id].gadget_id_align != GADGET_ID_NONE)
sx = (right_gadget_border[drawingarea_info[id].gadget_id_align] +
ED_DRAWINGAREA_TEXT_DISTANCE);
- /* determine horizontal offset for leading text */
+ // determine horizontal offset for leading text
if (drawingarea_info[id].text_left != NULL)
sx += getTextWidthForDrawingArea(drawingarea_info[id].text_left);
ModifyEditorDrawingArea(id, num_elements, 1);
- /* delete content areas in case of reducing number of them */
+ // delete content areas in case of reducing number of them
DrawBackground(sx, sy,
xsize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size,
ysize * ED_DRAWINGAREA_TILE_SIZE + 2 * border_size);
}
properties[] =
{
- /* configurable properties */
+ // configurable properties
{ EP_WALKABLE_OVER, "- player can walk over it" },
{ EP_WALKABLE_INSIDE, "- player can walk inside it" },
{ EP_CAN_CHANGE, "- can change to other element" },
- /* pre-defined properties */
+ // pre-defined properties
{ EP_CAN_PASS_MAGIC_WALL, "- can pass magic walls" },
{ EP_CAN_PASS_DC_MAGIC_WALL,"- can pass magic walls (DC style)" },
{ EP_SWITCHABLE, "- can be switched" },
ypos += 2 * font3_height;
}
- /* ----- print number of elements / percentage of this element in level */
+ // ----- print number of elements / percentage of this element in level
num_elements_in_level = 0;
for (y = 0; y < lev_fieldy; y++)
ypos += 2 * MAX(font1_height, font2_height);
- /* ----- print standard properties of this element */
+ // ----- print standard properties of this element
DrawTextS(xpos, ypos, font1_nr, properties_text);
ypos += MAX(font1_height, font2_height);
- /* ----- print special description of this element */
+ // ----- print special description of this element
PrintInfoText(description_text, font1_nr, xpos, ypos);
return;
}
- /* check if there are elements where a value can be chosen for */
+ // check if there are elements where a value can be chosen for
for (i = 0; elements_with_counter[i].element != -1; i++)
{
if (elements_with_counter[i].element == properties_element)
if (properties_element == EL_GAME_OF_LIFE ||
properties_element == EL_BIOMAZE)
{
- counterbutton_info[counter_id].min_value = 0; /* min neighbours */
- counterbutton_info[counter_id].max_value = 8; /* max neighbours */
+ counterbutton_info[counter_id].min_value = 0; // min neighbours
+ counterbutton_info[counter_id].max_value = 8; // max neighbours
}
else
{
- /* !!! CHANGE THIS FOR CERTAIN ELEMENTS !!! */
+ // !!! CHANGE THIS FOR CERTAIN ELEMENTS !!!
counterbutton_info[counter_id].min_value = MIN_SCORE;
counterbutton_info[counter_id].max_value = MAX_SCORE;
}
if (HAS_EDITOR_CONTENT(properties_element))
{
- /* draw stickybutton gadget */
+ // draw stickybutton gadget
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_STICK_ELEMENT);
if (IS_AMOEBOID(properties_element))
{
int player_nr = GET_PLAYER_NR(properties_element);
- /* these properties can be set for every player individually */
+ // these properties can be set for every player individually
if (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG_1)
{
checkbutton_info[ED_CHECKBUTTON_ID_USE_INITIAL_INVENTORY].value =
&level.use_initial_inventory[player_nr];
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_USE_INITIAL_INVENTORY);
- /* draw counter gadgets */
+ // draw counter gadgets
MapCounterButtons(ED_COUNTER_ID_INVENTORY_SIZE);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
DrawPlayerInitialInventoryArea(properties_element);
}
}
(!IS_CUSTOM_ELEMENT(properties_element) ||
edit_mode_properties == ED_MODE_PROPERTIES_CONFIG_2))
{
- /* set position for checkbutton for "can move into acid" */
+ // set position for checkbutton for "can move into acid"
checkbutton_info[ED_CHECKBUTTON_ID_CAN_MOVE_INTO_ACID].x =
ED_ELEMENT_SETTINGS_XPOS(IS_CUSTOM_ELEMENT(properties_element) ? 1 : 0);
checkbutton_info[ED_CHECKBUTTON_ID_CAN_MOVE_INTO_ACID].y =
checkbutton_info[button1_id].value = &level.envelope[envelope_nr].autowrap;
checkbutton_info[button2_id].value = &level.envelope[envelope_nr].centered;
- /* display counter to choose size of envelope text area */
+ // display counter to choose size of envelope text area
MapCounterButtons(counter1_id);
MapCounterButtons(counter2_id);
- /* display checkbuttons to choose auto-wrap and alignment properties */
+ // display checkbuttons to choose auto-wrap and alignment properties
MapCheckbuttonGadget(button1_id);
MapCheckbuttonGadget(button2_id);
if (IS_CUSTOM_ELEMENT(properties_element))
{
- /* draw stickybutton gadget */
+ // draw stickybutton gadget
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_STICK_ELEMENT);
if (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG_1)
{
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i = ED_CHECKBUTTON_ID_CUSTOM1_FIRST;
i <= ED_CHECKBUTTON_ID_CUSTOM1_LAST; i++)
MapCheckbuttonGadget(i);
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_CUSTOM1_FIRST;
i <= ED_COUNTER_ID_CUSTOM1_LAST; i++)
MapCounterButtons(i);
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
for (i = ED_SELECTBOX_ID_CUSTOM1_FIRST;
i <= ED_SELECTBOX_ID_CUSTOM1_LAST; i++)
MapSelectboxGadget(i);
- /* draw textbutton gadgets */
+ // draw textbutton gadgets
MapTextbuttonGadget(ED_TEXTBUTTON_ID_SAVE_AS_TEMPLATE_1);
- /* draw text input gadgets */
+ // draw text input gadgets
MapTextInputGadget(ED_TEXTINPUT_ID_ELEMENT_NAME);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
MapDrawingArea(ED_DRAWING_ID_CUSTOM_GRAPHIC);
draw_footer_line = TRUE;
}
else if (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG_2)
{
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i = ED_CHECKBUTTON_ID_CUSTOM2_FIRST;
i <= ED_CHECKBUTTON_ID_CUSTOM2_LAST; i++)
MapCheckbuttonGadget(i);
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_CUSTOM2_FIRST;
i <= ED_COUNTER_ID_CUSTOM2_LAST; i++)
MapCounterButtons(i);
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
for (i = ED_SELECTBOX_ID_CUSTOM2_FIRST;
i <= ED_SELECTBOX_ID_CUSTOM2_LAST; i++)
MapSelectboxGadget(i);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
MapDrawingArea(ED_DRAWING_ID_CUSTOM_MOVE_ENTER);
MapDrawingArea(ED_DRAWING_ID_CUSTOM_MOVE_LEAVE);
DrawCustomContentArea();
}
else if (IS_GROUP_ELEMENT(properties_element))
{
- /* draw stickybutton gadget */
+ // draw stickybutton gadget
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_STICK_ELEMENT);
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_CUSTOM_USE_GRAPHIC);
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_CUSTOM_USE_TEMPLATE_1);
- /* draw counter gadgets */
+ // draw counter gadgets
MapCounterButtons(ED_COUNTER_ID_GROUP_CONTENT);
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
MapSelectboxGadget(ED_SELECTBOX_ID_GROUP_CHOICE_MODE);
- /* draw textbutton gadgets */
+ // draw textbutton gadgets
MapTextbuttonGadget(ED_TEXTBUTTON_ID_SAVE_AS_TEMPLATE_1);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
DrawGroupElementArea(properties_element);
- /* draw text input gadgets */
+ // draw text input gadgets
MapTextInputGadget(ED_TEXTINPUT_ID_ELEMENT_NAME);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
MapDrawingArea(ED_DRAWING_ID_CUSTOM_GRAPHIC);
draw_footer_line = TRUE;
}
- /* draw little footer border line above CE/GE use/save template gadgets */
+ // draw little footer border line above CE/GE use/save template gadgets
if (draw_footer_line)
{
struct GadgetInfo *gd_gi1 = level_editor_gadget[GADGET_ID_PROPERTIES_INFO];
int gd_y = gd->y + gd_gi1->height - 1;
Pixel tab_color = GetPixel(gd->bitmap, gd_x, gd_y);
- if (tab_color != BLACK_PIXEL) /* black => transparent */
+ if (tab_color != BLACK_PIXEL) // black => transparent
FillRectangle(drawto,
SX + ED_ELEMENT_SETTINGS_X(0),
SY + ED_ELEMENT_SETTINGS_Y(14) - ED_SETTINGS_TABS_YOFFSET -
{
int i;
- /* needed to initially set selectbox options for special action options */
+ // needed to initially set selectbox options for special action options
setSelectboxSpecialActionOptions();
- /* draw stickybutton gadget */
+ // draw stickybutton gadget
MapCheckbuttonGadget(ED_CHECKBUTTON_ID_STICK_ELEMENT);
- /* draw checkbutton gadgets */
+ // draw checkbutton gadgets
for (i = ED_CHECKBUTTON_ID_CHANGE_FIRST;
i <= ED_CHECKBUTTON_ID_CHANGE_LAST; i++)
MapCheckbuttonGadget(i);
- /* draw counter gadgets */
+ // draw counter gadgets
for (i = ED_COUNTER_ID_CHANGE_FIRST;
i <= ED_COUNTER_ID_CHANGE_LAST; i++)
MapCounterButtons(i);
- /* draw selectbox gadgets */
+ // draw selectbox gadgets
for (i = ED_SELECTBOX_ID_CHANGE_FIRST;
i <= ED_SELECTBOX_ID_CHANGE_LAST; i++)
MapSelectboxGadget(i);
- /* draw textbutton gadgets */
+ // draw textbutton gadgets
for (i = ED_TEXTBUTTON_ID_CHANGE_FIRST;
i <= ED_TEXTBUTTON_ID_CHANGE_LAST; i++)
MapTextbuttonGadget(i);
- /* draw graphicbutton gadgets */
+ // draw graphicbutton gadgets
for (i = ED_GRAPHICBUTTON_ID_CHANGE_FIRST;
i <= ED_GRAPHICBUTTON_ID_CHANGE_LAST; i++)
MapGraphicbuttonGadget(i);
- /* draw drawing area gadgets */
+ // draw drawing area gadgets
DrawPropertiesChangeDrawingAreas();
}
stick_element_properties_window = FALSE;
- /* make sure that previous properties edit mode exists for this element */
+ // make sure that previous properties edit mode exists for this element
if (edit_mode_properties > ED_MODE_PROPERTIES_CONFIG_2 &&
!IS_CUSTOM_ELEMENT(properties_element))
edit_mode_properties = ED_MODE_PROPERTIES_CONFIG_2;
DrawText(sx, sy, text, font2_nr);
- FrameCounter = 0; /* restart animation frame counter */
+ FrameCounter = 0; // restart animation frame counter
DrawElementBorder(SX + x1, SY + y1, TILEX, TILEY, FALSE);
DrawEditorElementAnimation(SX + x1, SY + y1);
DrawPropertiesInfo();
else if (edit_mode_properties == ED_MODE_PROPERTIES_CHANGE)
DrawPropertiesChange();
- else /* (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG[_1|_2]) */
+ else // (edit_mode_properties == ED_MODE_PROPERTIES_CONFIG[_1|_2])
DrawPropertiesConfig();
}
SetMainBackgroundImage(IMG_BACKGROUND_EDITOR);
ClearField();
- /* map buttons to select elements */
+ // map buttons to select elements
for (i = 0; i < ED_NUM_ELEMENTLIST_BUTTONS; i++)
MapGadget(level_editor_gadget[GADGET_ID_ELEMENTLIST_FIRST + i]);
MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL]);
ModifyEditorElementList();
RedrawDrawingElements();
- /* force redraw of all mapped drawing area gadgets */
+ // force redraw of all mapped drawing area gadgets
for (i = 0; i < ED_NUM_DRAWING_AREAS; i++)
{
struct GadgetInfo *gi = level_editor_gadget[drawingarea_info[i].gadget_id];
case (MV_VERTICAL | MV_RIGHT): return EL_TUBE_VERTICAL_RIGHT;
case (MV_ANY_DIRECTION): return EL_TUBE_ANY;
- /* if only one direction, fall back to simple tube with that direction */
+ // if only one direction, fall back to simple tube with that direction
case (MV_LEFT): return EL_TUBE_HORIZONTAL;
case (MV_RIGHT): return EL_TUBE_HORIZONTAL;
case (MV_UP): return EL_TUBE_VERTICAL;
int (*close_function)(int, int),
boolean change_level)
{
- /* set neighbour elements to newly determined connections */
+ // set neighbour elements to newly determined connections
SetElementSimple(x1, y1, *element1, change_level);
SetElementSimple(x2, y2, *element2, change_level);
- /* remove all open connections of neighbour elements */
+ // remove all open connections of neighbour elements
*element1 = close_function(x1, y1);
*element2 = close_function(x2, y2);
- /* set neighbour elements to new, minimized connections */
+ // set neighbour elements to new, minimized connections
SetElementSimple(x1, y1, *element1, change_level);
SetElementSimple(x2, y2, *element2, change_level);
}
int direction = MV_NONE;
int i;
- /* if old element is of same kind, keep all existing directions */
+ // if old element is of same kind, keep all existing directions
if (IS_TUBE(old_element))
direction |= getOpenDirectionFromTube(old_element);
int direction = MV_NONE;
int i;
- /* if old element is of same kind, keep all existing directions */
+ // if old element is of same kind, keep all existing directions
if (IS_BELT(old_element))
direction |= getOpenDirectionFromBelt(old_element);
int direction = MV_NONE;
int i;
- /* if old element is of same kind, keep all existing directions */
+ // if old element is of same kind, keep all existing directions
if (IS_ACID_POOL_OR_ACID(old_element))
direction |= getOpenDirectionFromPool(old_element);
}
}
- /* special corrections needed for intuitively correct acid pool drawing */
+ // special corrections needed for intuitively correct acid pool drawing
if (last_element_new == EL_EMPTY)
last_element_new = new_element;
else if (last_element_new != EL_UNDEFINED)
int direction = MV_NONE;
int i;
- /* if old element is of same kind, keep all existing directions */
+ // if old element is of same kind, keep all existing directions
if (IS_EMC_PILLAR(old_element))
direction |= getOpenDirectionFromPillar(old_element);
int direction = MV_NONE;
int i;
- /* if old element is of same kind, keep all existing directions */
+ // if old element is of same kind, keep all existing directions
if (IS_DC_STEELWALL_2(old_element))
direction |= getOpenDirectionFromSteel2(old_element);
int direction = MV_NONE;
int i;
- /* (do not keep existing directions, regardless of kind of old element) */
+ // (do not keep existing directions, regardless of kind of old element)
for (i = 0; i < NUM_DIRECTIONS; i++)
{
int dy = (to_y < from_y ? -1 : +1);
int i;
- if (from_y == to_y) /* horizontal line */
+ if (from_y == to_y) // horizontal line
{
for (i = 0; i <= xsize; i++)
DrawLineElement(from_x + i * dx, from_y, element, change_level);
}
- else if (from_x == to_x) /* vertical line */
+ else if (from_x == to_x) // vertical line
{
for (i = 0; i <= ysize; i++)
DrawLineElement(from_x, from_y + i * dy, element, change_level);
}
- else /* diagonal line */
+ else // diagonal line
{
- if (ysize < xsize) /* a < 1 */
+ if (ysize < xsize) // a < 1
{
float a = (float)ysize / (float)xsize;
DrawLineElement(from_x + x, from_y + y, element, change_level);
}
}
- else /* a >= 1 */
+ else // a >= 1
{
float a = (float)xsize / (float)ysize;
DrawAreaBorder(from_x, from_y, to_x, to_y);
}
-/* values for CopyBrushExt() */
+// values for CopyBrushExt()
#define CB_AREA_TO_BRUSH 0
#define CB_BRUSH_TO_CURSOR 1
#define CB_BRUSH_TO_LEVEL 2
SetLevelElementHiRes(x, y, FillFeld[x][y]);
}
-/* values for DrawLevelText() modes */
+// values for DrawLevelText() modes
#define TEXT_INIT 0
#define TEXT_SETCURSOR 1
#define TEXT_WRITECHAR 2
int letter_element = EL_CHAR_ASCII0 + letter;
int lx = 0, ly = 0;
- /* map lower case letters to upper case and convert special characters */
+ // map lower case letters to upper case and convert special characters
if (letter >= 'a' && letter <= 'z')
letter_element = EL_CHAR_ASCII0 + letter + (int)('A' - 'a');
else if (letter == CHAR_BYTE_UMLAUT_a || letter == CHAR_BYTE_UMLAUT_A)
if (new_undo_buffer_position)
{
- /* advance position in undo buffer ring */
+ // advance 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++;
}
- /* always reset redo buffer when storing level change into undo buffer */
+ // always reset redo buffer when storing level change into undo buffer
redo_buffer_steps = 0;
for (x = 0; x < lev_fieldx; x++)
for (y = 0; y < lev_fieldy; y++)
UndoBuffer[undo_buffer_position][x][y] = Feld[x][y];
- /* check if drawing operation forces change of border style */
+ // check if drawing operation forces change of border style
CheckLevelBorderElement(TRUE);
level.changed = TRUE;
ResetIntelliDraw();
- /* determine number of free positions for randomly placing the new element */
+ // determine number of free positions for randomly placing the new element
for (x = 0; x < lev_fieldx; x++) for (y = 0; y < lev_fieldy; y++)
{
free_position[x][y] =
num_free_positions++;
}
- /* determine number of new elements to place there */
+ // determine number of new elements to place there
num_percentage = num_free_positions * random_placement_value / 100;
num_elements = (random_placement_method == RANDOM_USE_PERCENTAGE ?
num_percentage : random_placement_value);
- /* if less free positions than elements to place, fill all these positions */
+ // if less free positions than elements to place, fill all these positions
if (num_free_positions < num_elements)
{
for (x = 0; x < lev_fieldx; x++)
x = GetSimpleRandom(lev_fieldx);
y = GetSimpleRandom(lev_fieldy);
- /* don't place element at the same position twice */
+ // don't place element at the same position twice
if (free_position[x][y])
{
free_position[x][y] = FALSE;
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 */
+ // 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 */
+ // get positions inside level field
lx = sx + level_xpos;
ly = sy + level_ypos;
if (!IN_LEV_FIELD(lx, ly))
inside_drawing_area = FALSE;
- /* make sure to stay inside level field boundaries */
+ // 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 */
+ // correct drawing area positions accordingly
sx = lx - level_xpos;
sy = ly - level_ypos;
}
- /* also correct MM wall-sized (double) drawing area positions accordingly */
+ // also correct MM wall-sized (double) drawing area positions accordingly
if (sx2 / 2 < sx || sx2 / 2 > sx)
{
dx = (sx2 / 2 < sx ? 0 : 1);
}
else if (!button_press_event)
{
- /* prevent handling events for every pixel position when moving mouse */
+ // prevent handling events for every pixel position when moving mouse
if ((sx == last_sx && sy == last_sy &&
!IS_MM_WALL_EDITOR(new_element) && new_element != EL_EMPTY) ||
(sx2 == last_sx2 && sy2 == last_sy2))
if (!button && !button_release_event)
return;
- /* handle info callback for each invocation of action callback */
+ // handle info callback for each invocation of action callback
gi->callback_info(gi);
- /* automatically switch to 'single item' drawing mode, if needed */
+ // automatically switch to 'single item' drawing mode, if needed
actual_drawing_function =
(draw_level || drawing_function == GADGET_ID_PICK_ELEMENT ?
drawing_function : GADGET_ID_SINGLE_ITEMS);
- /* clicking into drawing area with pressed Control key picks element */
+ // clicking into drawing area with pressed Control key picks element
if (GetKeyModState() & KMOD_Control)
{
last_drawing_function = drawing_function;
ResetIntelliDraw();
}
- SetDrawModeHiRes(-1); /* reset to normal draw mode */
+ SetDrawModeHiRes(-1); // reset to normal draw mode
switch (actual_drawing_function)
{
if (new_element == EL_PLAYER_1)
{
- /* remove player at old position */
+ // remove player at old position
for (y = 0; y < lev_fieldy; y++)
for (x = 0; x < lev_fieldx; x++)
if (Feld[x][y] == EL_PLAYER_1)
{
UpdateCustomElementGraphicGadgets();
- FrameCounter = 0; /* restart animation frame counter */
+ FrameCounter = 0; // restart animation frame counter
}
}
break;
sx = sx2;
sy = sy2;
}
- /* FALLTHROUGH */
+ // FALLTHROUGH
case GADGET_ID_GRAB_BRUSH:
case GADGET_ID_TEXT:
{
draw_func = DrawFilledBox;
else if (drawing_function == GADGET_ID_GRAB_BRUSH)
draw_func = SelectArea;
- else /* (drawing_function == GADGET_ID_TEXT) */
+ else // (drawing_function == GADGET_ID_TEXT)
draw_func = SetTextCursor;
if (button_press_event)
else if (last_sx != sx || last_sy != sy)
{
draw_func(start_sx, start_sy, last_sx, last_sy, -1, FALSE);
- if (IS_MM_WALL_EDITOR(new_element)) /* clear wall background */
+ if (IS_MM_WALL_EDITOR(new_element)) // clear wall background
draw_func(start_sx, start_sy, sx, sy, EL_EMPTY, FALSE);
draw_func(start_sx, start_sy, sx, sy, new_element, FALSE);
last_sx = sx;
break;
}
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if ((type_id >= ED_DRAWING_ID_EDITOR_FIRST &&
type_id <= ED_DRAWING_ID_EDITOR_LAST) ||
actual_drawing_function == GADGET_ID_GRAB_BRUSH ||
if (level.game_engine_type != last_game_engine_type)
{
- /* update element selection list */
+ // update element selection list
ReinitializeElementList();
ModifyEditorElementList();
}
lev_fieldx = level.fieldx;
lev_fieldy = level.fieldy;
- /* check if resizing of level results in change of border border */
+ // check if resizing of level results in change of border border
SetBorderElement();
break;
counter_id <= ED_COUNTER_ID_CHANGE_LAST))
CopyElementPropertiesToGame(properties_element);
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if ((counter_id >= ED_COUNTER_ID_LEVELSET_FIRST &&
counter_id <= ED_COUNTER_ID_LEVELSET_LAST) ||
(counter_id >= ED_COUNTER_ID_EDITOR_FIRST &&
{
CopyElementPropertiesToGame(properties_element);
- ModifyEditorElementList(); /* update changed button info text */
+ ModifyEditorElementList(); // update changed button info text
}
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if (type_id >= ED_TEXTINPUT_ID_LEVELSET_FIRST &&
type_id <= ED_TEXTINPUT_ID_LEVELSET_LAST)
return;
{
if (type_id == ED_SELECTBOX_ID_ACTION_TYPE)
{
- /* when changing action type, also check action mode and action arg */
+ // when changing action type, also check action mode and action arg
if (value_old != value_new)
setSelectboxSpecialActionVariablesIfNeeded();
}
else if (type_id == ED_SELECTBOX_ID_GAME_ENGINE_TYPE)
{
- /* update element selection list */
+ // update element selection list
ReinitializeElementList();
ModifyEditorElementList();
}
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if (type_id == ED_SELECTBOX_ID_LEVELSET_SAVE_MODE ||
type_id == ED_SELECTBOX_ID_SELECT_CHANGE_PAGE)
return;
{
boolean new_template = !fileExists(getLocalLevelTemplateFilename());
- /* backup original "level.field" (needed to track playfield changes) */
+ // backup original "level.field" (needed to track playfield changes)
CopyPlayfield(level.field, FieldBackup);
- /* "SaveLevelTemplate()" uses "level.field", so copy editor playfield */
+ // "SaveLevelTemplate()" uses "level.field", so copy editor playfield
CopyPlayfield(Feld, level.field);
if (new_template ||
if (new_template)
Request("Template saved!", REQ_CONFIRM);
- /* restore original "level.field" (needed to track playfield changes) */
+ // restore original "level.field" (needed to track playfield changes)
CopyPlayfield(FieldBackup, level.field);
}
else if (type_id == ED_TEXTBUTTON_ID_SAVE_LEVELSET)
{
struct ElementInfo *ei = &element_info[properties_element];
- /* when modifying custom element, ask for copying level template */
+ // when modifying custom element, ask for copying level template
if (level.use_custom_template && !AskToCopyAndModifyLevelTemplate())
return;
setElementChangePages(ei, ei->num_change_pages + 1);
- /* set new change page to be new current change page */
+ // set new change page to be new current change page
ei->current_change_page = ei->num_change_pages - 1;
ei->change = &ei->change_page[ei->current_change_page];
{
struct ElementInfo *ei = &element_info[properties_element];
- /* when modifying custom element, ask for copying level template */
+ // when modifying custom element, ask for copying level template
if (level.use_custom_template && !AskToCopyAndModifyLevelTemplate())
return;
- /* copy all change pages after change page to be deleted */
+ // copy all change pages after change page to be deleted
for (i = ei->current_change_page; i < ei->num_change_pages - 1; i++)
ei->change_page[i] = ei->change_page[i + 1];
}
else if (type_id == ED_GRAPHICBUTTON_ID_PASTE_CHANGE_PAGE)
{
- /* when modifying custom element, ask for copying level template */
+ // when modifying custom element, ask for copying level template
if (level.use_custom_template && !AskToCopyAndModifyLevelTemplate())
return;
*radiobutton_info[type_id].value =
radiobutton_info[type_id].checked_value;
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if (type_id >= ED_RADIOBUTTON_ID_EDITOR_FIRST &&
type_id <= ED_RADIOBUTTON_ID_EDITOR_LAST)
return;
boolean template_related_changes_found = FALSE;
int i;
- /* check if any custom or group elements have been changed */
+ // check if any custom or group elements have been changed
for (i = 0; i < NUM_FILE_ELEMENTS; i++)
if ((IS_CUSTOM_ELEMENT(i) || IS_GROUP_ELEMENT(i)) &&
element_info[i].modified_settings)
SetAutomaticNumberOfGemsNeeded();
}
- /* do not mark level as modified for certain non-level-changing gadgets */
+ // do not mark level as modified for certain non-level-changing gadgets
if ((type_id >= ED_CHECKBUTTON_ID_LEVELSET_FIRST &&
type_id <= ED_CHECKBUTTON_ID_LEVELSET_LAST) ||
(type_id >= ED_CHECKBUTTON_ID_EDITOR_FIRST &&
!(GetKeyModState() & KMOD_Control))
ChangeEditModeWindow(ED_MODE_DRAWING);
- /* element copy mode active, but no element button pressed => deactivate */
+ // element copy mode active, but no element button pressed => deactivate
if (last_custom_copy_mode != -1 && id < ED_NUM_CTRL_BUTTONS)
last_custom_copy_mode = -1;
- /* when showing palette on element buttons, change element of button used */
+ // when showing palette on element buttons, change element of button used
if (editor.palette.show_on_element_buttons &&
id >= GADGET_ID_ELEMENT_LEFT && id <= GADGET_ID_ELEMENT_RIGHT)
{
{
DrawDrawingWindow();
- /* redraw zoom gadget info text */
+ // redraw zoom gadget info text
PrintEditorGadgetInfoText(level_editor_gadget[id]);
}
- /* save current editor zoom tilesize */
+ // save current editor zoom tilesize
SaveSetup_AutoSetup();
break;
if (button == 1)
{
- /* undo */
+ // undo
undo_buffer_position =
(undo_buffer_position - 1 + NUM_UNDO_STEPS) % NUM_UNDO_STEPS;
}
else
{
- /* redo */
+ // redo
undo_buffer_position = (undo_buffer_position + 1) % NUM_UNDO_STEPS;
for (y = 0; y < lev_fieldy; y++)
Feld[x][y] = UndoBuffer[undo_buffer_position][x][y];
- /* check if undo operation forces change of border style */
+ // check if undo operation forces change of border style
CheckLevelBorderElement(FALSE);
DrawEditorLevel(ed_fieldx, ed_fieldy, level_xpos, level_ypos);
}
}
- /* "cd" back to copied-from levelset (in case of saved read-only level) */
+ // "cd" back to copied-from levelset (in case of saved read-only level)
leveldir_current = leveldir_former;
level_nr = level_nr_former;
CloseDoor(DOOR_CLOSE_ALL);
- /* needed before playing if editor playfield area has different size */
+ // needed before playing if editor playfield area has different size
ClearRectangle(drawto, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
// redraw_mask = REDRAW_ALL;
break;
case GADGET_ID_EXIT:
- RequestExitLevelEditor(TRUE, FALSE); /* if level has changed, ask user */
+ RequestExitLevelEditor(TRUE, FALSE); // if level has changed, ask user
break;
default:
*cascade_element = EL_CASCADE_TOGGLE(*cascade_element);
*cascade_value = IS_EDITOR_CASCADE_ACTIVE(*cascade_element);
- /* update element selection list */
+ // update element selection list
ReinitializeElementList();
ModifyEditorElementList();
- /* update cascading gadget info text */
+ // update cascading gadget info text
PrintEditorGadgetInfoText(level_editor_gadget[id]);
- /* save current editor cascading state */
+ // save current editor cascading state
SaveSetup_EditorCascade();
break;
break;
}
- /* change element of button used to show palette */
+ // change element of button used to show palette
if (editor.palette.show_on_element_buttons)
button = last_button;
case KSYM_Insert:
case KSYM_Delete:
- /* this is needed to prevent interference with running "True X-Mouse" */
+ // this is needed to prevent interference with running "True X-Mouse"
if (GetKeyModStateFromEvents() & KMOD_Control)
break;
- /* check for last or next editor cascade block in element list */
+ // check for last or next editor cascade block in element list
for (i = 0; i < num_editor_elements; i++)
{
if ((key == KSYM_Insert && i == element_shift) ||
(key == KSYM_Delete && new_element_shift > element_shift))
break;
- /* jump to next cascade block (or to start of element list) */
+ // jump to next cascade block (or to start of element list)
if (i == 0 || IS_EDITOR_CASCADE(editor_elements[i]))
new_element_shift = i;
}
{
HandleControlButtons(level_editor_gadget[GADGET_ID_PALETTE]);
}
- else /* should never happen */
+ else // should never happen
{
ChangeEditModeWindow(ED_MODE_DRAWING);
}
redraw_mask |= REDRAW_FIELD;
- FrameCounter++; /* increase animation frame counter */
+ FrameCounter++; // increase animation frame counter
}
static void ClearEditorGadgetInfoText(void)
if (gi == NULL || gi->event.type == GD_EVENT_INFO_LEAVING)
return;
- /* misuse this function to delete brush cursor, if needed */
+ // misuse this function to delete brush cursor, if needed
if (edit_mode == ED_MODE_DRAWING && draw_with_brush)
DeleteBrushFromCursor();
char infotext[MAX_OUTPUT_LINESIZE + 1];
char *text;
- infotext[0] = '\0'; /* start with empty info text */
+ infotext[0] = '\0'; // start with empty info text
- /* pressed Control key: simulate picking element */
+ // pressed Control key: simulate picking element
if (GetKeyModState() & KMOD_Control)
actual_drawing_function = GADGET_ID_PICK_ELEMENT;
if (gi->event.type == GD_EVENT_INFO_LEAVING)
return;
- /* make sure to stay inside drawing area boundaries */
+ // 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);
int min_lx = 0, min_ly = 0;
int max_lx = lev_fieldx - 1, max_ly = lev_fieldy - 1;
- /* get positions inside level field */
+ // get positions inside level field
lx = sx + level_xpos;
ly = sy + level_ypos;
- /* make sure to stay inside level field boundaries */
+ // 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 */
+ // correct drawing area positions accordingly
sx = lx - level_xpos;
sy = ly - level_ypos;
}
if (IN_ED_FIELD(sx,sy) && IN_LEV_FIELD(lx, ly))
{
- if (button_status) /* if (gi->state == GD_BUTTON_PRESSED) */
+ if (button_status) // if (gi->state == GD_BUTTON_PRESSED)
{
if (gi->event.type == GD_EVENT_PRESSED)
{
sprintf(infotext, "Level position: %d, %d", lx, ly);
}
- /* misuse this function to draw brush cursor, if needed */
+ // misuse this function to draw brush cursor, if needed
if (edit_mode == ED_MODE_DRAWING && draw_with_brush && !button_status)
{
if (IN_ED_FIELD(sx, sy) && IN_LEV_FIELD(lx, ly))
struct RectWithBorder *vp_door_1 = &viewport.door_1[GAME_MODE_MAIN];
struct RectWithBorder *vp_door_2 = &viewport.door_2[GAME_MODE_MAIN];
- /* draw normal door */
+ // draw normal door
UndrawSpecialEditorDoor();
// use door animation if door 1 viewport is unchanged and contains toolbox
#include "tape.h"
#include "config.h"
-#define ENABLE_UNUSED_CODE 0 /* currently unused functions */
-#define ENABLE_HISTORIC_CHUNKS 0 /* only for historic reference */
-#define ENABLE_RESERVED_CODE 0 /* reserved for later use */
+#define ENABLE_UNUSED_CODE 0 // currently unused functions
+#define ENABLE_HISTORIC_CHUNKS 0 // only for historic reference
+#define ENABLE_RESERVED_CODE 0 // reserved for later use
-#define CHUNK_ID_LEN 4 /* IFF style chunk id length */
-#define CHUNK_SIZE_UNDEFINED 0 /* undefined chunk size == 0 */
-#define CHUNK_SIZE_NONE -1 /* do not write chunk size */
+#define CHUNK_ID_LEN 4 // IFF style chunk id length
+#define CHUNK_SIZE_UNDEFINED 0 // undefined chunk size == 0
+#define CHUNK_SIZE_NONE -1 // do not write chunk size
#define LEVEL_CHUNK_NAME_SIZE MAX_LEVEL_NAME_LEN
#define LEVEL_CHUNK_AUTH_SIZE MAX_LEVEL_AUTHOR_LEN
-#define LEVEL_CHUNK_VERS_SIZE 8 /* size of file version chunk */
-#define LEVEL_CHUNK_DATE_SIZE 4 /* size of file date chunk */
-#define LEVEL_CHUNK_HEAD_SIZE 80 /* size of level file header */
-#define LEVEL_CHUNK_HEAD_UNUSED 0 /* unused level header bytes */
-#define LEVEL_CHUNK_CNT2_SIZE 160 /* size of level CNT2 chunk */
-#define LEVEL_CHUNK_CNT2_UNUSED 11 /* unused CNT2 chunk bytes */
-#define LEVEL_CHUNK_CNT3_HEADER 16 /* size of level CNT3 header */
-#define LEVEL_CHUNK_CNT3_UNUSED 10 /* unused CNT3 chunk bytes */
-#define LEVEL_CPART_CUS3_SIZE 134 /* size of CUS3 chunk part */
-#define LEVEL_CPART_CUS3_UNUSED 15 /* unused CUS3 bytes / part */
-#define LEVEL_CHUNK_GRP1_SIZE 74 /* size of level GRP1 chunk */
-
-/* (element number, number of change pages, change page number) */
+#define LEVEL_CHUNK_VERS_SIZE 8 // size of file version chunk
+#define LEVEL_CHUNK_DATE_SIZE 4 // size of file date chunk
+#define LEVEL_CHUNK_HEAD_SIZE 80 // size of level file header
+#define LEVEL_CHUNK_HEAD_UNUSED 0 // unused level header bytes
+#define LEVEL_CHUNK_CNT2_SIZE 160 // size of level CNT2 chunk
+#define LEVEL_CHUNK_CNT2_UNUSED 11 // unused CNT2 chunk bytes
+#define LEVEL_CHUNK_CNT3_HEADER 16 // size of level CNT3 header
+#define LEVEL_CHUNK_CNT3_UNUSED 10 // unused CNT3 chunk bytes
+#define LEVEL_CPART_CUS3_SIZE 134 // size of CUS3 chunk part
+#define LEVEL_CPART_CUS3_UNUSED 15 // unused CUS3 bytes / part
+#define LEVEL_CHUNK_GRP1_SIZE 74 // size of level GRP1 chunk
+
+// (element number, number of change pages, change page number)
#define LEVEL_CHUNK_CUSX_UNCHANGED (2 + (1 + 1) + (1 + 1))
-/* (element number only) */
+// (element number only)
#define LEVEL_CHUNK_GRPX_UNCHANGED 2
#define LEVEL_CHUNK_NOTE_UNCHANGED 2
-/* (nothing at all if unchanged) */
+// (nothing at all if unchanged)
#define LEVEL_CHUNK_ELEM_UNCHANGED 0
-#define TAPE_CHUNK_VERS_SIZE 8 /* size of file version chunk */
-#define TAPE_CHUNK_HEAD_SIZE 20 /* size of tape file header */
-#define TAPE_CHUNK_HEAD_UNUSED 2 /* unused tape header bytes */
+#define TAPE_CHUNK_VERS_SIZE 8 // size of file version chunk
+#define TAPE_CHUNK_HEAD_SIZE 20 // size of tape file header
+#define TAPE_CHUNK_HEAD_UNUSED 2 // unused tape header bytes
#define LEVEL_CHUNK_CNT3_SIZE(x) (LEVEL_CHUNK_CNT3_HEADER + (x))
#define LEVEL_CHUNK_CUS3_SIZE(x) (2 + (x) * LEVEL_CPART_CUS3_SIZE)
#define LEVEL_CHUNK_CUS4_SIZE(x) (96 + (x) * 48)
-/* file identifier strings */
+// file identifier strings
#define LEVEL_COOKIE_TMPL "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
#define TAPE_COOKIE_TMPL "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
#define SCORE_COOKIE "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
-/* values for deciding when (not) to save configuration data */
+// values for deciding when (not) to save configuration data
#define SAVE_CONF_NEVER 0
#define SAVE_CONF_ALWAYS 1
#define SAVE_CONF_WHEN_CHANGED -1
-/* values for chunks using micro chunks */
+// values for chunks using micro chunks
#define CONF_MASK_1_BYTE 0x00
#define CONF_MASK_2_BYTE 0x40
#define CONF_MASK_4_BYTE 0x80
#define CONF_VALUE_4_BYTE(x) (CONF_MASK_4_BYTE | (x))
#define CONF_VALUE_MULTI_BYTES(x) (CONF_MASK_MULTI_BYTES | (x))
-/* these definitions are just for convenience of use and readability */
+// these definitions are just for convenience of use and readability
#define CONF_VALUE_8_BIT(x) CONF_VALUE_1_BYTE(x)
#define CONF_VALUE_16_BIT(x) CONF_VALUE_2_BYTE(x)
#define CONF_VALUE_32_BIT(x) CONF_VALUE_4_BYTE(x)
#define CONF_CONTENTS_ELEMENT(b,c,x,y) ((b[CONF_CONTENT_BYTE_POS(c,x,y)]<< 8)|\
(b[CONF_CONTENT_BYTE_POS(c,x,y) + 1]))
-/* temporary variables used to store pointers to structure members */
+// temporary variables used to store pointers to structure members
static struct LevelInfo li;
static struct ElementInfo xx_ei, yy_ei;
static struct ElementChangeInfo xx_change;
struct LevelFileConfigInfo
{
- int element; /* element for which data is to be stored */
- int save_type; /* save data always, never or when changed */
- int data_type; /* data type (used internally, not stored) */
- int conf_type; /* micro chunk identifier (stored in file) */
-
- /* (mandatory) */
- void *value; /* variable that holds the data to be stored */
- int default_value; /* initial default value for this variable */
-
- /* (optional) */
- void *value_copy; /* variable that holds the data to be copied */
- void *num_entities; /* number of entities for multi-byte data */
- int default_num_entities; /* default number of entities for this data */
- int max_num_entities; /* maximal number of entities for this data */
- char *default_string; /* optional default string for string data */
+ int element; // element for which data is to be stored
+ int save_type; // save data always, never or when changed
+ int data_type; // data type (used internally, not stored)
+ int conf_type; // micro chunk identifier (stored in file)
+
+ // (mandatory)
+ void *value; // variable that holds the data to be stored
+ int default_value; // initial default value for this variable
+
+ // (optional)
+ void *value_copy; // variable that holds the data to be copied
+ void *num_entities; // number of entities for multi-byte data
+ int default_num_entities; // default number of entities for this data
+ int max_num_entities; // maximal number of entities for this data
+ char *default_string; // optional default string for string data
};
static struct LevelFileConfigInfo chunk_config_INFO[] =
{
- /* ---------- values not related to single elements ----------------------- */
+ // ---------- values not related to single elements -------------------------
{
-1, SAVE_CONF_ALWAYS,
{
-1, -1,
TYPE_BITFIELD, CONF_VALUE_32_BIT(1),
- &li.can_move_into_acid_bits, ~0 /* default: everything can */
+ &li.can_move_into_acid_bits, ~0 // default: everything can
},
{
-1, -1,
TYPE_BITFIELD, CONF_VALUE_8_BIT(7),
- &li.dont_collide_with_bits, ~0 /* default: always deadly */
+ &li.dont_collide_with_bits, ~0 // default: always deadly
},
{
static struct LevelFileConfigInfo chunk_config_ELEM[] =
{
- /* (these values are the same for each player) */
+ // (these values are the same for each player)
{
EL_PLAYER_1, -1,
TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
- &li.block_last_field, FALSE /* default case for EM levels */
+ &li.block_last_field, FALSE // default case for EM levels
},
{
EL_PLAYER_1, -1,
TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
- &li.sp_block_last_field, TRUE /* default case for SP levels */
+ &li.sp_block_last_field, TRUE // default case for SP levels
},
{
EL_PLAYER_1, -1,
&li.lazy_relocation, FALSE
},
- /* (these values are different for each player) */
+ // (these values are different for each player)
{
EL_PLAYER_1, -1,
TYPE_INTEGER, CONF_VALUE_8_BIT(7),
&li.score[SC_ELEM_BONUS], 10
},
- /* ---------- unused values ----------------------------------------------- */
+ // ---------- unused values -------------------------------------------------
{
EL_UNKNOWN, SAVE_CONF_NEVER,
&yy_ei.properties[EP_BITFIELD_BASE_NR]
},
#if ENABLE_RESERVED_CODE
- /* (reserved for later use) */
+ // (reserved for later use)
{
-1, -1,
TYPE_BITFIELD, CONF_VALUE_32_BIT(2),
&xx_num_contents, 1, 1
},
- /* ---------- "num_change_pages" must be the last entry ------------------- */
+ // ---------- "num_change_pages" must be the last entry ---------------------
{
-1, SAVE_CONF_ALWAYS,
static struct LevelFileConfigInfo chunk_config_CUSX_change[] =
{
- /* ---------- "current_change_page" must be the first entry --------------- */
+ // ---------- "current_change_page" must be the first entry -----------------
{
-1, SAVE_CONF_ALWAYS,
&xx_current_change_page, -1
},
- /* ---------- (the remaining entries can be in any order) ----------------- */
+ // ---------- (the remaining entries can be in any order) -------------------
{
-1, -1,
}
};
-static struct LevelFileConfigInfo chunk_config_CONF[] = /* (OBSOLETE) */
+static struct LevelFileConfigInfo chunk_config_CONF[] = // (OBSOLETE)
{
{
EL_PLAYER_1, -1,
};
-/* ========================================================================= */
-/* level file functions */
-/* ========================================================================= */
+// ============================================================================
+// level file functions
+// ============================================================================
static boolean check_special_flags(char *flag)
{
ei->editor_description);
int i;
- /* always start with reliable default values */
+ // always start with reliable default values
for (i = 0; i < MAX_ELEMENT_NAME_LEN + 1; i++)
description[i] = '\0';
- /* truncate element description to MAX_ELEMENT_NAME_LEN bytes */
+ // truncate element description to MAX_ELEMENT_NAME_LEN bytes
strncpy(description, default_description, MAX_ELEMENT_NAME_LEN);
return &description[0];
content[c].e[x][y] = default_value;
}
}
- else /* constant size configuration data (1, 2 or 4 bytes) */
+ else // constant size configuration data (1, 2 or 4 bytes)
{
if (data_type == TYPE_BOOLEAN)
*(boolean *)(conf[i].value) = default_value;
content_copy[c].e[x][y] = content[c].e[x][y];
}
}
- else /* constant size configuration data (1, 2 or 4 bytes) */
+ else // constant size configuration data (1, 2 or 4 bytes)
{
if (data_type == TYPE_BOOLEAN)
*(boolean *)(conf[i].value_copy) = *(boolean *)(conf[i].value);
{
int i;
- xx_ei = *ei_from; /* copy element data into temporary buffer */
- yy_ei = *ei_to; /* copy element data into temporary buffer */
+ xx_ei = *ei_from; // copy element data into temporary buffer
+ yy_ei = *ei_to; // copy element data into temporary buffer
copyConfigFromConfigList(chunk_config_CUSX_base);
*ei_from = xx_ei;
*ei_to = yy_ei;
- /* ---------- reinitialize and copy change pages ---------- */
+ // ---------- reinitialize and copy change pages ----------
ei_to->num_change_pages = ei_from->num_change_pages;
ei_to->current_change_page = ei_from->current_change_page;
for (i = 0; i < ei_to->num_change_pages; i++)
ei_to->change_page[i] = ei_from->change_page[i];
- /* ---------- copy group element info ---------- */
- if (ei_from->group != NULL && ei_to->group != NULL) /* group or internal */
+ // ---------- copy group element info ----------
+ if (ei_from->group != NULL && ei_to->group != NULL) // group or internal
*ei_to->group = *ei_from->group;
- /* mark this custom element as modified */
+ // mark this custom element as modified
ei_to->modified_settings = TRUE;
}
void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
{
- xx_change = *change; /* copy change data into temporary buffer */
+ xx_change = *change; // copy change data into temporary buffer
setConfigToDefaultsFromConfigList(chunk_config_CUSX_change);
{
int i, x, y;
- li = *level; /* copy level data into temporary buffer */
+ li = *level; // copy level data into temporary buffer
setConfigToDefaultsFromConfigList(chunk_config_INFO);
- *level = li; /* copy temporary buffer back to level data */
+ *level = li; // copy temporary buffer back to level data
setLevelInfoToDefaults_EM();
setLevelInfoToDefaults_SP();
level->encoding_16bit_yamyam = TRUE;
level->encoding_16bit_amoeba = TRUE;
- /* clear level name and level author string buffers */
+ // clear level name and level author string buffers
for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
level->name[i] = '\0';
for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
level->author[i] = '\0';
- /* set level name and level author to default values */
+ // set level name and level author to default values
strcpy(level->name, NAMELESS_LEVEL_NAME);
strcpy(level->author, ANONYMOUS_NAME);
- /* set level playfield to playable default level with player and exit */
+ // set level playfield to playable default level with player and exit
for (x = 0; x < MAX_LEV_FIELDX; x++)
for (y = 0; y < MAX_LEV_FIELDY; y++)
level->field[x][y] = EL_SAND;
BorderElement = EL_STEELWALL;
- /* detect custom elements when loading them */
+ // detect custom elements when loading them
level->file_has_custom_elements = FALSE;
- /* set all bug compatibility flags to "false" => do not emulate this bug */
+ // set all bug compatibility flags to "false" => do not emulate this bug
level->use_action_after_change_bug = FALSE;
if (leveldir_current)
{
- /* try to determine better author name than 'anonymous' */
+ // try to determine better author name than 'anonymous'
if (!strEqual(leveldir_current->author, ANONYMOUS_NAME))
{
strncpy(level->author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
break;
default:
- /* keep default value */
+ // keep default value
break;
}
}
InitElementPropertiesStatic();
- li = *level; /* copy level data into temporary buffer */
+ li = *level; // copy level data into temporary buffer
setConfigToDefaultsFromConfigList(chunk_config_ELEM);
- *level = li; /* copy temporary buffer back to level data */
+ *level = li; // copy temporary buffer back to level data
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
int element = i;
struct ElementInfo *ei = &element_info[element];
- /* never initialize clipboard elements after the very first time */
- /* (to be able to use clipboard elements between several levels) */
+ // never initialize clipboard elements after the very first time
+ // (to be able to use clipboard elements between several levels)
if (IS_CLIPBOARD_ELEMENT(element) && clipboard_elements_initialized)
continue;
IS_GROUP_ELEMENT(element) ||
IS_INTERNAL_ELEMENT(element))
{
- xx_ei = *ei; /* copy element data into temporary buffer */
+ xx_ei = *ei; // copy element data into temporary buffer
setConfigToDefaultsFromConfigList(chunk_config_CUSX_base);
if (IS_CUSTOM_ELEMENT(element) ||
IS_INTERNAL_ELEMENT(element))
{
- /* internal values used in level editor */
+ // internal values used in level editor
ei->access_type = 0;
ei->access_layer = 0;
{
struct ElementGroupInfo *group;
- /* initialize memory for list of elements in group */
+ // initialize memory for list of elements in group
if (ei->group == NULL)
ei->group = checked_malloc(sizeof(struct ElementGroupInfo));
group = ei->group;
- xx_group = *group; /* copy group data into temporary buffer */
+ xx_group = *group; // copy group data into temporary buffer
setConfigToDefaultsFromConfigList(chunk_config_GRPX);
if (check_special_flags("load_xsb_to_ces"))
{
- /* fill smaller playfields with padding "beyond border wall" elements */
+ // fill smaller playfields with padding "beyond border wall" elements
if (level.fieldx < level_template.fieldx ||
level.fieldy < level_template.fieldy)
{
int pos_fieldx = (new_fieldx - level.fieldx) / 2;
int pos_fieldy = (new_fieldy - level.fieldy) / 2;
- /* copy old playfield (which is smaller than the visible area) */
+ // copy old playfield (which is smaller than the visible area)
for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
field[x][y] = level.field[x][y];
- /* fill new, larger playfield with "beyond border wall" elements */
+ // fill new, larger playfield with "beyond border wall" elements
for (y = 0; y < new_fieldy; y++) for (x = 0; x < new_fieldx; x++)
level.field[x][y] = getMappedElement_SB('_', TRUE);
- /* copy the old playfield to the middle of the new playfield */
+ // copy the old playfield to the middle of the new playfield
for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
level.field[pos_fieldx + x][pos_fieldy + y] = field[x][y];
{
struct LevelInfo level_backup = level;
- /* overwrite all individual level settings from template level settings */
+ // overwrite all individual level settings from template level settings
level = level_template;
- /* restore level file info */
+ // restore level file info
level.file_info = level_backup.file_info;
- /* restore playfield size */
+ // restore playfield size
level.fieldx = level_backup.fieldx;
level.fieldy = level_backup.fieldy;
- /* restore playfield content */
+ // restore playfield content
for (x = 0; x < level.fieldx; x++)
for (y = 0; y < level.fieldy; y++)
level.field[x][y] = level_backup.field[x][y];
- /* restore name and author from individual level */
+ // restore name and author from individual level
strcpy(level.name, level_backup.name);
strcpy(level.author, level_backup.author);
- /* restore flag "use_custom_template" */
+ // restore flag "use_custom_template"
level.use_custom_template = level_backup.use_custom_template;
}
}
static int getFileTypeFromBasename(char *basename)
{
- /* !!! ALSO SEE COMMENT IN checkForPackageFromBasename() !!! */
+ // !!! ALSO SEE COMMENT IN checkForPackageFromBasename() !!!
static char *filename = NULL;
struct stat file_status;
- /* ---------- try to determine file type from filename ---------- */
+ // ---------- try to determine file type from filename ----------
- /* check for typical filename of a Supaplex level package file */
+ // check for typical filename of a Supaplex level package file
if (strlen(basename) == 10 && strPrefixLower(basename, "levels.d"))
return LEVEL_FILE_TYPE_SP;
- /* check for typical filename of a Diamond Caves II level package file */
+ // check for typical filename of a Diamond Caves II level package file
if (strSuffixLower(basename, ".dc") ||
strSuffixLower(basename, ".dc2"))
return LEVEL_FILE_TYPE_DC;
- /* check for typical filename of a Sokoban level package file */
+ // check for typical filename of a Sokoban level package file
if (strSuffixLower(basename, ".xsb") &&
strchr(basename, '%') == NULL)
return LEVEL_FILE_TYPE_SB;
- /* ---------- try to determine file type from filesize ---------- */
+ // ---------- try to determine file type from filesize ----------
checked_free(filename);
filename = getPath2(getCurrentLevelDir(), basename);
if (stat(filename, &file_status) == 0)
{
- /* check for typical filesize of a Supaplex level package file */
+ // check for typical filesize of a Supaplex level package file
if (file_status.st_size == 170496)
return LEVEL_FILE_TYPE_SP;
}
Directory *dir;
DirectoryEntry *dir_entry;
- strcpy(basename, UNDEFINED_FILENAME); /* default: undefined file */
+ strcpy(basename, UNDEFINED_FILENAME); // default: undefined file
if ((dir = openDirectory(directory)) == NULL)
{
return basename;
}
- while ((dir_entry = readDirectory(dir)) != NULL) /* loop all entries */
+ while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
{
char *entry_basename = dir_entry->basename;
int entry_type = getFileTypeFromBasename(entry_basename);
- if (entry_type != LEVEL_FILE_TYPE_UNKNOWN) /* found valid level package */
+ if (entry_type != LEVEL_FILE_TYPE_UNKNOWN) // found valid level package
{
if (type == LEVEL_FILE_TYPE_UNKNOWN ||
type == entry_type)
char *getGlobalLevelTemplateFilename(void)
{
- /* global variable "leveldir_current" must be modified in the loop below */
+ // global variable "leveldir_current" must be modified in the loop below
LevelDirTree *leveldir_current_last = leveldir_current;
char *filename = NULL;
- /* check for template level in path from current to topmost tree node */
+ // check for template level in path from current to topmost tree node
while (leveldir_current != NULL)
{
leveldir_current = leveldir_current->node_parent;
}
- /* restore global variable "leveldir_current" modified in above loop */
+ // restore global variable "leveldir_current" modified in above loop
leveldir_current = leveldir_current_last;
return filename;
{
int nr = lfi->nr;
- /* special case: level number is negative => check for level template file */
+ // special case: level number is negative => check for level template file
if (nr < 0)
{
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
getSingleLevelBasename(-1));
- /* replace local level template filename with global template filename */
+ // replace local level template filename with global template filename
setString(&lfi->filename, getGlobalLevelTemplateFilename());
- /* no fallback if template file not existing */
+ // no fallback if template file not existing
return;
}
- /* special case: check for file name/pattern specified in "levelinfo.conf" */
+ // special case: check for file name/pattern specified in "levelinfo.conf"
if (leveldir_current->level_filename != NULL)
{
int filetype = getFiletypeFromID(leveldir_current->level_filetype);
{
int filetype = getFiletypeFromID(leveldir_current->level_filetype);
- /* check for specified native level file with standard file name */
+ // check for specified native level file with standard file name
setLevelFileInfo_FormatLevelFilename(lfi, filetype,
"%03d.%s", nr, LEVELFILE_EXTENSION);
if (fileExists(lfi->filename))
return;
}
- /* check for native Rocks'n'Diamonds level file */
+ // check for native Rocks'n'Diamonds level file
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
"%03d.%s", nr, LEVELFILE_EXTENSION);
if (fileExists(lfi->filename))
return;
- /* check for Emerald Mine level file (V1) */
+ // check for Emerald Mine level file (V1)
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "a%c%c",
'a' + (nr / 10) % 26, '0' + nr % 10);
if (fileExists(lfi->filename))
if (fileExists(lfi->filename))
return;
- /* check for Emerald Mine level file (V2 to V5) */
+ // check for Emerald Mine level file (V2 to V5)
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%d", nr);
if (fileExists(lfi->filename))
return;
- /* check for Emerald Mine level file (V6 / single mode) */
+ // check for Emerald Mine level file (V6 / single mode)
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02ds", nr);
if (fileExists(lfi->filename))
return;
if (fileExists(lfi->filename))
return;
- /* check for Emerald Mine level file (V6 / teamwork mode) */
+ // check for Emerald Mine level file (V6 / teamwork mode)
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dt", nr);
if (fileExists(lfi->filename))
return;
if (fileExists(lfi->filename))
return;
- /* check for various packed level file formats */
+ // check for various packed level file formats
setLevelFileInfo_PackedLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
if (fileExists(lfi->filename))
return;
- /* no known level file found -- use default values (and fail later) */
+ // no known level file found -- use default values (and fail later)
setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
"%03d.%s", nr, LEVELFILE_EXTENSION);
}
static void setLevelFileInfo(struct LevelFileInfo *level_file_info, int nr)
{
- /* always start with reliable default values */
+ // always start with reliable default values
setFileInfoToDefaults(level_file_info);
- level_file_info->nr = nr; /* set requested level number */
+ level_file_info->nr = nr; // set requested level number
determineLevelFileInfo_Filename(level_file_info);
determineLevelFileInfo_Filetype(level_file_info);
setString(&lfi_to->filename, lfi_from->filename);
}
-/* ------------------------------------------------------------------------- */
-/* functions for loading R'n'D level */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading R'n'D level
+// ----------------------------------------------------------------------------
static int getMappedElement(int element)
{
- /* remap some (historic, now obsolete) elements */
+ // remap some (historic, now obsolete) elements
switch (element)
{
static int getMappedElementByVersion(int element, int game_version)
{
- /* remap some elements due to certain game version */
+ // remap some elements due to certain game version
if (game_version <= VERSION_IDENT(2,2,0,0))
{
- /* map game font elements */
+ // map game font elements
element = (element == EL_CHAR('[') ? EL_CHAR_AUMLAUT :
element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
element == EL_CHAR(']') ? EL_CHAR_UUMLAUT :
if (game_version < VERSION_IDENT(3,0,0,0))
{
- /* map Supaplex gravity tube elements */
+ // map Supaplex gravity tube elements
element = (element == EL_SP_GRAVITY_PORT_LEFT ? EL_SP_PORT_LEFT :
element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
element == EL_SP_GRAVITY_PORT_UP ? EL_SP_PORT_UP :
getFile8Bit(file);
getFile8Bit(file);
- /* correct invalid number of content fields -- should never happen */
+ // correct invalid number of content fields -- should never happen
if (level->num_yamyam_contents < 1 ||
level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
element = getMappedElement(getFile16BitBE(file));
num_contents = getFile8Bit(file);
- getFile8Bit(file); /* content x size (unused) */
- getFile8Bit(file); /* content y size (unused) */
+ getFile8Bit(file); // content x size (unused)
+ getFile8Bit(file); // content y size (unused)
ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
for (x = 0; x < 3; x++)
content_array[i][x][y] = getMappedElement(getFile16BitBE(file));
- /* correct invalid number of content fields -- should never happen */
+ // correct invalid number of content fields -- should never happen
if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
num_contents = STD_ELEMENT_CONTENTS;
ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
- /* some free bytes for future properties and padding */
+ // some free bytes for future properties and padding
ReadUnusedBytesFromFile(file, 7);
ei->use_gfx_element = getFile8Bit(file);
ei->slippery_type = getFile8Bit(file);
- /* some free bytes for future properties and padding */
+ // some free bytes for future properties and padding
ReadUnusedBytesFromFile(file, LEVEL_CPART_CUS3_UNUSED);
- /* mark that this custom element has been modified */
+ // mark that this custom element has been modified
ei->modified_settings = TRUE;
}
int element;
int i, j, x, y;
- /* ---------- custom element base property values (96 bytes) ------------- */
+ // ---------- custom element base property values (96 bytes) ----------------
element = getMappedElement(getFile16BitBE(file));
ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
- ReadUnusedBytesFromFile(file, 4); /* reserved for more base properties */
+ ReadUnusedBytesFromFile(file, 4); // reserved for more base properties
ei->num_change_pages = getFile8Bit(file);
ei->move_delay_fixed = getFile16BitBE(file);
ei->move_delay_random = getFile16BitBE(file);
- /* bits 0 - 15 of "move_pattern" ... */
+ // bits 0 - 15 of "move_pattern" ...
ei->move_pattern = getFile16BitBE(file);
ei->move_direction_initial = getFile8Bit(file);
ei->move_stepsize = getFile8Bit(file);
ei->move_leave_element = getMappedElement(getFile16BitBE(file));
ei->move_leave_type = getFile8Bit(file);
- /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
+ // ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible)
ei->move_pattern |= (getFile16BitBE(file) << 16);
ei->access_direction = getFile8Bit(file);
ei->ignition_delay = getFile8Bit(file);
ei->explosion_type = getFile8Bit(file);
- /* some free bytes for future custom property values and padding */
+ // some free bytes for future custom property values and padding
ReadUnusedBytesFromFile(file, 1);
- /* ---------- change page property values (48 bytes) --------------------- */
+ // ---------- change page property values (48 bytes) ------------------------
setElementChangePages(ei, ei->num_change_pages);
struct ElementChangeInfo *change = &ei->change_page[i];
unsigned int event_bits;
- /* always start with reliable default values */
+ // always start with reliable default values
setElementChangeInfoToDefaults(change);
- /* bits 0 - 31 of "has_event[]" ... */
+ // bits 0 - 31 of "has_event[]" ...
event_bits = getFile32BitBE(file);
for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
if (event_bits & (1 << j))
change->action_mode = getFile8Bit(file);
change->action_arg = getFile16BitBE(file);
- /* ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible) */
+ // ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible)
event_bits = getFile8Bit(file);
for (j = 32; j < NUM_CHANGE_EVENTS; j++)
if (event_bits & (1 << (j - 32)))
change->has_event[j] = TRUE;
}
- /* mark this custom element as modified */
+ // mark this custom element as modified
ei->modified_settings = TRUE;
level->file_has_custom_elements = TRUE;
group->choice_mode = getFile8Bit(file);
- /* some free bytes for future values and padding */
+ // some free bytes for future values and padding
ReadUnusedBytesFromFile(file, 3);
for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
group->element[i] = getMappedElement(getFile16BitBE(file));
- /* mark this group element as modified */
+ // mark this group element as modified
element_info[element].modified_settings = TRUE;
level->file_has_custom_elements = TRUE;
if (num_entities == 0 && (data_type == TYPE_ELEMENT_LIST ||
data_type == TYPE_CONTENT_LIST))
{
- /* for element and content lists, zero entities are not allowed */
+ // for element and content lists, zero entities are not allowed
Error(ERR_WARN, "found empty list of entities for element %d",
element);
- /* do not set "num_entities" here to prevent reading behind buffer */
+ // do not set "num_entities" here to prevent reading behind buffer
- *(int *)(conf[i].num_entities) = 1; /* at least one is required */
+ *(int *)(conf[i].num_entities) = 1; // at least one is required
}
else
{
micro_chunk_size += 2 + num_bytes;
}
- else /* constant size configuration data (1, 2 or 4 bytes) */
+ else // constant size configuration data (1, 2 or 4 bytes)
{
int value = (byte_mask == CONF_MASK_1_BYTE ? getFile8Bit (file) :
byte_mask == CONF_MASK_2_BYTE ? getFile16BitBE(file) :
{
int real_chunk_size = 0;
- li = *level; /* copy level data into temporary buffer */
+ li = *level; // copy level data into temporary buffer
while (!checkEndOfFile(file))
{
break;
}
- *level = li; /* copy temporary buffer back to level data */
+ *level = li; // copy temporary buffer back to level data
return real_chunk_size;
}
{
int real_chunk_size = 0;
- li = *level; /* copy level data into temporary buffer */
+ li = *level; // copy level data into temporary buffer
while (!checkEndOfFile(file))
{
break;
}
- *level = li; /* copy temporary buffer back to level data */
+ *level = li; // copy temporary buffer back to level data
return real_chunk_size;
}
{
int real_chunk_size = 0;
- li = *level; /* copy level data into temporary buffer */
+ li = *level; // copy level data into temporary buffer
while (!checkEndOfFile(file))
{
break;
}
- *level = li; /* copy temporary buffer back to level data */
+ *level = li; // copy temporary buffer back to level data
return real_chunk_size;
}
int envelope_nr = element - EL_ENVELOPE_1;
int real_chunk_size = 2;
- xx_envelope = level->envelope[envelope_nr]; /* copy into temporary buffer */
+ xx_envelope = level->envelope[envelope_nr]; // copy into temporary buffer
while (!checkEndOfFile(file))
{
break;
}
- level->envelope[envelope_nr] = xx_envelope; /* copy from temporary buffer */
+ level->envelope[envelope_nr] = xx_envelope; // copy from temporary buffer
return real_chunk_size;
}
struct ElementInfo *ei = &element_info[element];
int i;
- xx_ei = *ei; /* copy element data into temporary buffer */
+ xx_ei = *ei; // copy element data into temporary buffer
xx_ei.num_change_pages = -1;
return real_chunk_size;
}
- /* initialize number of change pages stored for this custom element */
+ // initialize number of change pages stored for this custom element
setElementChangePages(ei, ei->num_change_pages);
for (i = 0; i < ei->num_change_pages; i++)
setElementChangeInfoToDefaults(&ei->change_page[i]);
- /* start with reading properties for the first change page */
+ // start with reading properties for the first change page
xx_current_change_page = 0;
while (!checkEndOfFile(file))
{
struct ElementChangeInfo *change = &ei->change_page[xx_current_change_page];
- xx_change = *change; /* copy change data into temporary buffer */
+ xx_change = *change; // copy change data into temporary buffer
- resetEventBits(); /* reset bits; change page might have changed */
+ resetEventBits(); // reset bits; change page might have changed
real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CUSX_change,
-1, element);
struct ElementInfo *ei = &element_info[element];
struct ElementGroupInfo *group = ei->group;
- xx_ei = *ei; /* copy element data into temporary buffer */
- xx_group = *group; /* copy group data into temporary buffer */
+ xx_ei = *ei; // copy element data into temporary buffer
+ xx_group = *group; // copy group data into temporary buffer
while (!checkEndOfFile(file))
{
if (!setup.editor.use_template_for_new_levels)
return;
- /* if level file not found, try to initialize level data from template */
+ // if level file not found, try to initialize level data from template
filename = getGlobalLevelTemplateFilename();
if (!(file = openFile(filename, MODE_READ)))
return;
- /* default: for empty levels, use level template for custom elements */
+ // default: for empty levels, use level template for custom elements
level->use_custom_template = TRUE;
level->no_valid_file = FALSE;
getFileChunkBE(file, chunk_name, NULL);
if (strEqual(chunk_name, "RND1"))
{
- getFile32BitBE(file); /* not used */
+ getFile32BitBE(file); // not used
getFileChunkBE(file, chunk_name, NULL);
if (!strEqual(chunk_name, "CAVE"))
return;
}
}
- else /* check for pre-2.0 file format with cookie string */
+ else // check for pre-2.0 file format with cookie string
{
strcpy(cookie, chunk_name);
if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
return;
}
- /* pre-2.0 level files have no game version, so use file version here */
+ // pre-2.0 level files have no game version, so use file version here
level->game_version = level->file_version;
}
if (level->file_version < FILE_VERSION_1_2)
{
- /* level files from versions before 1.2.0 without chunk structure */
+ // level files from versions before 1.2.0 without chunk structure
LoadLevel_HEAD(file, LEVEL_CHUNK_HEAD_SIZE, level);
LoadLevel_BODY(file, level->fieldx * level->fieldy, level);
}
}
else
{
- /* call function to load this level chunk */
+ // call function to load this level chunk
int chunk_size_expected =
(chunk_info[i].loader)(file, chunk_size, level);
}
-/* ------------------------------------------------------------------------- */
-/* functions for loading EM level */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading EM level
+// ----------------------------------------------------------------------------
static void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
{
map_android_clone_elements_RND_to_EM(level);
- /* first fill the complete playfield with the default border element */
+ // first fill the complete playfield with the default border element
for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
level_em->cave[x][y] = ZBORDER;
level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_STEELWALL);
}
- /* then copy the real level contents from level file into the playfield */
+ // then copy the real level contents from level file into the playfield
for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
{
int new_element = map_element_RND_to_EM(level->field[x][y]);
ply[i]->y_initial = 0;
}
- /* initialize player positions and delete players from the playfield */
+ // initialize player positions and delete players from the playfield
for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
{
if (ELEM_IS_PLAYER(level->field[x][y]))
map_android_clone_elements_EM_to_RND(level);
- /* convert the playfield (some elements need special treatment) */
+ // convert the playfield (some elements need special treatment)
for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
{
int new_element = map_element_EM_to_RND(level_em->cave[x + 1][y + 1]);
for (i = 0; i < MAX_PLAYERS; i++)
{
- /* in case of all players set to the same field, use the first player */
+ // in case of all players set to the same field, use the first player
int nr = MAX_PLAYERS - i - 1;
int jx = ply[nr]->x_initial - 1;
int jy = ply[nr]->y_initial - 1;
}
-/* ------------------------------------------------------------------------- */
-/* functions for loading SP level */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading SP level
+// ----------------------------------------------------------------------------
static void CopyNativeLevel_RND_to_SP(struct LevelInfo *level)
{
for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
header->LevelTitle[i] = level->name[i];
- /* !!! NO STRING TERMINATION IN SUPAPLEX VB CODE YET -- FIX THIS !!! */
+ // !!! NO STRING TERMINATION IN SUPAPLEX VB CODE YET -- FIX THIS !!!
header->InfotronsNeeded = level->gems_needed;
}
else
{
- /* change special gravity port to normal port */
+ // change special gravity port to normal port
element += EL_SP_PORT_RIGHT - gravity_port_base_element;
}
level->initial_player_gravity[i] =
(header->InitialGravity == 1 ? TRUE : FALSE);
- /* skip leading spaces */
+ // skip leading spaces
for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
if (header->LevelTitle[i] != ' ')
break;
- /* copy level title */
+ // copy level title
for (j = 0; i < SP_LEVEL_NAME_LEN; i++, j++)
level->name[j] = header->LevelTitle[i];
level->name[j] = '\0';
- /* cut trailing spaces */
+ // cut trailing spaces
for (; j > 0; j--)
if (level->name[j - 1] == ' ' && level->name[j] == '\0')
level->name[j - 1] = '\0';
EL_SP_GRAVITY_OFF_PORT_RIGHT) - EL_SP_GRAVITY_PORT_RIGHT;
}
- /* change special gravity ports without database entries to normal ports */
+ // change special gravity ports without database entries to normal ports
for (x = 0; x < level->fieldx; x++)
for (y = 0; y < level->fieldy; y++)
if (level->field[x][y] >= EL_SP_GRAVITY_PORT_RIGHT &&
level->field[x][y] <= EL_SP_GRAVITY_PORT_UP)
level->field[x][y] += EL_SP_PORT_RIGHT - EL_SP_GRAVITY_PORT_RIGHT;
- level->time = 0; /* no time limit */
+ level->time = 0; // no time limit
level->amoeba_speed = 0;
level->time_magic_wall = 0;
level->time_wheel = 0;
level->amoeba_content = EL_EMPTY;
#if 1
- /* original Supaplex does not use score values -- use default values */
+ // original Supaplex does not use score values -- use default values
#else
for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
level->score[i] = 0;
#endif
- /* there are no yamyams in supaplex levels */
+ // there are no yamyams in supaplex levels
for (i = 0; i < level->num_yamyam_contents; i++)
for (x = 0; x < 3; x++)
for (y = 0; y < 3; y++)
struct DemoInfo_SP *demo = &level_sp->demo;
int i, j;
- /* always start with reliable default values */
+ // always start with reliable default values
demo->is_available = FALSE;
demo->length = 0;
if (TAPE_IS_EMPTY(tape))
return;
- demo->level_nr = tape.level_nr; /* (currently not used) */
+ demo->level_nr = tape.level_nr; // (currently not used)
level_sp->header.DemoRandomSeed = tape.random_seed;
char *filename = level->file_info.filename;
int i;
- /* always start with reliable default values */
+ // always start with reliable default values
setTapeInfoToDefaults();
if (!demo->is_available)
return;
- tape.level_nr = demo->level_nr; /* (currently not used) */
+ tape.level_nr = demo->level_nr; // (currently not used)
tape.random_seed = level_sp->header.DemoRandomSeed;
TapeSetDateFromEpochSeconds(getFileTimestampEpochSeconds(filename));
}
-/* ------------------------------------------------------------------------- */
-/* functions for loading MM level */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading MM level
+// ----------------------------------------------------------------------------
static void CopyNativeLevel_RND_to_MM(struct LevelInfo *level)
{
strcpy(level->name, level_mm->name);
- /* only overwrite author from 'levelinfo.conf' if author defined in level */
+ // only overwrite author from 'levelinfo.conf' if author defined in level
if (!strEqual(level_mm->author, ANONYMOUS_NAME))
strcpy(level->author, level_mm->author);
}
-/* ------------------------------------------------------------------------- */
-/* functions for loading DC level */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading DC level
+// ----------------------------------------------------------------------------
#define DC_LEVEL_HEADER_SIZE 344
element = EL_ROCK;
break;
- /* 0x0117 - 0x036e: (?) */
- /* EL_DIAMOND */
+ // 0x0117 - 0x036e: (?)
+ // EL_DIAMOND
- /* 0x042d - 0x0684: (?) */
- /* EL_EMERALD */
+ // 0x042d - 0x0684: (?)
+ // EL_EMERALD
case 0x06f1:
element = EL_NUT;
element = EL_CRYSTAL;
break;
- case 0x0e77: /* quicksand (boulder) */
+ case 0x0e77: // quicksand (boulder)
element = EL_QUICKSAND_FAST_FULL;
break;
- case 0x0e99: /* slow quicksand (boulder) */
+ case 0x0e99: // slow quicksand (boulder)
element = EL_QUICKSAND_FULL;
break;
element = EL_EM_STEEL_EXIT_CLOSED;
break;
- case 0x0f4f: /* dynamite (lit 1) */
+ case 0x0f4f: // dynamite (lit 1)
element = EL_EM_DYNAMITE_ACTIVE;
break;
- case 0x0f57: /* dynamite (lit 2) */
+ case 0x0f57: // dynamite (lit 2)
element = EL_EM_DYNAMITE_ACTIVE;
break;
- case 0x0f5f: /* dynamite (lit 3) */
+ case 0x0f5f: // dynamite (lit 3)
element = EL_EM_DYNAMITE_ACTIVE;
break;
- case 0x0f67: /* dynamite (lit 4) */
+ case 0x0f67: // dynamite (lit 4)
element = EL_EM_DYNAMITE_ACTIVE;
break;
element = EL_TIMEGATE_CLOSED;
break;
- case 0x144c: /* conveyor belt switch (green) */
+ case 0x144c: // conveyor belt switch (green)
element = EL_CONVEYOR_BELT_3_SWITCH_MIDDLE;
break;
- case 0x144f: /* conveyor belt switch (red) */
+ case 0x144f: // conveyor belt switch (red)
element = EL_CONVEYOR_BELT_1_SWITCH_MIDDLE;
break;
- case 0x1452: /* conveyor belt switch (blue) */
+ case 0x1452: // conveyor belt switch (blue)
element = EL_CONVEYOR_BELT_4_SWITCH_MIDDLE;
break;
element = EL_EXPANDABLE_WALL_ANY;
break;
- case 0x14ce: /* growing steel wall (left/right) */
+ case 0x14ce: // growing steel wall (left/right)
element = EL_EXPANDABLE_STEELWALL_HORIZONTAL;
break;
- case 0x14df: /* growing steel wall (up/down) */
+ case 0x14df: // growing steel wall (up/down)
element = EL_EXPANDABLE_STEELWALL_VERTICAL;
break;
- case 0x14e8: /* growing steel wall (up/down/left/right) */
+ case 0x14e8: // growing steel wall (up/down/left/right)
element = EL_EXPANDABLE_STEELWALL_ANY;
break;
element = EL_EMPTY_SPACE;
break;
- case 0x1578: /* quicksand (empty) */
+ case 0x1578: // quicksand (empty)
element = EL_QUICKSAND_FAST_EMPTY;
break;
- case 0x1579: /* slow quicksand (empty) */
+ case 0x1579: // slow quicksand (empty)
element = EL_QUICKSAND_EMPTY;
break;
- /* 0x157c - 0x158b: */
- /* EL_SAND */
+ // 0x157c - 0x158b:
+ // EL_SAND
- /* 0x1590 - 0x159f: */
- /* EL_DC_LANDMINE */
+ // 0x1590 - 0x159f:
+ // EL_DC_LANDMINE
case 0x15a0:
element = EL_EM_DYNAMITE;
break;
- case 0x15a1: /* key (red) */
+ case 0x15a1: // key (red)
element = EL_EM_KEY_1;
break;
- case 0x15a2: /* key (yellow) */
+ case 0x15a2: // key (yellow)
element = EL_EM_KEY_2;
break;
- case 0x15a3: /* key (blue) */
+ case 0x15a3: // key (blue)
element = EL_EM_KEY_4;
break;
- case 0x15a4: /* key (green) */
+ case 0x15a4: // key (green)
element = EL_EM_KEY_3;
break;
- case 0x15a5: /* key (white) */
+ case 0x15a5: // key (white)
element = EL_DC_KEY_WHITE;
break;
element = EL_WALL;
break;
- case 0x15a8: /* wall (not round) */
+ case 0x15a8: // wall (not round)
element = EL_WALL;
break;
- case 0x15a9: /* (blue) */
+ case 0x15a9: // (blue)
element = EL_CHAR_A;
break;
- case 0x15aa: /* (blue) */
+ case 0x15aa: // (blue)
element = EL_CHAR_B;
break;
- case 0x15ab: /* (blue) */
+ case 0x15ab: // (blue)
element = EL_CHAR_C;
break;
- case 0x15ac: /* (blue) */
+ case 0x15ac: // (blue)
element = EL_CHAR_D;
break;
- case 0x15ad: /* (blue) */
+ case 0x15ad: // (blue)
element = EL_CHAR_E;
break;
- case 0x15ae: /* (blue) */
+ case 0x15ae: // (blue)
element = EL_CHAR_F;
break;
- case 0x15af: /* (blue) */
+ case 0x15af: // (blue)
element = EL_CHAR_G;
break;
- case 0x15b0: /* (blue) */
+ case 0x15b0: // (blue)
element = EL_CHAR_H;
break;
- case 0x15b1: /* (blue) */
+ case 0x15b1: // (blue)
element = EL_CHAR_I;
break;
- case 0x15b2: /* (blue) */
+ case 0x15b2: // (blue)
element = EL_CHAR_J;
break;
- case 0x15b3: /* (blue) */
+ case 0x15b3: // (blue)
element = EL_CHAR_K;
break;
- case 0x15b4: /* (blue) */
+ case 0x15b4: // (blue)
element = EL_CHAR_L;
break;
- case 0x15b5: /* (blue) */
+ case 0x15b5: // (blue)
element = EL_CHAR_M;
break;
- case 0x15b6: /* (blue) */
+ case 0x15b6: // (blue)
element = EL_CHAR_N;
break;
- case 0x15b7: /* (blue) */
+ case 0x15b7: // (blue)
element = EL_CHAR_O;
break;
- case 0x15b8: /* (blue) */
+ case 0x15b8: // (blue)
element = EL_CHAR_P;
break;
- case 0x15b9: /* (blue) */
+ case 0x15b9: // (blue)
element = EL_CHAR_Q;
break;
- case 0x15ba: /* (blue) */
+ case 0x15ba: // (blue)
element = EL_CHAR_R;
break;
- case 0x15bb: /* (blue) */
+ case 0x15bb: // (blue)
element = EL_CHAR_S;
break;
- case 0x15bc: /* (blue) */
+ case 0x15bc: // (blue)
element = EL_CHAR_T;
break;
- case 0x15bd: /* (blue) */
+ case 0x15bd: // (blue)
element = EL_CHAR_U;
break;
- case 0x15be: /* (blue) */
+ case 0x15be: // (blue)
element = EL_CHAR_V;
break;
- case 0x15bf: /* (blue) */
+ case 0x15bf: // (blue)
element = EL_CHAR_W;
break;
- case 0x15c0: /* (blue) */
+ case 0x15c0: // (blue)
element = EL_CHAR_X;
break;
- case 0x15c1: /* (blue) */
+ case 0x15c1: // (blue)
element = EL_CHAR_Y;
break;
- case 0x15c2: /* (blue) */
+ case 0x15c2: // (blue)
element = EL_CHAR_Z;
break;
- case 0x15c3: /* (blue) */
+ case 0x15c3: // (blue)
element = EL_CHAR_AUMLAUT;
break;
- case 0x15c4: /* (blue) */
+ case 0x15c4: // (blue)
element = EL_CHAR_OUMLAUT;
break;
- case 0x15c5: /* (blue) */
+ case 0x15c5: // (blue)
element = EL_CHAR_UUMLAUT;
break;
- case 0x15c6: /* (blue) */
+ case 0x15c6: // (blue)
element = EL_CHAR_0;
break;
- case 0x15c7: /* (blue) */
+ case 0x15c7: // (blue)
element = EL_CHAR_1;
break;
- case 0x15c8: /* (blue) */
+ case 0x15c8: // (blue)
element = EL_CHAR_2;
break;
- case 0x15c9: /* (blue) */
+ case 0x15c9: // (blue)
element = EL_CHAR_3;
break;
- case 0x15ca: /* (blue) */
+ case 0x15ca: // (blue)
element = EL_CHAR_4;
break;
- case 0x15cb: /* (blue) */
+ case 0x15cb: // (blue)
element = EL_CHAR_5;
break;
- case 0x15cc: /* (blue) */
+ case 0x15cc: // (blue)
element = EL_CHAR_6;
break;
- case 0x15cd: /* (blue) */
+ case 0x15cd: // (blue)
element = EL_CHAR_7;
break;
- case 0x15ce: /* (blue) */
+ case 0x15ce: // (blue)
element = EL_CHAR_8;
break;
- case 0x15cf: /* (blue) */
+ case 0x15cf: // (blue)
element = EL_CHAR_9;
break;
- case 0x15d0: /* (blue) */
+ case 0x15d0: // (blue)
element = EL_CHAR_PERIOD;
break;
- case 0x15d1: /* (blue) */
+ case 0x15d1: // (blue)
element = EL_CHAR_EXCLAM;
break;
- case 0x15d2: /* (blue) */
+ case 0x15d2: // (blue)
element = EL_CHAR_COLON;
break;
- case 0x15d3: /* (blue) */
+ case 0x15d3: // (blue)
element = EL_CHAR_LESS;
break;
- case 0x15d4: /* (blue) */
+ case 0x15d4: // (blue)
element = EL_CHAR_GREATER;
break;
- case 0x15d5: /* (blue) */
+ case 0x15d5: // (blue)
element = EL_CHAR_QUESTION;
break;
- case 0x15d6: /* (blue) */
+ case 0x15d6: // (blue)
element = EL_CHAR_COPYRIGHT;
break;
- case 0x15d7: /* (blue) */
+ case 0x15d7: // (blue)
element = EL_CHAR_UP;
break;
- case 0x15d8: /* (blue) */
+ case 0x15d8: // (blue)
element = EL_CHAR_DOWN;
break;
- case 0x15d9: /* (blue) */
+ case 0x15d9: // (blue)
element = EL_CHAR_BUTTON;
break;
- case 0x15da: /* (blue) */
+ case 0x15da: // (blue)
element = EL_CHAR_PLUS;
break;
- case 0x15db: /* (blue) */
+ case 0x15db: // (blue)
element = EL_CHAR_MINUS;
break;
- case 0x15dc: /* (blue) */
+ case 0x15dc: // (blue)
element = EL_CHAR_APOSTROPHE;
break;
- case 0x15dd: /* (blue) */
+ case 0x15dd: // (blue)
element = EL_CHAR_PARENLEFT;
break;
- case 0x15de: /* (blue) */
+ case 0x15de: // (blue)
element = EL_CHAR_PARENRIGHT;
break;
- case 0x15df: /* (green) */
+ case 0x15df: // (green)
element = EL_CHAR_A;
break;
- case 0x15e0: /* (green) */
+ case 0x15e0: // (green)
element = EL_CHAR_B;
break;
- case 0x15e1: /* (green) */
+ case 0x15e1: // (green)
element = EL_CHAR_C;
break;
- case 0x15e2: /* (green) */
+ case 0x15e2: // (green)
element = EL_CHAR_D;
break;
- case 0x15e3: /* (green) */
+ case 0x15e3: // (green)
element = EL_CHAR_E;
break;
- case 0x15e4: /* (green) */
+ case 0x15e4: // (green)
element = EL_CHAR_F;
break;
- case 0x15e5: /* (green) */
+ case 0x15e5: // (green)
element = EL_CHAR_G;
break;
- case 0x15e6: /* (green) */
+ case 0x15e6: // (green)
element = EL_CHAR_H;
break;
- case 0x15e7: /* (green) */
+ case 0x15e7: // (green)
element = EL_CHAR_I;
break;
- case 0x15e8: /* (green) */
+ case 0x15e8: // (green)
element = EL_CHAR_J;
break;
- case 0x15e9: /* (green) */
+ case 0x15e9: // (green)
element = EL_CHAR_K;
break;
- case 0x15ea: /* (green) */
+ case 0x15ea: // (green)
element = EL_CHAR_L;
break;
- case 0x15eb: /* (green) */
+ case 0x15eb: // (green)
element = EL_CHAR_M;
break;
- case 0x15ec: /* (green) */
+ case 0x15ec: // (green)
element = EL_CHAR_N;
break;
- case 0x15ed: /* (green) */
+ case 0x15ed: // (green)
element = EL_CHAR_O;
break;
- case 0x15ee: /* (green) */
+ case 0x15ee: // (green)
element = EL_CHAR_P;
break;
- case 0x15ef: /* (green) */
+ case 0x15ef: // (green)
element = EL_CHAR_Q;
break;
- case 0x15f0: /* (green) */
+ case 0x15f0: // (green)
element = EL_CHAR_R;
break;
- case 0x15f1: /* (green) */
+ case 0x15f1: // (green)
element = EL_CHAR_S;
break;
- case 0x15f2: /* (green) */
+ case 0x15f2: // (green)
element = EL_CHAR_T;
break;
- case 0x15f3: /* (green) */
+ case 0x15f3: // (green)
element = EL_CHAR_U;
break;
- case 0x15f4: /* (green) */
+ case 0x15f4: // (green)
element = EL_CHAR_V;
break;
- case 0x15f5: /* (green) */
+ case 0x15f5: // (green)
element = EL_CHAR_W;
break;
- case 0x15f6: /* (green) */
+ case 0x15f6: // (green)
element = EL_CHAR_X;
break;
- case 0x15f7: /* (green) */
+ case 0x15f7: // (green)
element = EL_CHAR_Y;
break;
- case 0x15f8: /* (green) */
+ case 0x15f8: // (green)
element = EL_CHAR_Z;
break;
- case 0x15f9: /* (green) */
+ case 0x15f9: // (green)
element = EL_CHAR_AUMLAUT;
break;
- case 0x15fa: /* (green) */
+ case 0x15fa: // (green)
element = EL_CHAR_OUMLAUT;
break;
- case 0x15fb: /* (green) */
+ case 0x15fb: // (green)
element = EL_CHAR_UUMLAUT;
break;
- case 0x15fc: /* (green) */
+ case 0x15fc: // (green)
element = EL_CHAR_0;
break;
- case 0x15fd: /* (green) */
+ case 0x15fd: // (green)
element = EL_CHAR_1;
break;
- case 0x15fe: /* (green) */
+ case 0x15fe: // (green)
element = EL_CHAR_2;
break;
- case 0x15ff: /* (green) */
+ case 0x15ff: // (green)
element = EL_CHAR_3;
break;
- case 0x1600: /* (green) */
+ case 0x1600: // (green)
element = EL_CHAR_4;
break;
- case 0x1601: /* (green) */
+ case 0x1601: // (green)
element = EL_CHAR_5;
break;
- case 0x1602: /* (green) */
+ case 0x1602: // (green)
element = EL_CHAR_6;
break;
- case 0x1603: /* (green) */
+ case 0x1603: // (green)
element = EL_CHAR_7;
break;
- case 0x1604: /* (green) */
+ case 0x1604: // (green)
element = EL_CHAR_8;
break;
- case 0x1605: /* (green) */
+ case 0x1605: // (green)
element = EL_CHAR_9;
break;
- case 0x1606: /* (green) */
+ case 0x1606: // (green)
element = EL_CHAR_PERIOD;
break;
- case 0x1607: /* (green) */
+ case 0x1607: // (green)
element = EL_CHAR_EXCLAM;
break;
- case 0x1608: /* (green) */
+ case 0x1608: // (green)
element = EL_CHAR_COLON;
break;
- case 0x1609: /* (green) */
+ case 0x1609: // (green)
element = EL_CHAR_LESS;
break;
- case 0x160a: /* (green) */
+ case 0x160a: // (green)
element = EL_CHAR_GREATER;
break;
- case 0x160b: /* (green) */
+ case 0x160b: // (green)
element = EL_CHAR_QUESTION;
break;
- case 0x160c: /* (green) */
+ case 0x160c: // (green)
element = EL_CHAR_COPYRIGHT;
break;
- case 0x160d: /* (green) */
+ case 0x160d: // (green)
element = EL_CHAR_UP;
break;
- case 0x160e: /* (green) */
+ case 0x160e: // (green)
element = EL_CHAR_DOWN;
break;
- case 0x160f: /* (green) */
+ case 0x160f: // (green)
element = EL_CHAR_BUTTON;
break;
- case 0x1610: /* (green) */
+ case 0x1610: // (green)
element = EL_CHAR_PLUS;
break;
- case 0x1611: /* (green) */
+ case 0x1611: // (green)
element = EL_CHAR_MINUS;
break;
- case 0x1612: /* (green) */
+ case 0x1612: // (green)
element = EL_CHAR_APOSTROPHE;
break;
- case 0x1613: /* (green) */
+ case 0x1613: // (green)
element = EL_CHAR_PARENLEFT;
break;
- case 0x1614: /* (green) */
+ case 0x1614: // (green)
element = EL_CHAR_PARENRIGHT;
break;
- case 0x1615: /* (blue steel) */
+ case 0x1615: // (blue steel)
element = EL_STEEL_CHAR_A;
break;
- case 0x1616: /* (blue steel) */
+ case 0x1616: // (blue steel)
element = EL_STEEL_CHAR_B;
break;
- case 0x1617: /* (blue steel) */
+ case 0x1617: // (blue steel)
element = EL_STEEL_CHAR_C;
break;
- case 0x1618: /* (blue steel) */
+ case 0x1618: // (blue steel)
element = EL_STEEL_CHAR_D;
break;
- case 0x1619: /* (blue steel) */
+ case 0x1619: // (blue steel)
element = EL_STEEL_CHAR_E;
break;
- case 0x161a: /* (blue steel) */
+ case 0x161a: // (blue steel)
element = EL_STEEL_CHAR_F;
break;
- case 0x161b: /* (blue steel) */
+ case 0x161b: // (blue steel)
element = EL_STEEL_CHAR_G;
break;
- case 0x161c: /* (blue steel) */
+ case 0x161c: // (blue steel)
element = EL_STEEL_CHAR_H;
break;
- case 0x161d: /* (blue steel) */
+ case 0x161d: // (blue steel)
element = EL_STEEL_CHAR_I;
break;
- case 0x161e: /* (blue steel) */
+ case 0x161e: // (blue steel)
element = EL_STEEL_CHAR_J;
break;
- case 0x161f: /* (blue steel) */
+ case 0x161f: // (blue steel)
element = EL_STEEL_CHAR_K;
break;
- case 0x1620: /* (blue steel) */
+ case 0x1620: // (blue steel)
element = EL_STEEL_CHAR_L;
break;
- case 0x1621: /* (blue steel) */
+ case 0x1621: // (blue steel)
element = EL_STEEL_CHAR_M;
break;
- case 0x1622: /* (blue steel) */
+ case 0x1622: // (blue steel)
element = EL_STEEL_CHAR_N;
break;
- case 0x1623: /* (blue steel) */
+ case 0x1623: // (blue steel)
element = EL_STEEL_CHAR_O;
break;
- case 0x1624: /* (blue steel) */
+ case 0x1624: // (blue steel)
element = EL_STEEL_CHAR_P;
break;
- case 0x1625: /* (blue steel) */
+ case 0x1625: // (blue steel)
element = EL_STEEL_CHAR_Q;
break;
- case 0x1626: /* (blue steel) */
+ case 0x1626: // (blue steel)
element = EL_STEEL_CHAR_R;
break;
- case 0x1627: /* (blue steel) */
+ case 0x1627: // (blue steel)
element = EL_STEEL_CHAR_S;
break;
- case 0x1628: /* (blue steel) */
+ case 0x1628: // (blue steel)
element = EL_STEEL_CHAR_T;
break;
- case 0x1629: /* (blue steel) */
+ case 0x1629: // (blue steel)
element = EL_STEEL_CHAR_U;
break;
- case 0x162a: /* (blue steel) */
+ case 0x162a: // (blue steel)
element = EL_STEEL_CHAR_V;
break;
- case 0x162b: /* (blue steel) */
+ case 0x162b: // (blue steel)
element = EL_STEEL_CHAR_W;
break;
- case 0x162c: /* (blue steel) */
+ case 0x162c: // (blue steel)
element = EL_STEEL_CHAR_X;
break;
- case 0x162d: /* (blue steel) */
+ case 0x162d: // (blue steel)
element = EL_STEEL_CHAR_Y;
break;
- case 0x162e: /* (blue steel) */
+ case 0x162e: // (blue steel)
element = EL_STEEL_CHAR_Z;
break;
- case 0x162f: /* (blue steel) */
+ case 0x162f: // (blue steel)
element = EL_STEEL_CHAR_AUMLAUT;
break;
- case 0x1630: /* (blue steel) */
+ case 0x1630: // (blue steel)
element = EL_STEEL_CHAR_OUMLAUT;
break;
- case 0x1631: /* (blue steel) */
+ case 0x1631: // (blue steel)
element = EL_STEEL_CHAR_UUMLAUT;
break;
- case 0x1632: /* (blue steel) */
+ case 0x1632: // (blue steel)
element = EL_STEEL_CHAR_0;
break;
- case 0x1633: /* (blue steel) */
+ case 0x1633: // (blue steel)
element = EL_STEEL_CHAR_1;
break;
- case 0x1634: /* (blue steel) */
+ case 0x1634: // (blue steel)
element = EL_STEEL_CHAR_2;
break;
- case 0x1635: /* (blue steel) */
+ case 0x1635: // (blue steel)
element = EL_STEEL_CHAR_3;
break;
- case 0x1636: /* (blue steel) */
+ case 0x1636: // (blue steel)
element = EL_STEEL_CHAR_4;
break;
- case 0x1637: /* (blue steel) */
+ case 0x1637: // (blue steel)
element = EL_STEEL_CHAR_5;
break;
- case 0x1638: /* (blue steel) */
+ case 0x1638: // (blue steel)
element = EL_STEEL_CHAR_6;
break;
- case 0x1639: /* (blue steel) */
+ case 0x1639: // (blue steel)
element = EL_STEEL_CHAR_7;
break;
- case 0x163a: /* (blue steel) */
+ case 0x163a: // (blue steel)
element = EL_STEEL_CHAR_8;
break;
- case 0x163b: /* (blue steel) */
+ case 0x163b: // (blue steel)
element = EL_STEEL_CHAR_9;
break;
- case 0x163c: /* (blue steel) */
+ case 0x163c: // (blue steel)
element = EL_STEEL_CHAR_PERIOD;
break;
- case 0x163d: /* (blue steel) */
+ case 0x163d: // (blue steel)
element = EL_STEEL_CHAR_EXCLAM;
break;
- case 0x163e: /* (blue steel) */
+ case 0x163e: // (blue steel)
element = EL_STEEL_CHAR_COLON;
break;
- case 0x163f: /* (blue steel) */
+ case 0x163f: // (blue steel)
element = EL_STEEL_CHAR_LESS;
break;
- case 0x1640: /* (blue steel) */
+ case 0x1640: // (blue steel)
element = EL_STEEL_CHAR_GREATER;
break;
- case 0x1641: /* (blue steel) */
+ case 0x1641: // (blue steel)
element = EL_STEEL_CHAR_QUESTION;
break;
- case 0x1642: /* (blue steel) */
+ case 0x1642: // (blue steel)
element = EL_STEEL_CHAR_COPYRIGHT;
break;
- case 0x1643: /* (blue steel) */
+ case 0x1643: // (blue steel)
element = EL_STEEL_CHAR_UP;
break;
- case 0x1644: /* (blue steel) */
+ case 0x1644: // (blue steel)
element = EL_STEEL_CHAR_DOWN;
break;
- case 0x1645: /* (blue steel) */
+ case 0x1645: // (blue steel)
element = EL_STEEL_CHAR_BUTTON;
break;
- case 0x1646: /* (blue steel) */
+ case 0x1646: // (blue steel)
element = EL_STEEL_CHAR_PLUS;
break;
- case 0x1647: /* (blue steel) */
+ case 0x1647: // (blue steel)
element = EL_STEEL_CHAR_MINUS;
break;
- case 0x1648: /* (blue steel) */
+ case 0x1648: // (blue steel)
element = EL_STEEL_CHAR_APOSTROPHE;
break;
- case 0x1649: /* (blue steel) */
+ case 0x1649: // (blue steel)
element = EL_STEEL_CHAR_PARENLEFT;
break;
- case 0x164a: /* (blue steel) */
+ case 0x164a: // (blue steel)
element = EL_STEEL_CHAR_PARENRIGHT;
break;
- case 0x164b: /* (green steel) */
+ case 0x164b: // (green steel)
element = EL_STEEL_CHAR_A;
break;
- case 0x164c: /* (green steel) */
+ case 0x164c: // (green steel)
element = EL_STEEL_CHAR_B;
break;
- case 0x164d: /* (green steel) */
+ case 0x164d: // (green steel)
element = EL_STEEL_CHAR_C;
break;
- case 0x164e: /* (green steel) */
+ case 0x164e: // (green steel)
element = EL_STEEL_CHAR_D;
break;
- case 0x164f: /* (green steel) */
+ case 0x164f: // (green steel)
element = EL_STEEL_CHAR_E;
break;
- case 0x1650: /* (green steel) */
+ case 0x1650: // (green steel)
element = EL_STEEL_CHAR_F;
break;
- case 0x1651: /* (green steel) */
+ case 0x1651: // (green steel)
element = EL_STEEL_CHAR_G;
break;
- case 0x1652: /* (green steel) */
+ case 0x1652: // (green steel)
element = EL_STEEL_CHAR_H;
break;
- case 0x1653: /* (green steel) */
+ case 0x1653: // (green steel)
element = EL_STEEL_CHAR_I;
break;
- case 0x1654: /* (green steel) */
+ case 0x1654: // (green steel)
element = EL_STEEL_CHAR_J;
break;
- case 0x1655: /* (green steel) */
+ case 0x1655: // (green steel)
element = EL_STEEL_CHAR_K;
break;
- case 0x1656: /* (green steel) */
+ case 0x1656: // (green steel)
element = EL_STEEL_CHAR_L;
break;
- case 0x1657: /* (green steel) */
+ case 0x1657: // (green steel)
element = EL_STEEL_CHAR_M;
break;
- case 0x1658: /* (green steel) */
+ case 0x1658: // (green steel)
element = EL_STEEL_CHAR_N;
break;
- case 0x1659: /* (green steel) */
+ case 0x1659: // (green steel)
element = EL_STEEL_CHAR_O;
break;
- case 0x165a: /* (green steel) */
+ case 0x165a: // (green steel)
element = EL_STEEL_CHAR_P;
break;
- case 0x165b: /* (green steel) */
+ case 0x165b: // (green steel)
element = EL_STEEL_CHAR_Q;
break;
- case 0x165c: /* (green steel) */
+ case 0x165c: // (green steel)
element = EL_STEEL_CHAR_R;
break;
- case 0x165d: /* (green steel) */
+ case 0x165d: // (green steel)
element = EL_STEEL_CHAR_S;
break;
- case 0x165e: /* (green steel) */
+ case 0x165e: // (green steel)
element = EL_STEEL_CHAR_T;
break;
- case 0x165f: /* (green steel) */
+ case 0x165f: // (green steel)
element = EL_STEEL_CHAR_U;
break;
- case 0x1660: /* (green steel) */
+ case 0x1660: // (green steel)
element = EL_STEEL_CHAR_V;
break;
- case 0x1661: /* (green steel) */
+ case 0x1661: // (green steel)
element = EL_STEEL_CHAR_W;
break;
- case 0x1662: /* (green steel) */
+ case 0x1662: // (green steel)
element = EL_STEEL_CHAR_X;
break;
- case 0x1663: /* (green steel) */
+ case 0x1663: // (green steel)
element = EL_STEEL_CHAR_Y;
break;
- case 0x1664: /* (green steel) */
+ case 0x1664: // (green steel)
element = EL_STEEL_CHAR_Z;
break;
- case 0x1665: /* (green steel) */
+ case 0x1665: // (green steel)
element = EL_STEEL_CHAR_AUMLAUT;
break;
- case 0x1666: /* (green steel) */
+ case 0x1666: // (green steel)
element = EL_STEEL_CHAR_OUMLAUT;
break;
- case 0x1667: /* (green steel) */
+ case 0x1667: // (green steel)
element = EL_STEEL_CHAR_UUMLAUT;
break;
- case 0x1668: /* (green steel) */
+ case 0x1668: // (green steel)
element = EL_STEEL_CHAR_0;
break;
- case 0x1669: /* (green steel) */
+ case 0x1669: // (green steel)
element = EL_STEEL_CHAR_1;
break;
- case 0x166a: /* (green steel) */
+ case 0x166a: // (green steel)
element = EL_STEEL_CHAR_2;
break;
- case 0x166b: /* (green steel) */
+ case 0x166b: // (green steel)
element = EL_STEEL_CHAR_3;
break;
- case 0x166c: /* (green steel) */
+ case 0x166c: // (green steel)
element = EL_STEEL_CHAR_4;
break;
- case 0x166d: /* (green steel) */
+ case 0x166d: // (green steel)
element = EL_STEEL_CHAR_5;
break;
- case 0x166e: /* (green steel) */
+ case 0x166e: // (green steel)
element = EL_STEEL_CHAR_6;
break;
- case 0x166f: /* (green steel) */
+ case 0x166f: // (green steel)
element = EL_STEEL_CHAR_7;
break;
- case 0x1670: /* (green steel) */
+ case 0x1670: // (green steel)
element = EL_STEEL_CHAR_8;
break;
- case 0x1671: /* (green steel) */
+ case 0x1671: // (green steel)
element = EL_STEEL_CHAR_9;
break;
- case 0x1672: /* (green steel) */
+ case 0x1672: // (green steel)
element = EL_STEEL_CHAR_PERIOD;
break;
- case 0x1673: /* (green steel) */
+ case 0x1673: // (green steel)
element = EL_STEEL_CHAR_EXCLAM;
break;
- case 0x1674: /* (green steel) */
+ case 0x1674: // (green steel)
element = EL_STEEL_CHAR_COLON;
break;
- case 0x1675: /* (green steel) */
+ case 0x1675: // (green steel)
element = EL_STEEL_CHAR_LESS;
break;
- case 0x1676: /* (green steel) */
+ case 0x1676: // (green steel)
element = EL_STEEL_CHAR_GREATER;
break;
- case 0x1677: /* (green steel) */
+ case 0x1677: // (green steel)
element = EL_STEEL_CHAR_QUESTION;
break;
- case 0x1678: /* (green steel) */
+ case 0x1678: // (green steel)
element = EL_STEEL_CHAR_COPYRIGHT;
break;
- case 0x1679: /* (green steel) */
+ case 0x1679: // (green steel)
element = EL_STEEL_CHAR_UP;
break;
- case 0x167a: /* (green steel) */
+ case 0x167a: // (green steel)
element = EL_STEEL_CHAR_DOWN;
break;
- case 0x167b: /* (green steel) */
+ case 0x167b: // (green steel)
element = EL_STEEL_CHAR_BUTTON;
break;
- case 0x167c: /* (green steel) */
+ case 0x167c: // (green steel)
element = EL_STEEL_CHAR_PLUS;
break;
- case 0x167d: /* (green steel) */
+ case 0x167d: // (green steel)
element = EL_STEEL_CHAR_MINUS;
break;
- case 0x167e: /* (green steel) */
+ case 0x167e: // (green steel)
element = EL_STEEL_CHAR_APOSTROPHE;
break;
- case 0x167f: /* (green steel) */
+ case 0x167f: // (green steel)
element = EL_STEEL_CHAR_PARENLEFT;
break;
- case 0x1680: /* (green steel) */
+ case 0x1680: // (green steel)
element = EL_STEEL_CHAR_PARENRIGHT;
break;
- case 0x1681: /* gate (red) */
+ case 0x1681: // gate (red)
element = EL_EM_GATE_1;
break;
- case 0x1682: /* secret gate (red) */
+ case 0x1682: // secret gate (red)
element = EL_GATE_1_GRAY;
break;
- case 0x1683: /* gate (yellow) */
+ case 0x1683: // gate (yellow)
element = EL_EM_GATE_2;
break;
- case 0x1684: /* secret gate (yellow) */
+ case 0x1684: // secret gate (yellow)
element = EL_GATE_2_GRAY;
break;
- case 0x1685: /* gate (blue) */
+ case 0x1685: // gate (blue)
element = EL_EM_GATE_4;
break;
- case 0x1686: /* secret gate (blue) */
+ case 0x1686: // secret gate (blue)
element = EL_GATE_4_GRAY;
break;
- case 0x1687: /* gate (green) */
+ case 0x1687: // gate (green)
element = EL_EM_GATE_3;
break;
- case 0x1688: /* secret gate (green) */
+ case 0x1688: // secret gate (green)
element = EL_GATE_3_GRAY;
break;
- case 0x1689: /* gate (white) */
+ case 0x1689: // gate (white)
element = EL_DC_GATE_WHITE;
break;
- case 0x168a: /* secret gate (white) */
+ case 0x168a: // secret gate (white)
element = EL_DC_GATE_WHITE_GRAY;
break;
- case 0x168b: /* secret gate (no key) */
+ case 0x168b: // secret gate (no key)
element = EL_DC_GATE_FAKE_GRAY;
break;
element = EL_STEELWALL_SLIPPERY;
break;
- case 0x1695: /* steel wall (not round) */
+ case 0x1695: // steel wall (not round)
element = EL_STEELWALL;
break;
- case 0x1696: /* steel wall (left) */
+ case 0x1696: // steel wall (left)
element = EL_DC_STEELWALL_1_LEFT;
break;
- case 0x1697: /* steel wall (bottom) */
+ case 0x1697: // steel wall (bottom)
element = EL_DC_STEELWALL_1_BOTTOM;
break;
- case 0x1698: /* steel wall (right) */
+ case 0x1698: // steel wall (right)
element = EL_DC_STEELWALL_1_RIGHT;
break;
- case 0x1699: /* steel wall (top) */
+ case 0x1699: // steel wall (top)
element = EL_DC_STEELWALL_1_TOP;
break;
- case 0x169a: /* steel wall (left/bottom) */
+ case 0x169a: // steel wall (left/bottom)
element = EL_DC_STEELWALL_1_BOTTOMLEFT;
break;
- case 0x169b: /* steel wall (right/bottom) */
+ case 0x169b: // steel wall (right/bottom)
element = EL_DC_STEELWALL_1_BOTTOMRIGHT;
break;
- case 0x169c: /* steel wall (right/top) */
+ case 0x169c: // steel wall (right/top)
element = EL_DC_STEELWALL_1_TOPRIGHT;
break;
- case 0x169d: /* steel wall (left/top) */
+ case 0x169d: // steel wall (left/top)
element = EL_DC_STEELWALL_1_TOPLEFT;
break;
- case 0x169e: /* steel wall (right/bottom small) */
+ case 0x169e: // steel wall (right/bottom small)
element = EL_DC_STEELWALL_1_BOTTOMRIGHT_2;
break;
- case 0x169f: /* steel wall (left/bottom small) */
+ case 0x169f: // steel wall (left/bottom small)
element = EL_DC_STEELWALL_1_BOTTOMLEFT_2;
break;
- case 0x16a0: /* steel wall (right/top small) */
+ case 0x16a0: // steel wall (right/top small)
element = EL_DC_STEELWALL_1_TOPRIGHT_2;
break;
- case 0x16a1: /* steel wall (left/top small) */
+ case 0x16a1: // steel wall (left/top small)
element = EL_DC_STEELWALL_1_TOPLEFT_2;
break;
- case 0x16a2: /* steel wall (left/right) */
+ case 0x16a2: // steel wall (left/right)
element = EL_DC_STEELWALL_1_VERTICAL;
break;
- case 0x16a3: /* steel wall (top/bottom) */
+ case 0x16a3: // steel wall (top/bottom)
element = EL_DC_STEELWALL_1_HORIZONTAL;
break;
- case 0x16a4: /* steel wall 2 (left end) */
+ case 0x16a4: // steel wall 2 (left end)
element = EL_DC_STEELWALL_2_LEFT;
break;
- case 0x16a5: /* steel wall 2 (right end) */
+ case 0x16a5: // steel wall 2 (right end)
element = EL_DC_STEELWALL_2_RIGHT;
break;
- case 0x16a6: /* steel wall 2 (top end) */
+ case 0x16a6: // steel wall 2 (top end)
element = EL_DC_STEELWALL_2_TOP;
break;
- case 0x16a7: /* steel wall 2 (bottom end) */
+ case 0x16a7: // steel wall 2 (bottom end)
element = EL_DC_STEELWALL_2_BOTTOM;
break;
- case 0x16a8: /* steel wall 2 (left/right) */
+ case 0x16a8: // steel wall 2 (left/right)
element = EL_DC_STEELWALL_2_HORIZONTAL;
break;
- case 0x16a9: /* steel wall 2 (up/down) */
+ case 0x16a9: // steel wall 2 (up/down)
element = EL_DC_STEELWALL_2_VERTICAL;
break;
- case 0x16aa: /* steel wall 2 (mid) */
+ case 0x16aa: // steel wall 2 (mid)
element = EL_DC_STEELWALL_2_MIDDLE;
break;
element = EL_INVISIBLE_STEELWALL;
break;
- /* 0x16bc - 0x16cb: */
- /* EL_INVISIBLE_SAND */
+ // 0x16bc - 0x16cb:
+ // EL_INVISIBLE_SAND
case 0x16cc:
element = EL_LIGHT_SWITCH;
break;
default:
- if (element >= 0x0117 && element <= 0x036e) /* (?) */
+ if (element >= 0x0117 && element <= 0x036e) // (?)
element = EL_DIAMOND;
- else if (element >= 0x042d && element <= 0x0684) /* (?) */
+ else if (element >= 0x042d && element <= 0x0684) // (?)
element = EL_EMERALD;
else if (element >= 0x157c && element <= 0x158b)
element = EL_SAND;
int num_yamyam_contents;
int i, x, y;
- getDecodedWord_DC(0, TRUE); /* initialize DC2 decoding engine */
+ getDecodedWord_DC(0, TRUE); // initialize DC2 decoding engine
for (i = 0; i < DC_LEVEL_HEADER_SIZE / 2; i++)
{
header[i * 2 + 1] = header_word & 0xff;
}
- /* read some values from level header to check level decoding integrity */
+ // read some values from level header to check level decoding integrity
fieldx = header[6] | (header[7] << 8);
fieldy = header[8] | (header[9] << 8);
num_yamyam_contents = header[60] | (header[61] << 8);
- /* do some simple sanity checks to ensure that level was correctly decoded */
+ // do some simple sanity checks to ensure that level was correctly decoded
if (fieldx < 1 || fieldx > 256 ||
fieldy < 1 || fieldy > 256 ||
num_yamyam_contents < 1 || num_yamyam_contents > 8)
return;
}
- /* maximum envelope header size is 31 bytes */
+ // maximum envelope header size is 31 bytes
envelope_header_len = header[envelope_header_pos];
- /* maximum envelope content size is 110 (156?) bytes */
+ // maximum envelope content size is 110 (156?) bytes
envelope_content_len = header[envelope_content_pos];
- /* maximum level title size is 40 bytes */
+ // maximum level title size is 40 bytes
level_name_len = MIN(header[level_name_pos], MAX_LEVEL_NAME_LEN);
- /* maximum level author size is 30 (51?) bytes */
+ // maximum level author size is 30 (51?) bytes
level_author_len = MIN(header[level_author_pos], MAX_LEVEL_AUTHOR_LEN);
envelope_size = 0;
if (level_file_info->packed)
{
- /* read "magic bytes" from start of file */
+ // read "magic bytes" from start of file
if (getStringFromFile(file, magic_bytes, num_magic_bytes + 1) == NULL)
magic_bytes[0] = '\0';
- /* check "magic bytes" for correct file format */
+ // check "magic bytes" for correct file format
if (!strPrefix(magic_bytes, "DC2"))
{
level->no_valid_file = TRUE;
int extra_bytes = 4;
int skip_bytes;
- /* advance file stream to first level inside the level package */
+ // advance file stream to first level inside the level package
skip_bytes = position_first_level - num_magic_bytes - extra_bytes;
- /* each block of level data is followed by block of non-level data */
+ // each block of level data is followed by block of non-level data
num_levels_to_skip *= 2;
- /* at least skip header bytes, therefore use ">= 0" instead of "> 0" */
+ // at least skip header bytes, therefore use ">= 0" instead of "> 0"
while (num_levels_to_skip >= 0)
{
- /* advance file stream to next level inside the level package */
+ // advance file stream to next level inside the level package
projects / rocksndiamonds.git / commitdiff