1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
17 #include "libgame/libgame.h"
27 #define ENABLE_UNUSED_CODE 0 // currently unused functions
28 #define ENABLE_HISTORIC_CHUNKS 0 // only for historic reference
29 #define ENABLE_RESERVED_CODE 0 // reserved for later use
31 #define CHUNK_ID_LEN 4 // IFF style chunk id length
32 #define CHUNK_SIZE_UNDEFINED 0 // undefined chunk size == 0
33 #define CHUNK_SIZE_NONE -1 // do not write chunk size
35 #define LEVEL_CHUNK_NAME_SIZE MAX_LEVEL_NAME_LEN
36 #define LEVEL_CHUNK_AUTH_SIZE MAX_LEVEL_AUTHOR_LEN
38 #define LEVEL_CHUNK_VERS_SIZE 8 // size of file version chunk
39 #define LEVEL_CHUNK_DATE_SIZE 4 // size of file date chunk
40 #define LEVEL_CHUNK_HEAD_SIZE 80 // size of level file header
41 #define LEVEL_CHUNK_HEAD_UNUSED 0 // unused level header bytes
42 #define LEVEL_CHUNK_CNT2_SIZE 160 // size of level CNT2 chunk
43 #define LEVEL_CHUNK_CNT2_UNUSED 11 // unused CNT2 chunk bytes
44 #define LEVEL_CHUNK_CNT3_HEADER 16 // size of level CNT3 header
45 #define LEVEL_CHUNK_CNT3_UNUSED 10 // unused CNT3 chunk bytes
46 #define LEVEL_CPART_CUS3_SIZE 134 // size of CUS3 chunk part
47 #define LEVEL_CPART_CUS3_UNUSED 15 // unused CUS3 bytes / part
48 #define LEVEL_CHUNK_GRP1_SIZE 74 // size of level GRP1 chunk
50 // (element number, number of change pages, change page number)
51 #define LEVEL_CHUNK_CUSX_UNCHANGED (2 + (1 + 1) + (1 + 1))
53 // (element number only)
54 #define LEVEL_CHUNK_GRPX_UNCHANGED 2
55 #define LEVEL_CHUNK_EMPX_UNCHANGED 2
56 #define LEVEL_CHUNK_NOTE_UNCHANGED 2
58 // (nothing at all if unchanged)
59 #define LEVEL_CHUNK_ELEM_UNCHANGED 0
61 #define TAPE_CHUNK_VERS_SIZE 8 // size of file version chunk
62 #define TAPE_CHUNK_HEAD_SIZE 20 // size of tape file header
63 #define TAPE_CHUNK_SCRN_SIZE 2 // size of screen size chunk
65 #define SCORE_CHUNK_VERS_SIZE 8 // size of file version chunk
67 #define LEVEL_CHUNK_CNT3_SIZE(x) (LEVEL_CHUNK_CNT3_HEADER + (x))
68 #define LEVEL_CHUNK_CUS3_SIZE(x) (2 + (x) * LEVEL_CPART_CUS3_SIZE)
69 #define LEVEL_CHUNK_CUS4_SIZE(x) (96 + (x) * 48)
71 // file identifier strings
72 #define LEVEL_COOKIE_TMPL "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
73 #define TAPE_COOKIE_TMPL "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
74 #define SCORE_COOKIE_TMPL "ROCKSNDIAMONDS_SCORE_FILE_VERSION_x.x"
76 // values for deciding when (not) to save configuration data
77 #define SAVE_CONF_NEVER 0
78 #define SAVE_CONF_ALWAYS 1
79 #define SAVE_CONF_WHEN_CHANGED -1
81 // values for chunks using micro chunks
82 #define CONF_MASK_1_BYTE 0x00
83 #define CONF_MASK_2_BYTE 0x40
84 #define CONF_MASK_4_BYTE 0x80
85 #define CONF_MASK_MULTI_BYTES 0xc0
87 #define CONF_MASK_BYTES 0xc0
88 #define CONF_MASK_TOKEN 0x3f
90 #define CONF_VALUE_1_BYTE(x) (CONF_MASK_1_BYTE | (x))
91 #define CONF_VALUE_2_BYTE(x) (CONF_MASK_2_BYTE | (x))
92 #define CONF_VALUE_4_BYTE(x) (CONF_MASK_4_BYTE | (x))
93 #define CONF_VALUE_MULTI_BYTES(x) (CONF_MASK_MULTI_BYTES | (x))
95 // these definitions are just for convenience of use and readability
96 #define CONF_VALUE_8_BIT(x) CONF_VALUE_1_BYTE(x)
97 #define CONF_VALUE_16_BIT(x) CONF_VALUE_2_BYTE(x)
98 #define CONF_VALUE_32_BIT(x) CONF_VALUE_4_BYTE(x)
99 #define CONF_VALUE_BYTES(x) CONF_VALUE_MULTI_BYTES(x)
101 #define CONF_VALUE_NUM_BYTES(x) ((x) == CONF_MASK_1_BYTE ? 1 : \
102 (x) == CONF_MASK_2_BYTE ? 2 : \
103 (x) == CONF_MASK_4_BYTE ? 4 : 0)
105 #define CONF_CONTENT_NUM_ELEMENTS (3 * 3)
106 #define CONF_CONTENT_NUM_BYTES (CONF_CONTENT_NUM_ELEMENTS * 2)
107 #define CONF_ELEMENT_NUM_BYTES (2)
109 #define CONF_ENTITY_NUM_BYTES(t) ((t) == TYPE_ELEMENT || \
110 (t) == TYPE_ELEMENT_LIST ? \
111 CONF_ELEMENT_NUM_BYTES : \
112 (t) == TYPE_CONTENT || \
113 (t) == TYPE_CONTENT_LIST ? \
114 CONF_CONTENT_NUM_BYTES : 1)
116 #define CONF_ELEMENT_BYTE_POS(i) ((i) * CONF_ELEMENT_NUM_BYTES)
117 #define CONF_ELEMENTS_ELEMENT(b, i) ((b[CONF_ELEMENT_BYTE_POS(i)] << 8) | \
118 (b[CONF_ELEMENT_BYTE_POS(i) + 1]))
120 #define CONF_CONTENT_ELEMENT_POS(c,x,y) ((c) * CONF_CONTENT_NUM_ELEMENTS + \
122 #define CONF_CONTENT_BYTE_POS(c,x,y) (CONF_CONTENT_ELEMENT_POS(c,x,y) * \
123 CONF_ELEMENT_NUM_BYTES)
124 #define CONF_CONTENTS_ELEMENT(b,c,x,y) ((b[CONF_CONTENT_BYTE_POS(c,x,y)]<< 8)|\
125 (b[CONF_CONTENT_BYTE_POS(c,x,y) + 1]))
127 // temporary variables used to store pointers to structure members
128 static struct LevelInfo li;
129 static struct ElementInfo xx_ei, yy_ei;
130 static struct ElementChangeInfo xx_change;
131 static struct ElementGroupInfo xx_group;
132 static struct EnvelopeInfo xx_envelope;
133 static unsigned int xx_event_bits[NUM_CE_BITFIELDS];
134 static char xx_default_description[MAX_ELEMENT_NAME_LEN + 1];
135 static int xx_num_contents;
136 static int xx_current_change_page;
137 static char xx_default_string_empty[1] = "";
138 static int xx_string_length_unused;
140 struct LevelFileConfigInfo
142 int element; // element for which data is to be stored
143 int save_type; // save data always, never or when changed
144 int data_type; // data type (used internally, not stored)
145 int conf_type; // micro chunk identifier (stored in file)
148 void *value; // variable that holds the data to be stored
149 int default_value; // initial default value for this variable
152 void *value_copy; // variable that holds the data to be copied
153 void *num_entities; // number of entities for multi-byte data
154 int default_num_entities; // default number of entities for this data
155 int max_num_entities; // maximal number of entities for this data
156 char *default_string; // optional default string for string data
159 static struct LevelFileConfigInfo chunk_config_INFO[] =
161 // ---------- values not related to single elements -------------------------
164 -1, SAVE_CONF_ALWAYS,
165 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
166 &li.game_engine_type, GAME_ENGINE_TYPE_RND
170 -1, SAVE_CONF_ALWAYS,
171 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
172 &li.fieldx, STD_LEV_FIELDX
175 -1, SAVE_CONF_ALWAYS,
176 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
177 &li.fieldy, STD_LEV_FIELDY
181 -1, SAVE_CONF_ALWAYS,
182 TYPE_INTEGER, CONF_VALUE_16_BIT(3),
187 -1, SAVE_CONF_ALWAYS,
188 TYPE_INTEGER, CONF_VALUE_16_BIT(4),
194 TYPE_INTEGER, CONF_VALUE_32_BIT(2),
200 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
201 &li.use_step_counter, FALSE
206 TYPE_BITFIELD, CONF_VALUE_8_BIT(4),
207 &li.wind_direction_initial, MV_NONE
212 TYPE_BOOLEAN, CONF_VALUE_8_BIT(5),
213 &li.em_slippery_gems, FALSE
218 TYPE_BOOLEAN, CONF_VALUE_8_BIT(6),
219 &li.use_custom_template, FALSE
224 TYPE_BITFIELD, CONF_VALUE_32_BIT(1),
225 &li.can_move_into_acid_bits, ~0 // default: everything can
230 TYPE_BITFIELD, CONF_VALUE_8_BIT(7),
231 &li.dont_collide_with_bits, ~0 // default: always deadly
236 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
237 &li.em_explodes_by_fire, FALSE
242 TYPE_INTEGER, CONF_VALUE_16_BIT(5),
243 &li.score[SC_TIME_BONUS], 1
248 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
249 &li.auto_exit_sokoban, FALSE
254 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
255 &li.auto_count_gems, FALSE
260 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
261 &li.solved_by_one_player, FALSE
266 TYPE_INTEGER, CONF_VALUE_8_BIT(12),
267 &li.time_score_base, 1
272 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
273 &li.rate_time_over_score, FALSE
283 static struct LevelFileConfigInfo chunk_config_ELEM[] =
285 // (these values are the same for each player)
288 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
289 &li.block_last_field, FALSE // default case for EM levels
293 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
294 &li.sp_block_last_field, TRUE // default case for SP levels
298 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
299 &li.instant_relocation, FALSE
303 TYPE_BOOLEAN, CONF_VALUE_8_BIT(4),
304 &li.can_pass_to_walkable, FALSE
308 TYPE_BOOLEAN, CONF_VALUE_8_BIT(5),
309 &li.block_snap_field, TRUE
313 TYPE_BOOLEAN, CONF_VALUE_8_BIT(6),
314 &li.continuous_snapping, TRUE
318 TYPE_BOOLEAN, CONF_VALUE_8_BIT(12),
319 &li.shifted_relocation, FALSE
323 TYPE_BOOLEAN, CONF_VALUE_8_BIT(15),
324 &li.lazy_relocation, FALSE
328 TYPE_BOOLEAN, CONF_VALUE_8_BIT(16),
329 &li.finish_dig_collect, TRUE
333 TYPE_BOOLEAN, CONF_VALUE_8_BIT(17),
334 &li.keep_walkable_ce, FALSE
337 // (these values are different for each player)
340 TYPE_INTEGER, CONF_VALUE_8_BIT(7),
341 &li.initial_player_stepsize[0], STEPSIZE_NORMAL
345 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
346 &li.initial_player_gravity[0], FALSE
350 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
351 &li.use_start_element[0], FALSE
355 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
356 &li.start_element[0], EL_PLAYER_1
360 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
361 &li.use_artwork_element[0], FALSE
365 TYPE_ELEMENT, CONF_VALUE_16_BIT(2),
366 &li.artwork_element[0], EL_PLAYER_1
370 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
371 &li.use_explosion_element[0], FALSE
375 TYPE_ELEMENT, CONF_VALUE_16_BIT(3),
376 &li.explosion_element[0], EL_PLAYER_1
380 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
381 &li.use_initial_inventory[0], FALSE
385 TYPE_BOOLEAN, CONF_VALUE_8_BIT(14),
386 &li.initial_inventory_size[0], 1
390 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
391 &li.initial_inventory_content[0][0],EL_EMPTY, NULL,
392 &li.initial_inventory_size[0], 1, MAX_INITIAL_INVENTORY_SIZE
397 TYPE_INTEGER, CONF_VALUE_8_BIT(7),
398 &li.initial_player_stepsize[1], STEPSIZE_NORMAL
402 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
403 &li.initial_player_gravity[1], FALSE
407 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
408 &li.use_start_element[1], FALSE
412 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
413 &li.start_element[1], EL_PLAYER_2
417 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
418 &li.use_artwork_element[1], FALSE
422 TYPE_ELEMENT, CONF_VALUE_16_BIT(2),
423 &li.artwork_element[1], EL_PLAYER_2
427 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
428 &li.use_explosion_element[1], FALSE
432 TYPE_ELEMENT, CONF_VALUE_16_BIT(3),
433 &li.explosion_element[1], EL_PLAYER_2
437 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
438 &li.use_initial_inventory[1], FALSE
442 TYPE_BOOLEAN, CONF_VALUE_8_BIT(14),
443 &li.initial_inventory_size[1], 1
447 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
448 &li.initial_inventory_content[1][0],EL_EMPTY, NULL,
449 &li.initial_inventory_size[1], 1, MAX_INITIAL_INVENTORY_SIZE
454 TYPE_INTEGER, CONF_VALUE_8_BIT(7),
455 &li.initial_player_stepsize[2], STEPSIZE_NORMAL
459 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
460 &li.initial_player_gravity[2], FALSE
464 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
465 &li.use_start_element[2], FALSE
469 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
470 &li.start_element[2], EL_PLAYER_3
474 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
475 &li.use_artwork_element[2], FALSE
479 TYPE_ELEMENT, CONF_VALUE_16_BIT(2),
480 &li.artwork_element[2], EL_PLAYER_3
484 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
485 &li.use_explosion_element[2], FALSE
489 TYPE_ELEMENT, CONF_VALUE_16_BIT(3),
490 &li.explosion_element[2], EL_PLAYER_3
494 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
495 &li.use_initial_inventory[2], FALSE
499 TYPE_BOOLEAN, CONF_VALUE_8_BIT(14),
500 &li.initial_inventory_size[2], 1
504 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
505 &li.initial_inventory_content[2][0],EL_EMPTY, NULL,
506 &li.initial_inventory_size[2], 1, MAX_INITIAL_INVENTORY_SIZE
511 TYPE_INTEGER, CONF_VALUE_8_BIT(7),
512 &li.initial_player_stepsize[3], STEPSIZE_NORMAL
516 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
517 &li.initial_player_gravity[3], FALSE
521 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
522 &li.use_start_element[3], FALSE
526 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
527 &li.start_element[3], EL_PLAYER_4
531 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
532 &li.use_artwork_element[3], FALSE
536 TYPE_ELEMENT, CONF_VALUE_16_BIT(2),
537 &li.artwork_element[3], EL_PLAYER_4
541 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
542 &li.use_explosion_element[3], FALSE
546 TYPE_ELEMENT, CONF_VALUE_16_BIT(3),
547 &li.explosion_element[3], EL_PLAYER_4
551 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
552 &li.use_initial_inventory[3], FALSE
556 TYPE_BOOLEAN, CONF_VALUE_8_BIT(14),
557 &li.initial_inventory_size[3], 1
561 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
562 &li.initial_inventory_content[3][0],EL_EMPTY, NULL,
563 &li.initial_inventory_size[3], 1, MAX_INITIAL_INVENTORY_SIZE
568 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
569 &li.score[SC_EMERALD], 10
574 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
575 &li.score[SC_DIAMOND], 10
580 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
581 &li.score[SC_BUG], 10
586 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
587 &li.score[SC_SPACESHIP], 10
592 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
593 &li.score[SC_PACMAN], 10
598 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
599 &li.score[SC_NUT], 10
604 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
605 &li.score[SC_DYNAMITE], 10
610 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
611 &li.score[SC_KEY], 10
616 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
617 &li.score[SC_PEARL], 10
622 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
623 &li.score[SC_CRYSTAL], 10
628 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
629 &li.amoeba_content, EL_DIAMOND
633 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
638 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
639 &li.grow_into_diggable, TRUE
644 TYPE_CONTENT_LIST, CONF_VALUE_BYTES(1),
645 &li.yamyam_content, EL_ROCK, NULL,
646 &li.num_yamyam_contents, 4, MAX_ELEMENT_CONTENTS
650 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
651 &li.score[SC_YAMYAM], 10
656 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
657 &li.score[SC_ROBOT], 10
661 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
667 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
673 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
674 &li.time_magic_wall, 10
679 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
680 &li.game_of_life[0], 2
684 TYPE_INTEGER, CONF_VALUE_8_BIT(2),
685 &li.game_of_life[1], 3
689 TYPE_INTEGER, CONF_VALUE_8_BIT(3),
690 &li.game_of_life[2], 3
694 TYPE_INTEGER, CONF_VALUE_8_BIT(4),
695 &li.game_of_life[3], 3
699 TYPE_BOOLEAN, CONF_VALUE_8_BIT(5),
700 &li.use_life_bugs, FALSE
705 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
710 TYPE_INTEGER, CONF_VALUE_8_BIT(2),
715 TYPE_INTEGER, CONF_VALUE_8_BIT(3),
720 TYPE_INTEGER, CONF_VALUE_8_BIT(4),
725 EL_TIMEGATE_SWITCH, -1,
726 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
727 &li.time_timegate, 10
731 EL_LIGHT_SWITCH_ACTIVE, -1,
732 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
737 EL_SHIELD_NORMAL, -1,
738 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
739 &li.shield_normal_time, 10
742 EL_SHIELD_NORMAL, -1,
743 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
744 &li.score[SC_SHIELD], 10
748 EL_SHIELD_DEADLY, -1,
749 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
750 &li.shield_deadly_time, 10
753 EL_SHIELD_DEADLY, -1,
754 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
755 &li.score[SC_SHIELD], 10
760 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
765 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
766 &li.extra_time_score, 10
770 EL_TIME_ORB_FULL, -1,
771 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
772 &li.time_orb_time, 10
775 EL_TIME_ORB_FULL, -1,
776 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
777 &li.use_time_orb_bug, FALSE
782 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
783 &li.use_spring_bug, FALSE
788 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
789 &li.android_move_time, 10
793 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
794 &li.android_clone_time, 10
797 EL_EMC_ANDROID, SAVE_CONF_NEVER,
798 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
799 &li.android_clone_element[0], EL_EMPTY, NULL,
800 &li.num_android_clone_elements, 1, MAX_ANDROID_ELEMENTS_OLD
804 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(2),
805 &li.android_clone_element[0], EL_EMPTY, NULL,
806 &li.num_android_clone_elements, 1, MAX_ANDROID_ELEMENTS
811 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
816 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
821 EL_EMC_MAGNIFIER, -1,
822 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
823 &li.magnify_score, 10
826 EL_EMC_MAGNIFIER, -1,
827 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
832 EL_EMC_MAGIC_BALL, -1,
833 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
837 EL_EMC_MAGIC_BALL, -1,
838 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
839 &li.ball_random, FALSE
842 EL_EMC_MAGIC_BALL, -1,
843 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
844 &li.ball_active_initial, FALSE
847 EL_EMC_MAGIC_BALL, -1,
848 TYPE_CONTENT_LIST, CONF_VALUE_BYTES(1),
849 &li.ball_content, EL_EMPTY, NULL,
850 &li.num_ball_contents, 4, MAX_ELEMENT_CONTENTS
854 EL_SOKOBAN_FIELD_EMPTY, -1,
855 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
856 &li.sb_fields_needed, TRUE
860 EL_SOKOBAN_OBJECT, -1,
861 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
862 &li.sb_objects_needed, TRUE
867 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
868 &li.mm_laser_red, FALSE
872 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
873 &li.mm_laser_green, FALSE
877 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
878 &li.mm_laser_blue, TRUE
883 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
884 &li.df_laser_red, TRUE
888 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
889 &li.df_laser_green, TRUE
893 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
894 &li.df_laser_blue, FALSE
898 EL_MM_FUSE_ACTIVE, -1,
899 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
904 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
910 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
915 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
916 &li.mm_ball_choice_mode, ANIM_RANDOM
920 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(1),
921 &li.mm_ball_content, EL_EMPTY, NULL,
922 &li.num_mm_ball_contents, 8, MAX_MM_BALL_CONTENTS
926 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
927 &li.rotate_mm_ball_content, TRUE
931 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
932 &li.explode_mm_ball, FALSE
936 EL_MM_STEEL_BLOCK, -1,
937 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
938 &li.mm_time_block, 75
942 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
943 &li.score[SC_ELEM_BONUS], 10
946 // ---------- unused values -------------------------------------------------
949 EL_UNKNOWN, SAVE_CONF_NEVER,
950 TYPE_INTEGER, CONF_VALUE_16_BIT(1),
951 &li.score[SC_UNKNOWN_15], 10
961 static struct LevelFileConfigInfo chunk_config_NOTE[] =
965 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
966 &xx_envelope.xsize, MAX_ENVELOPE_XSIZE,
970 TYPE_INTEGER, CONF_VALUE_8_BIT(2),
971 &xx_envelope.ysize, MAX_ENVELOPE_YSIZE,
976 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
977 &xx_envelope.autowrap, FALSE
981 TYPE_BOOLEAN, CONF_VALUE_8_BIT(4),
982 &xx_envelope.centered, FALSE
987 TYPE_STRING, CONF_VALUE_BYTES(1),
988 &xx_envelope.text, -1, NULL,
989 &xx_string_length_unused, -1, MAX_ENVELOPE_TEXT_LEN,
990 &xx_default_string_empty[0]
1000 static struct LevelFileConfigInfo chunk_config_CUSX_base[] =
1004 TYPE_STRING, CONF_VALUE_BYTES(1),
1005 &xx_ei.description[0], -1,
1006 &yy_ei.description[0],
1007 &xx_string_length_unused, -1, MAX_ELEMENT_NAME_LEN,
1008 &xx_default_description[0]
1013 TYPE_BITFIELD, CONF_VALUE_32_BIT(1),
1014 &xx_ei.properties[EP_BITFIELD_BASE_NR], EP_BITMASK_BASE_DEFAULT,
1015 &yy_ei.properties[EP_BITFIELD_BASE_NR]
1017 #if ENABLE_RESERVED_CODE
1018 // (reserved for later use)
1021 TYPE_BITFIELD, CONF_VALUE_32_BIT(2),
1022 &xx_ei.properties[EP_BITFIELD_BASE_NR + 1], EP_BITMASK_DEFAULT,
1023 &yy_ei.properties[EP_BITFIELD_BASE_NR + 1]
1029 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
1030 &xx_ei.use_gfx_element, FALSE,
1031 &yy_ei.use_gfx_element
1035 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
1036 &xx_ei.gfx_element_initial, EL_EMPTY_SPACE,
1037 &yy_ei.gfx_element_initial
1042 TYPE_BITFIELD, CONF_VALUE_8_BIT(2),
1043 &xx_ei.access_direction, MV_ALL_DIRECTIONS,
1044 &yy_ei.access_direction
1049 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
1050 &xx_ei.collect_score_initial, 10,
1051 &yy_ei.collect_score_initial
1055 TYPE_INTEGER, CONF_VALUE_16_BIT(3),
1056 &xx_ei.collect_count_initial, 1,
1057 &yy_ei.collect_count_initial
1062 TYPE_INTEGER, CONF_VALUE_16_BIT(4),
1063 &xx_ei.ce_value_fixed_initial, 0,
1064 &yy_ei.ce_value_fixed_initial
1068 TYPE_INTEGER, CONF_VALUE_16_BIT(5),
1069 &xx_ei.ce_value_random_initial, 0,
1070 &yy_ei.ce_value_random_initial
1074 TYPE_BOOLEAN, CONF_VALUE_8_BIT(3),
1075 &xx_ei.use_last_ce_value, FALSE,
1076 &yy_ei.use_last_ce_value
1081 TYPE_INTEGER, CONF_VALUE_16_BIT(6),
1082 &xx_ei.push_delay_fixed, 8,
1083 &yy_ei.push_delay_fixed
1087 TYPE_INTEGER, CONF_VALUE_16_BIT(7),
1088 &xx_ei.push_delay_random, 8,
1089 &yy_ei.push_delay_random
1093 TYPE_INTEGER, CONF_VALUE_16_BIT(8),
1094 &xx_ei.drop_delay_fixed, 0,
1095 &yy_ei.drop_delay_fixed
1099 TYPE_INTEGER, CONF_VALUE_16_BIT(9),
1100 &xx_ei.drop_delay_random, 0,
1101 &yy_ei.drop_delay_random
1105 TYPE_INTEGER, CONF_VALUE_16_BIT(10),
1106 &xx_ei.move_delay_fixed, 0,
1107 &yy_ei.move_delay_fixed
1111 TYPE_INTEGER, CONF_VALUE_16_BIT(11),
1112 &xx_ei.move_delay_random, 0,
1113 &yy_ei.move_delay_random
1117 TYPE_INTEGER, CONF_VALUE_16_BIT(16),
1118 &xx_ei.step_delay_fixed, 0,
1119 &yy_ei.step_delay_fixed
1123 TYPE_INTEGER, CONF_VALUE_16_BIT(17),
1124 &xx_ei.step_delay_random, 0,
1125 &yy_ei.step_delay_random
1130 TYPE_BITFIELD, CONF_VALUE_32_BIT(3),
1131 &xx_ei.move_pattern, MV_ALL_DIRECTIONS,
1136 TYPE_BITFIELD, CONF_VALUE_8_BIT(4),
1137 &xx_ei.move_direction_initial, MV_START_AUTOMATIC,
1138 &yy_ei.move_direction_initial
1142 TYPE_INTEGER, CONF_VALUE_8_BIT(5),
1143 &xx_ei.move_stepsize, TILEX / 8,
1144 &yy_ei.move_stepsize
1149 TYPE_ELEMENT, CONF_VALUE_16_BIT(12),
1150 &xx_ei.move_enter_element, EL_EMPTY_SPACE,
1151 &yy_ei.move_enter_element
1155 TYPE_ELEMENT, CONF_VALUE_16_BIT(13),
1156 &xx_ei.move_leave_element, EL_EMPTY_SPACE,
1157 &yy_ei.move_leave_element
1161 TYPE_INTEGER, CONF_VALUE_8_BIT(6),
1162 &xx_ei.move_leave_type, LEAVE_TYPE_UNLIMITED,
1163 &yy_ei.move_leave_type
1168 TYPE_INTEGER, CONF_VALUE_8_BIT(7),
1169 &xx_ei.slippery_type, SLIPPERY_ANY_RANDOM,
1170 &yy_ei.slippery_type
1175 TYPE_INTEGER, CONF_VALUE_8_BIT(8),
1176 &xx_ei.explosion_type, EXPLODES_3X3,
1177 &yy_ei.explosion_type
1181 TYPE_INTEGER, CONF_VALUE_16_BIT(14),
1182 &xx_ei.explosion_delay, 16,
1183 &yy_ei.explosion_delay
1187 TYPE_INTEGER, CONF_VALUE_16_BIT(15),
1188 &xx_ei.ignition_delay, 8,
1189 &yy_ei.ignition_delay
1194 TYPE_CONTENT_LIST, CONF_VALUE_BYTES(2),
1195 &xx_ei.content, EL_EMPTY_SPACE,
1197 &xx_num_contents, 1, 1
1200 // ---------- "num_change_pages" must be the last entry ---------------------
1203 -1, SAVE_CONF_ALWAYS,
1204 TYPE_INTEGER, CONF_VALUE_8_BIT(9),
1205 &xx_ei.num_change_pages, 1,
1206 &yy_ei.num_change_pages
1217 static struct LevelFileConfigInfo chunk_config_CUSX_change[] =
1219 // ---------- "current_change_page" must be the first entry -----------------
1222 -1, SAVE_CONF_ALWAYS,
1223 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
1224 &xx_current_change_page, -1
1227 // ---------- (the remaining entries can be in any order) -------------------
1231 TYPE_BOOLEAN, CONF_VALUE_8_BIT(2),
1232 &xx_change.can_change, FALSE
1237 TYPE_BITFIELD, CONF_VALUE_32_BIT(1),
1238 &xx_event_bits[0], 0
1242 TYPE_BITFIELD, CONF_VALUE_32_BIT(2),
1243 &xx_event_bits[1], 0
1248 TYPE_BITFIELD, CONF_VALUE_8_BIT(3),
1249 &xx_change.trigger_player, CH_PLAYER_ANY
1253 TYPE_BITFIELD, CONF_VALUE_8_BIT(4),
1254 &xx_change.trigger_side, CH_SIDE_ANY
1258 TYPE_BITFIELD, CONF_VALUE_32_BIT(3),
1259 &xx_change.trigger_page, CH_PAGE_ANY
1264 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
1265 &xx_change.target_element, EL_EMPTY_SPACE
1270 TYPE_INTEGER, CONF_VALUE_16_BIT(2),
1271 &xx_change.delay_fixed, 0
1275 TYPE_INTEGER, CONF_VALUE_16_BIT(3),
1276 &xx_change.delay_random, 0
1280 TYPE_INTEGER, CONF_VALUE_16_BIT(4),
1281 &xx_change.delay_frames, FRAMES_PER_SECOND
1286 TYPE_ELEMENT, CONF_VALUE_16_BIT(5),
1287 &xx_change.initial_trigger_element, EL_EMPTY_SPACE
1292 TYPE_BOOLEAN, CONF_VALUE_8_BIT(6),
1293 &xx_change.explode, FALSE
1297 TYPE_BOOLEAN, CONF_VALUE_8_BIT(7),
1298 &xx_change.use_target_content, FALSE
1302 TYPE_BOOLEAN, CONF_VALUE_8_BIT(8),
1303 &xx_change.only_if_complete, FALSE
1307 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
1308 &xx_change.use_random_replace, FALSE
1312 TYPE_INTEGER, CONF_VALUE_8_BIT(10),
1313 &xx_change.random_percentage, 100
1317 TYPE_INTEGER, CONF_VALUE_8_BIT(11),
1318 &xx_change.replace_when, CP_WHEN_EMPTY
1323 TYPE_BOOLEAN, CONF_VALUE_8_BIT(12),
1324 &xx_change.has_action, FALSE
1328 TYPE_INTEGER, CONF_VALUE_8_BIT(13),
1329 &xx_change.action_type, CA_NO_ACTION
1333 TYPE_INTEGER, CONF_VALUE_8_BIT(14),
1334 &xx_change.action_mode, CA_MODE_UNDEFINED
1338 TYPE_INTEGER, CONF_VALUE_16_BIT(6),
1339 &xx_change.action_arg, CA_ARG_UNDEFINED
1344 TYPE_ELEMENT, CONF_VALUE_16_BIT(7),
1345 &xx_change.action_element, EL_EMPTY_SPACE
1350 TYPE_CONTENT_LIST, CONF_VALUE_BYTES(1),
1351 &xx_change.target_content, EL_EMPTY_SPACE, NULL,
1352 &xx_num_contents, 1, 1
1362 static struct LevelFileConfigInfo chunk_config_GRPX[] =
1366 TYPE_STRING, CONF_VALUE_BYTES(1),
1367 &xx_ei.description[0], -1, NULL,
1368 &xx_string_length_unused, -1, MAX_ELEMENT_NAME_LEN,
1369 &xx_default_description[0]
1374 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
1375 &xx_ei.use_gfx_element, FALSE
1379 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
1380 &xx_ei.gfx_element_initial, EL_EMPTY_SPACE
1385 TYPE_INTEGER, CONF_VALUE_8_BIT(2),
1386 &xx_group.choice_mode, ANIM_RANDOM
1391 TYPE_ELEMENT_LIST, CONF_VALUE_BYTES(2),
1392 &xx_group.element[0], EL_EMPTY_SPACE, NULL,
1393 &xx_group.num_elements, 1, MAX_ELEMENTS_IN_GROUP
1403 static struct LevelFileConfigInfo chunk_config_EMPX[] =
1407 TYPE_BOOLEAN, CONF_VALUE_8_BIT(1),
1408 &xx_ei.use_gfx_element, FALSE
1412 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
1413 &xx_ei.gfx_element_initial, EL_EMPTY_SPACE
1423 static struct LevelFileConfigInfo chunk_config_CONF[] = // (OBSOLETE)
1427 TYPE_BOOLEAN, CONF_VALUE_8_BIT(9),
1428 &li.block_snap_field, TRUE
1432 TYPE_BOOLEAN, CONF_VALUE_8_BIT(13),
1433 &li.continuous_snapping, TRUE
1437 TYPE_INTEGER, CONF_VALUE_8_BIT(1),
1438 &li.initial_player_stepsize[0], STEPSIZE_NORMAL
1442 TYPE_BOOLEAN, CONF_VALUE_8_BIT(10),
1443 &li.use_start_element[0], FALSE
1447 TYPE_ELEMENT, CONF_VALUE_16_BIT(1),
1448 &li.start_element[0], EL_PLAYER_1
1452 TYPE_BOOLEAN, CONF_VALUE_8_BIT(11),
1453 &li.use_artwork_element[0], FALSE
1457 TYPE_ELEMENT, CONF_VALUE_16_BIT(2),
1458 &li.artwork_element[0], EL_PLAYER_1
1462 TYPE_BOOLEAN, CONF_VALUE_8_BIT(12),
1463 &li.use_explosion_element[0], FALSE
1467 TYPE_ELEMENT, CONF_VALUE_16_BIT(3),
1468 &li.explosion_element[0], EL_PLAYER_1
1483 filetype_id_list[] =
1485 { LEVEL_FILE_TYPE_RND, "RND" },
1486 { LEVEL_FILE_TYPE_BD, "BD" },
1487 { LEVEL_FILE_TYPE_EM, "EM" },
1488 { LEVEL_FILE_TYPE_SP, "SP" },
1489 { LEVEL_FILE_TYPE_DX, "DX" },
1490 { LEVEL_FILE_TYPE_SB, "SB" },
1491 { LEVEL_FILE_TYPE_DC, "DC" },
1492 { LEVEL_FILE_TYPE_MM, "MM" },
1493 { LEVEL_FILE_TYPE_MM, "DF" },
1498 // ============================================================================
1499 // level file functions
1500 // ============================================================================
1502 static boolean check_special_flags(char *flag)
1504 if (strEqual(options.special_flags, flag) ||
1505 strEqual(leveldir_current->special_flags, flag))
1511 static struct DateInfo getCurrentDate(void)
1513 time_t epoch_seconds = time(NULL);
1514 struct tm *now = localtime(&epoch_seconds);
1515 struct DateInfo date;
1517 date.year = now->tm_year + 1900;
1518 date.month = now->tm_mon + 1;
1519 date.day = now->tm_mday;
1521 date.src = DATE_SRC_CLOCK;
1526 static void resetEventFlags(struct ElementChangeInfo *change)
1530 for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1531 change->has_event[i] = FALSE;
1534 static void resetEventBits(void)
1538 for (i = 0; i < NUM_CE_BITFIELDS; i++)
1539 xx_event_bits[i] = 0;
1542 static void setEventFlagsFromEventBits(struct ElementChangeInfo *change)
1546 /* important: only change event flag if corresponding event bit is set
1547 (this is because all xx_event_bits[] values are loaded separately,
1548 and all xx_event_bits[] values are set back to zero before loading
1549 another value xx_event_bits[x] (each value representing 32 flags)) */
1551 for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1552 if (xx_event_bits[CH_EVENT_BITFIELD_NR(i)] & CH_EVENT_BIT(i))
1553 change->has_event[i] = TRUE;
1556 static void setEventBitsFromEventFlags(struct ElementChangeInfo *change)
1560 /* in contrast to the above function setEventFlagsFromEventBits(), it
1561 would also be possible to set all bits in xx_event_bits[] to 0 or 1
1562 depending on the corresponding change->has_event[i] values here, as
1563 all xx_event_bits[] values are reset in resetEventBits() before */
1565 for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1566 if (change->has_event[i])
1567 xx_event_bits[CH_EVENT_BITFIELD_NR(i)] |= CH_EVENT_BIT(i);
1570 static char *getDefaultElementDescription(struct ElementInfo *ei)
1572 static char description[MAX_ELEMENT_NAME_LEN + 1];
1573 char *default_description = (ei->custom_description != NULL ?
1574 ei->custom_description :
1575 ei->editor_description);
1578 // always start with reliable default values
1579 for (i = 0; i < MAX_ELEMENT_NAME_LEN + 1; i++)
1580 description[i] = '\0';
1582 // truncate element description to MAX_ELEMENT_NAME_LEN bytes
1583 strncpy(description, default_description, MAX_ELEMENT_NAME_LEN);
1585 return &description[0];
1588 static void setElementDescriptionToDefault(struct ElementInfo *ei)
1590 char *default_description = getDefaultElementDescription(ei);
1593 for (i = 0; i < MAX_ELEMENT_NAME_LEN + 1; i++)
1594 ei->description[i] = default_description[i];
1597 static void setConfigToDefaultsFromConfigList(struct LevelFileConfigInfo *conf)
1601 for (i = 0; conf[i].data_type != -1; i++)
1603 int default_value = conf[i].default_value;
1604 int data_type = conf[i].data_type;
1605 int conf_type = conf[i].conf_type;
1606 int byte_mask = conf_type & CONF_MASK_BYTES;
1608 if (byte_mask == CONF_MASK_MULTI_BYTES)
1610 int default_num_entities = conf[i].default_num_entities;
1611 int max_num_entities = conf[i].max_num_entities;
1613 *(int *)(conf[i].num_entities) = default_num_entities;
1615 if (data_type == TYPE_STRING)
1617 char *default_string = conf[i].default_string;
1618 char *string = (char *)(conf[i].value);
1620 strncpy(string, default_string, max_num_entities);
1622 else if (data_type == TYPE_ELEMENT_LIST)
1624 int *element_array = (int *)(conf[i].value);
1627 for (j = 0; j < max_num_entities; j++)
1628 element_array[j] = default_value;
1630 else if (data_type == TYPE_CONTENT_LIST)
1632 struct Content *content = (struct Content *)(conf[i].value);
1635 for (c = 0; c < max_num_entities; c++)
1636 for (y = 0; y < 3; y++)
1637 for (x = 0; x < 3; x++)
1638 content[c].e[x][y] = default_value;
1641 else // constant size configuration data (1, 2 or 4 bytes)
1643 if (data_type == TYPE_BOOLEAN)
1644 *(boolean *)(conf[i].value) = default_value;
1646 *(int *) (conf[i].value) = default_value;
1651 static void copyConfigFromConfigList(struct LevelFileConfigInfo *conf)
1655 for (i = 0; conf[i].data_type != -1; i++)
1657 int data_type = conf[i].data_type;
1658 int conf_type = conf[i].conf_type;
1659 int byte_mask = conf_type & CONF_MASK_BYTES;
1661 if (byte_mask == CONF_MASK_MULTI_BYTES)
1663 int max_num_entities = conf[i].max_num_entities;
1665 if (data_type == TYPE_STRING)
1667 char *string = (char *)(conf[i].value);
1668 char *string_copy = (char *)(conf[i].value_copy);
1670 strncpy(string_copy, string, max_num_entities);
1672 else if (data_type == TYPE_ELEMENT_LIST)
1674 int *element_array = (int *)(conf[i].value);
1675 int *element_array_copy = (int *)(conf[i].value_copy);
1678 for (j = 0; j < max_num_entities; j++)
1679 element_array_copy[j] = element_array[j];
1681 else if (data_type == TYPE_CONTENT_LIST)
1683 struct Content *content = (struct Content *)(conf[i].value);
1684 struct Content *content_copy = (struct Content *)(conf[i].value_copy);
1687 for (c = 0; c < max_num_entities; c++)
1688 for (y = 0; y < 3; y++)
1689 for (x = 0; x < 3; x++)
1690 content_copy[c].e[x][y] = content[c].e[x][y];
1693 else // constant size configuration data (1, 2 or 4 bytes)
1695 if (data_type == TYPE_BOOLEAN)
1696 *(boolean *)(conf[i].value_copy) = *(boolean *)(conf[i].value);
1698 *(int *) (conf[i].value_copy) = *(int *) (conf[i].value);
1703 void copyElementInfo(struct ElementInfo *ei_from, struct ElementInfo *ei_to)
1707 xx_ei = *ei_from; // copy element data into temporary buffer
1708 yy_ei = *ei_to; // copy element data into temporary buffer
1710 copyConfigFromConfigList(chunk_config_CUSX_base);
1715 // ---------- reinitialize and copy change pages ----------
1717 ei_to->num_change_pages = ei_from->num_change_pages;
1718 ei_to->current_change_page = ei_from->current_change_page;
1720 setElementChangePages(ei_to, ei_to->num_change_pages);
1722 for (i = 0; i < ei_to->num_change_pages; i++)
1723 ei_to->change_page[i] = ei_from->change_page[i];
1725 // ---------- copy group element info ----------
1726 if (ei_from->group != NULL && ei_to->group != NULL) // group or internal
1727 *ei_to->group = *ei_from->group;
1729 // mark this custom element as modified
1730 ei_to->modified_settings = TRUE;
1733 void setElementChangePages(struct ElementInfo *ei, int change_pages)
1735 int change_page_size = sizeof(struct ElementChangeInfo);
1737 ei->num_change_pages = MAX(1, change_pages);
1740 checked_realloc(ei->change_page, ei->num_change_pages * change_page_size);
1742 if (ei->current_change_page >= ei->num_change_pages)
1743 ei->current_change_page = ei->num_change_pages - 1;
1745 ei->change = &ei->change_page[ei->current_change_page];
1748 void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
1750 xx_change = *change; // copy change data into temporary buffer
1752 setConfigToDefaultsFromConfigList(chunk_config_CUSX_change);
1754 *change = xx_change;
1756 resetEventFlags(change);
1758 change->direct_action = 0;
1759 change->other_action = 0;
1761 change->pre_change_function = NULL;
1762 change->change_function = NULL;
1763 change->post_change_function = NULL;
1766 static void setLevelInfoToDefaults_Level(struct LevelInfo *level)
1770 li = *level; // copy level data into temporary buffer
1771 setConfigToDefaultsFromConfigList(chunk_config_INFO);
1772 *level = li; // copy temporary buffer back to level data
1774 setLevelInfoToDefaults_BD();
1775 setLevelInfoToDefaults_EM();
1776 setLevelInfoToDefaults_SP();
1777 setLevelInfoToDefaults_MM();
1779 level->native_bd_level = &native_bd_level;
1780 level->native_em_level = &native_em_level;
1781 level->native_sp_level = &native_sp_level;
1782 level->native_mm_level = &native_mm_level;
1784 level->file_version = FILE_VERSION_ACTUAL;
1785 level->game_version = GAME_VERSION_ACTUAL;
1787 level->creation_date = getCurrentDate();
1789 level->encoding_16bit_field = TRUE;
1790 level->encoding_16bit_yamyam = TRUE;
1791 level->encoding_16bit_amoeba = TRUE;
1793 // clear level name and level author string buffers
1794 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
1795 level->name[i] = '\0';
1796 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
1797 level->author[i] = '\0';
1799 // set level name and level author to default values
1800 strcpy(level->name, NAMELESS_LEVEL_NAME);
1801 strcpy(level->author, ANONYMOUS_NAME);
1803 // set level playfield to playable default level with player and exit
1804 for (x = 0; x < MAX_LEV_FIELDX; x++)
1805 for (y = 0; y < MAX_LEV_FIELDY; y++)
1806 level->field[x][y] = EL_SAND;
1808 level->field[0][0] = EL_PLAYER_1;
1809 level->field[STD_LEV_FIELDX - 1][STD_LEV_FIELDY - 1] = EL_EXIT_CLOSED;
1811 BorderElement = EL_STEELWALL;
1813 // detect custom elements when loading them
1814 level->file_has_custom_elements = FALSE;
1816 // set all bug compatibility flags to "false" => do not emulate this bug
1817 level->use_action_after_change_bug = FALSE;
1819 if (leveldir_current)
1821 // try to determine better author name than 'anonymous'
1822 if (!strEqual(leveldir_current->author, ANONYMOUS_NAME))
1824 strncpy(level->author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
1825 level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1829 switch (LEVELCLASS(leveldir_current))
1831 case LEVELCLASS_TUTORIAL:
1832 strcpy(level->author, PROGRAM_AUTHOR_STRING);
1835 case LEVELCLASS_CONTRIB:
1836 strncpy(level->author, leveldir_current->name, MAX_LEVEL_AUTHOR_LEN);
1837 level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1840 case LEVELCLASS_PRIVATE:
1841 strncpy(level->author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
1842 level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1846 // keep default value
1853 static void setLevelInfoToDefaults_Elements(struct LevelInfo *level)
1855 static boolean clipboard_elements_initialized = FALSE;
1858 InitElementPropertiesStatic();
1860 li = *level; // copy level data into temporary buffer
1861 setConfigToDefaultsFromConfigList(chunk_config_ELEM);
1862 *level = li; // copy temporary buffer back to level data
1864 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1867 struct ElementInfo *ei = &element_info[element];
1869 if (element == EL_MM_GRAY_BALL)
1871 struct LevelInfo_MM *level_mm = level->native_mm_level;
1874 for (j = 0; j < level->num_mm_ball_contents; j++)
1875 level->mm_ball_content[j] =
1876 map_element_MM_to_RND(level_mm->ball_content[j]);
1879 // never initialize clipboard elements after the very first time
1880 // (to be able to use clipboard elements between several levels)
1881 if (IS_CLIPBOARD_ELEMENT(element) && clipboard_elements_initialized)
1884 if (IS_ENVELOPE(element))
1886 int envelope_nr = element - EL_ENVELOPE_1;
1888 setConfigToDefaultsFromConfigList(chunk_config_NOTE);
1890 level->envelope[envelope_nr] = xx_envelope;
1893 if (IS_CUSTOM_ELEMENT(element) ||
1894 IS_GROUP_ELEMENT(element) ||
1895 IS_INTERNAL_ELEMENT(element))
1897 xx_ei = *ei; // copy element data into temporary buffer
1899 setConfigToDefaultsFromConfigList(chunk_config_CUSX_base);
1904 setElementChangePages(ei, 1);
1905 setElementChangeInfoToDefaults(ei->change);
1907 if (IS_CUSTOM_ELEMENT(element) ||
1908 IS_GROUP_ELEMENT(element))
1910 setElementDescriptionToDefault(ei);
1912 ei->modified_settings = FALSE;
1915 if (IS_CUSTOM_ELEMENT(element) ||
1916 IS_INTERNAL_ELEMENT(element))
1918 // internal values used in level editor
1920 ei->access_type = 0;
1921 ei->access_layer = 0;
1922 ei->access_protected = 0;
1923 ei->walk_to_action = 0;
1924 ei->smash_targets = 0;
1927 ei->can_explode_by_fire = FALSE;
1928 ei->can_explode_smashed = FALSE;
1929 ei->can_explode_impact = FALSE;
1931 ei->current_change_page = 0;
1934 if (IS_GROUP_ELEMENT(element) ||
1935 IS_INTERNAL_ELEMENT(element))
1937 struct ElementGroupInfo *group;
1939 // initialize memory for list of elements in group
1940 if (ei->group == NULL)
1941 ei->group = checked_malloc(sizeof(struct ElementGroupInfo));
1945 xx_group = *group; // copy group data into temporary buffer
1947 setConfigToDefaultsFromConfigList(chunk_config_GRPX);
1952 if (IS_EMPTY_ELEMENT(element) ||
1953 IS_INTERNAL_ELEMENT(element))
1955 xx_ei = *ei; // copy element data into temporary buffer
1957 setConfigToDefaultsFromConfigList(chunk_config_EMPX);
1963 clipboard_elements_initialized = TRUE;
1966 static void setLevelInfoToDefaults(struct LevelInfo *level,
1967 boolean level_info_only,
1968 boolean reset_file_status)
1970 setLevelInfoToDefaults_Level(level);
1972 if (!level_info_only)
1973 setLevelInfoToDefaults_Elements(level);
1975 if (reset_file_status)
1977 level->no_valid_file = FALSE;
1978 level->no_level_file = FALSE;
1981 level->changed = FALSE;
1984 static void setFileInfoToDefaults(struct LevelFileInfo *level_file_info)
1986 level_file_info->nr = 0;
1987 level_file_info->type = LEVEL_FILE_TYPE_UNKNOWN;
1988 level_file_info->packed = FALSE;
1990 setString(&level_file_info->basename, NULL);
1991 setString(&level_file_info->filename, NULL);
1994 int getMappedElement_SB(int, boolean);
1996 static void ActivateLevelTemplate(void)
2000 if (check_special_flags("load_xsb_to_ces"))
2002 // fill smaller playfields with padding "beyond border wall" elements
2003 if (level.fieldx < level_template.fieldx ||
2004 level.fieldy < level_template.fieldy)
2006 short field[level.fieldx][level.fieldy];
2007 int new_fieldx = MAX(level.fieldx, level_template.fieldx);
2008 int new_fieldy = MAX(level.fieldy, level_template.fieldy);
2009 int pos_fieldx = (new_fieldx - level.fieldx) / 2;
2010 int pos_fieldy = (new_fieldy - level.fieldy) / 2;
2012 // copy old playfield (which is smaller than the visible area)
2013 for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
2014 field[x][y] = level.field[x][y];
2016 // fill new, larger playfield with "beyond border wall" elements
2017 for (y = 0; y < new_fieldy; y++) for (x = 0; x < new_fieldx; x++)
2018 level.field[x][y] = getMappedElement_SB('_', TRUE);
2020 // copy the old playfield to the middle of the new playfield
2021 for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
2022 level.field[pos_fieldx + x][pos_fieldy + y] = field[x][y];
2024 level.fieldx = new_fieldx;
2025 level.fieldy = new_fieldy;
2029 // Currently there is no special action needed to activate the template
2030 // data, because 'element_info' property settings overwrite the original
2031 // level data, while all other variables do not change.
2033 // Exception: 'from_level_template' elements in the original level playfield
2034 // are overwritten with the corresponding elements at the same position in
2035 // playfield from the level template.
2037 for (x = 0; x < level.fieldx; x++)
2038 for (y = 0; y < level.fieldy; y++)
2039 if (level.field[x][y] == EL_FROM_LEVEL_TEMPLATE)
2040 level.field[x][y] = level_template.field[x][y];
2042 if (check_special_flags("load_xsb_to_ces"))
2044 struct LevelInfo level_backup = level;
2046 // overwrite all individual level settings from template level settings
2047 level = level_template;
2049 // restore level file info
2050 level.file_info = level_backup.file_info;
2052 // restore playfield size
2053 level.fieldx = level_backup.fieldx;
2054 level.fieldy = level_backup.fieldy;
2056 // restore playfield content
2057 for (x = 0; x < level.fieldx; x++)
2058 for (y = 0; y < level.fieldy; y++)
2059 level.field[x][y] = level_backup.field[x][y];
2061 // restore name and author from individual level
2062 strcpy(level.name, level_backup.name);
2063 strcpy(level.author, level_backup.author);
2065 // restore flag "use_custom_template"
2066 level.use_custom_template = level_backup.use_custom_template;
2070 static char *getLevelFilenameFromBasename(char *basename)
2072 static char *filename = NULL;
2074 checked_free(filename);
2076 filename = getPath2(getCurrentLevelDir(), basename);
2081 static int getFileTypeFromBasename(char *basename)
2083 // !!! ALSO SEE COMMENT IN checkForPackageFromBasename() !!!
2085 static char *filename = NULL;
2086 struct stat file_status;
2088 // ---------- try to determine file type from filename ----------
2090 // check for typical filename of a Supaplex level package file
2091 if (strlen(basename) == 10 && strPrefixLower(basename, "levels.d"))
2092 return LEVEL_FILE_TYPE_SP;
2094 // check for typical filename of a Diamond Caves II level package file
2095 if (strSuffixLower(basename, ".dc") ||
2096 strSuffixLower(basename, ".dc2"))
2097 return LEVEL_FILE_TYPE_DC;
2099 // check for typical filename of a Sokoban level package file
2100 if (strSuffixLower(basename, ".xsb") &&
2101 strchr(basename, '%') == NULL)
2102 return LEVEL_FILE_TYPE_SB;
2104 // check for typical filename of a Boulder Dash (GDash) level package file
2105 if (strSuffixLower(basename, ".bd") ||
2106 strSuffixLower(basename, ".bdr") ||
2107 strSuffixLower(basename, ".brc") ||
2108 strSuffixLower(basename, ".gds"))
2109 return LEVEL_FILE_TYPE_BD;
2111 // ---------- try to determine file type from filesize ----------
2113 checked_free(filename);
2114 filename = getPath2(getCurrentLevelDir(), basename);
2116 if (stat(filename, &file_status) == 0)
2118 // check for typical filesize of a Supaplex level package file
2119 if (file_status.st_size == 170496)
2120 return LEVEL_FILE_TYPE_SP;
2123 return LEVEL_FILE_TYPE_UNKNOWN;
2126 static int getFileTypeFromMagicBytes(char *filename, int type)
2130 if ((file = openFile(filename, MODE_READ)))
2132 char chunk_name[CHUNK_ID_LEN + 1];
2134 getFileChunkBE(file, chunk_name, NULL);
2136 if (strEqual(chunk_name, "MMII") ||
2137 strEqual(chunk_name, "MIRR"))
2138 type = LEVEL_FILE_TYPE_MM;
2146 static boolean checkForPackageFromBasename(char *basename)
2148 // !!! WON'T WORK ANYMORE IF getFileTypeFromBasename() ALSO DETECTS !!!
2149 // !!! SINGLE LEVELS (CURRENTLY ONLY DETECTS LEVEL PACKAGES !!!
2151 return (getFileTypeFromBasename(basename) != LEVEL_FILE_TYPE_UNKNOWN);
2154 static char *getSingleLevelBasenameExt(int nr, char *extension)
2156 static char basename[MAX_FILENAME_LEN];
2159 sprintf(basename, "%s", LEVELTEMPLATE_FILENAME);
2161 sprintf(basename, "%03d.%s", nr, extension);
2166 static char *getSingleLevelBasename(int nr)
2168 return getSingleLevelBasenameExt(nr, LEVELFILE_EXTENSION);
2171 static char *getPackedLevelBasename(int type)
2173 static char basename[MAX_FILENAME_LEN];
2174 char *directory = getCurrentLevelDir();
2176 DirectoryEntry *dir_entry;
2178 strcpy(basename, UNDEFINED_FILENAME); // default: undefined file
2180 if ((dir = openDirectory(directory)) == NULL)
2182 Warn("cannot read current level directory '%s'", directory);
2187 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
2189 char *entry_basename = dir_entry->basename;
2190 int entry_type = getFileTypeFromBasename(entry_basename);
2192 if (entry_type != LEVEL_FILE_TYPE_UNKNOWN) // found valid level package
2194 if (type == LEVEL_FILE_TYPE_UNKNOWN ||
2197 strcpy(basename, entry_basename);
2204 closeDirectory(dir);
2209 static char *getSingleLevelFilename(int nr)
2211 return getLevelFilenameFromBasename(getSingleLevelBasename(nr));
2214 #if ENABLE_UNUSED_CODE
2215 static char *getPackedLevelFilename(int type)
2217 return getLevelFilenameFromBasename(getPackedLevelBasename(type));
2221 char *getDefaultLevelFilename(int nr)
2223 return getSingleLevelFilename(nr);
2226 #if ENABLE_UNUSED_CODE
2227 static void setLevelFileInfo_SingleLevelFilename(struct LevelFileInfo *lfi,
2231 lfi->packed = FALSE;
2233 setString(&lfi->basename, getSingleLevelBasename(lfi->nr, lfi->type));
2234 setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
2238 static void setLevelFileInfo_FormatLevelFilename(struct LevelFileInfo *lfi,
2239 int type, char *format, ...)
2241 static char basename[MAX_FILENAME_LEN];
2244 va_start(ap, format);
2245 vsprintf(basename, format, ap);
2249 lfi->packed = FALSE;
2251 setString(&lfi->basename, basename);
2252 setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
2255 static void setLevelFileInfo_PackedLevelFilename(struct LevelFileInfo *lfi,
2261 setString(&lfi->basename, getPackedLevelBasename(lfi->type));
2262 setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
2265 static int getFiletypeFromID(char *filetype_id)
2267 char *filetype_id_lower;
2268 int filetype = LEVEL_FILE_TYPE_UNKNOWN;
2271 if (filetype_id == NULL)
2272 return LEVEL_FILE_TYPE_UNKNOWN;
2274 filetype_id_lower = getStringToLower(filetype_id);
2276 for (i = 0; filetype_id_list[i].id != NULL; i++)
2278 char *id_lower = getStringToLower(filetype_id_list[i].id);
2280 if (strEqual(filetype_id_lower, id_lower))
2281 filetype = filetype_id_list[i].filetype;
2285 if (filetype != LEVEL_FILE_TYPE_UNKNOWN)
2289 free(filetype_id_lower);
2294 char *getLocalLevelTemplateFilename(void)
2296 return getDefaultLevelFilename(-1);
2299 char *getGlobalLevelTemplateFilename(void)
2301 // global variable "leveldir_current" must be modified in the loop below
2302 LevelDirTree *leveldir_current_last = leveldir_current;
2303 char *filename = NULL;
2305 // check for template level in path from current to topmost tree node
2307 while (leveldir_current != NULL)
2309 filename = getDefaultLevelFilename(-1);
2311 if (fileExists(filename))
2314 leveldir_current = leveldir_current->node_parent;
2317 // restore global variable "leveldir_current" modified in above loop
2318 leveldir_current = leveldir_current_last;
2323 static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
2327 // special case: level number is negative => check for level template file
2330 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2331 getSingleLevelBasename(-1));
2333 // replace local level template filename with global template filename
2334 setString(&lfi->filename, getGlobalLevelTemplateFilename());
2336 // no fallback if template file not existing
2340 // special case: check for file name/pattern specified in "levelinfo.conf"
2341 if (leveldir_current->level_filename != NULL)
2343 int filetype = getFiletypeFromID(leveldir_current->level_filetype);
2345 setLevelFileInfo_FormatLevelFilename(lfi, filetype,
2346 leveldir_current->level_filename, nr);
2348 lfi->packed = checkForPackageFromBasename(leveldir_current->level_filename);
2350 if (fileExists(lfi->filename))
2353 else if (leveldir_current->level_filetype != NULL)
2355 int filetype = getFiletypeFromID(leveldir_current->level_filetype);
2357 // check for specified native level file with standard file name
2358 setLevelFileInfo_FormatLevelFilename(lfi, filetype,
2359 "%03d.%s", nr, LEVELFILE_EXTENSION);
2360 if (fileExists(lfi->filename))
2364 // check for native Rocks'n'Diamonds level file
2365 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2366 "%03d.%s", nr, LEVELFILE_EXTENSION);
2367 if (fileExists(lfi->filename))
2370 // check for Emerald Mine level file (V1)
2371 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "a%c%c",
2372 'a' + (nr / 10) % 26, '0' + nr % 10);
2373 if (fileExists(lfi->filename))
2375 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "A%c%c",
2376 'A' + (nr / 10) % 26, '0' + nr % 10);
2377 if (fileExists(lfi->filename))
2380 // check for Emerald Mine level file (V2 to V5)
2381 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%d", nr);
2382 if (fileExists(lfi->filename))
2385 // check for Emerald Mine level file (V6 / single mode)
2386 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02ds", nr);
2387 if (fileExists(lfi->filename))
2389 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dS", nr);
2390 if (fileExists(lfi->filename))
2393 // check for Emerald Mine level file (V6 / teamwork mode)
2394 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dt", nr);
2395 if (fileExists(lfi->filename))
2397 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dT", nr);
2398 if (fileExists(lfi->filename))
2401 // check for various packed level file formats
2402 setLevelFileInfo_PackedLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
2403 if (fileExists(lfi->filename))
2406 // no known level file found -- use default values (and fail later)
2407 setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2408 "%03d.%s", nr, LEVELFILE_EXTENSION);
2411 static void determineLevelFileInfo_Filetype(struct LevelFileInfo *lfi)
2413 if (lfi->type == LEVEL_FILE_TYPE_UNKNOWN)
2414 lfi->type = getFileTypeFromBasename(lfi->basename);
2416 if (lfi->type == LEVEL_FILE_TYPE_RND)
2417 lfi->type = getFileTypeFromMagicBytes(lfi->filename, lfi->type);
2420 static void setLevelFileInfo(struct LevelFileInfo *level_file_info, int nr)
2422 // always start with reliable default values
2423 setFileInfoToDefaults(level_file_info);
2425 level_file_info->nr = nr; // set requested level number
2427 determineLevelFileInfo_Filename(level_file_info);
2428 determineLevelFileInfo_Filetype(level_file_info);
2431 static void copyLevelFileInfo(struct LevelFileInfo *lfi_from,
2432 struct LevelFileInfo *lfi_to)
2434 lfi_to->nr = lfi_from->nr;
2435 lfi_to->type = lfi_from->type;
2436 lfi_to->packed = lfi_from->packed;
2438 setString(&lfi_to->basename, lfi_from->basename);
2439 setString(&lfi_to->filename, lfi_from->filename);
2442 // ----------------------------------------------------------------------------
2443 // functions for loading R'n'D level
2444 // ----------------------------------------------------------------------------
2446 int getMappedElement(int element)
2448 // remap some (historic, now obsolete) elements
2452 case EL_PLAYER_OBSOLETE:
2453 element = EL_PLAYER_1;
2456 case EL_KEY_OBSOLETE:
2460 case EL_EM_KEY_1_FILE_OBSOLETE:
2461 element = EL_EM_KEY_1;
2464 case EL_EM_KEY_2_FILE_OBSOLETE:
2465 element = EL_EM_KEY_2;
2468 case EL_EM_KEY_3_FILE_OBSOLETE:
2469 element = EL_EM_KEY_3;
2472 case EL_EM_KEY_4_FILE_OBSOLETE:
2473 element = EL_EM_KEY_4;
2476 case EL_ENVELOPE_OBSOLETE:
2477 element = EL_ENVELOPE_1;
2485 if (element >= NUM_FILE_ELEMENTS)
2487 Warn("invalid level element %d", element);
2489 element = EL_UNKNOWN;
2497 static int getMappedElementByVersion(int element, int game_version)
2499 // remap some elements due to certain game version
2501 if (game_version <= VERSION_IDENT(2,2,0,0))
2503 // map game font elements
2504 element = (element == EL_CHAR('[') ? EL_CHAR_AUMLAUT :
2505 element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
2506 element == EL_CHAR(']') ? EL_CHAR_UUMLAUT :
2507 element == EL_CHAR('^') ? EL_CHAR_COPYRIGHT : element);
2510 if (game_version < VERSION_IDENT(3,0,0,0))
2512 // map Supaplex gravity tube elements
2513 element = (element == EL_SP_GRAVITY_PORT_LEFT ? EL_SP_PORT_LEFT :
2514 element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
2515 element == EL_SP_GRAVITY_PORT_UP ? EL_SP_PORT_UP :
2516 element == EL_SP_GRAVITY_PORT_DOWN ? EL_SP_PORT_DOWN :
2523 static int LoadLevel_VERS(File *file, int chunk_size, struct LevelInfo *level)
2525 level->file_version = getFileVersion(file);
2526 level->game_version = getFileVersion(file);
2531 static int LoadLevel_DATE(File *file, int chunk_size, struct LevelInfo *level)
2533 level->creation_date.year = getFile16BitBE(file);
2534 level->creation_date.month = getFile8Bit(file);
2535 level->creation_date.day = getFile8Bit(file);
2537 level->creation_date.src = DATE_SRC_LEVELFILE;
2542 static int LoadLevel_HEAD(File *file, int chunk_size, struct LevelInfo *level)
2544 int initial_player_stepsize;
2545 int initial_player_gravity;
2548 level->fieldx = getFile8Bit(file);
2549 level->fieldy = getFile8Bit(file);
2551 level->time = getFile16BitBE(file);
2552 level->gems_needed = getFile16BitBE(file);
2554 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
2555 level->name[i] = getFile8Bit(file);
2556 level->name[MAX_LEVEL_NAME_LEN] = 0;
2558 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
2559 level->score[i] = getFile8Bit(file);
2561 level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
2562 for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
2563 for (y = 0; y < 3; y++)
2564 for (x = 0; x < 3; x++)
2565 level->yamyam_content[i].e[x][y] = getMappedElement(getFile8Bit(file));
2567 level->amoeba_speed = getFile8Bit(file);
2568 level->time_magic_wall = getFile8Bit(file);
2569 level->time_wheel = getFile8Bit(file);
2570 level->amoeba_content = getMappedElement(getFile8Bit(file));
2572 initial_player_stepsize = (getFile8Bit(file) == 1 ? STEPSIZE_FAST :
2575 for (i = 0; i < MAX_PLAYERS; i++)
2576 level->initial_player_stepsize[i] = initial_player_stepsize;
2578 initial_player_gravity = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2580 for (i = 0; i < MAX_PLAYERS; i++)
2581 level->initial_player_gravity[i] = initial_player_gravity;
2583 level->encoding_16bit_field = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2584 level->em_slippery_gems = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2586 level->use_custom_template = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2588 level->block_last_field = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2589 level->sp_block_last_field = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2590 level->can_move_into_acid_bits = getFile32BitBE(file);
2591 level->dont_collide_with_bits = getFile8Bit(file);
2593 level->use_spring_bug = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2594 level->use_step_counter = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2596 level->instant_relocation = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2597 level->can_pass_to_walkable = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2598 level->grow_into_diggable = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2600 level->game_engine_type = getFile8Bit(file);
2602 ReadUnusedBytesFromFile(file, LEVEL_CHUNK_HEAD_UNUSED);
2607 static int LoadLevel_NAME(File *file, int chunk_size, struct LevelInfo *level)
2611 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
2612 level->name[i] = getFile8Bit(file);
2613 level->name[MAX_LEVEL_NAME_LEN] = 0;
2618 static int LoadLevel_AUTH(File *file, int chunk_size, struct LevelInfo *level)
2622 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
2623 level->author[i] = getFile8Bit(file);
2624 level->author[MAX_LEVEL_AUTHOR_LEN] = 0;
2629 static int LoadLevel_BODY(File *file, int chunk_size, struct LevelInfo *level)
2632 int chunk_size_expected = level->fieldx * level->fieldy;
2634 /* Note: "chunk_size" was wrong before version 2.0 when elements are
2635 stored with 16-bit encoding (and should be twice as big then).
2636 Even worse, playfield data was stored 16-bit when only yamyam content
2637 contained 16-bit elements and vice versa. */
2639 if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
2640 chunk_size_expected *= 2;
2642 if (chunk_size_expected != chunk_size)
2644 ReadUnusedBytesFromFile(file, chunk_size);
2645 return chunk_size_expected;
2648 for (y = 0; y < level->fieldy; y++)
2649 for (x = 0; x < level->fieldx; x++)
2650 level->field[x][y] =
2651 getMappedElement(level->encoding_16bit_field ? getFile16BitBE(file) :
2656 static int LoadLevel_CONT(File *file, int chunk_size, struct LevelInfo *level)
2659 int header_size = 4;
2660 int content_size = MAX_ELEMENT_CONTENTS * 3 * 3;
2661 int chunk_size_expected = header_size + content_size;
2663 /* Note: "chunk_size" was wrong before version 2.0 when elements are
2664 stored with 16-bit encoding (and should be twice as big then).
2665 Even worse, playfield data was stored 16-bit when only yamyam content
2666 contained 16-bit elements and vice versa. */
2668 if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
2669 chunk_size_expected += content_size;
2671 if (chunk_size_expected != chunk_size)
2673 ReadUnusedBytesFromFile(file, chunk_size);
2674 return chunk_size_expected;
2678 level->num_yamyam_contents = getFile8Bit(file);
2682 // correct invalid number of content fields -- should never happen
2683 if (level->num_yamyam_contents < 1 ||
2684 level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
2685 level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
2687 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2688 for (y = 0; y < 3; y++)
2689 for (x = 0; x < 3; x++)
2690 level->yamyam_content[i].e[x][y] =
2691 getMappedElement(level->encoding_16bit_field ?
2692 getFile16BitBE(file) : getFile8Bit(file));
2696 static int LoadLevel_CNT2(File *file, int chunk_size, struct LevelInfo *level)
2701 int content_array[MAX_ELEMENT_CONTENTS][3][3];
2703 element = getMappedElement(getFile16BitBE(file));
2704 num_contents = getFile8Bit(file);
2706 getFile8Bit(file); // content x size (unused)
2707 getFile8Bit(file); // content y size (unused)
2709 ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
2711 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2712 for (y = 0; y < 3; y++)
2713 for (x = 0; x < 3; x++)
2714 content_array[i][x][y] = getMappedElement(getFile16BitBE(file));
2716 // correct invalid number of content fields -- should never happen
2717 if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
2718 num_contents = STD_ELEMENT_CONTENTS;
2720 if (element == EL_YAMYAM)
2722 level->num_yamyam_contents = num_contents;
2724 for (i = 0; i < num_contents; i++)
2725 for (y = 0; y < 3; y++)
2726 for (x = 0; x < 3; x++)
2727 level->yamyam_content[i].e[x][y] = content_array[i][x][y];
2729 else if (element == EL_BD_AMOEBA)
2731 level->amoeba_content = content_array[0][0][0];
2735 Warn("cannot load content for element '%d'", element);
2741 static int LoadLevel_CNT3(File *file, int chunk_size, struct LevelInfo *level)
2747 int chunk_size_expected;
2749 element = getMappedElement(getFile16BitBE(file));
2750 if (!IS_ENVELOPE(element))
2751 element = EL_ENVELOPE_1;
2753 envelope_nr = element - EL_ENVELOPE_1;
2755 envelope_len = getFile16BitBE(file);
2757 level->envelope[envelope_nr].xsize = getFile8Bit(file);
2758 level->envelope[envelope_nr].ysize = getFile8Bit(file);
2760 ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT3_UNUSED);
2762 chunk_size_expected = LEVEL_CHUNK_CNT3_SIZE(envelope_len);
2763 if (chunk_size_expected != chunk_size)
2765 ReadUnusedBytesFromFile(file, chunk_size - LEVEL_CHUNK_CNT3_HEADER);
2766 return chunk_size_expected;
2769 for (i = 0; i < envelope_len; i++)
2770 level->envelope[envelope_nr].text[i] = getFile8Bit(file);
2775 static int LoadLevel_CUS1(File *file, int chunk_size, struct LevelInfo *level)
2777 int num_changed_custom_elements = getFile16BitBE(file);
2778 int chunk_size_expected = 2 + num_changed_custom_elements * 6;
2781 if (chunk_size_expected != chunk_size)
2783 ReadUnusedBytesFromFile(file, chunk_size - 2);
2784 return chunk_size_expected;
2787 for (i = 0; i < num_changed_custom_elements; i++)
2789 int element = getMappedElement(getFile16BitBE(file));
2790 int properties = getFile32BitBE(file);
2792 if (IS_CUSTOM_ELEMENT(element))
2793 element_info[element].properties[EP_BITFIELD_BASE_NR] = properties;
2795 Warn("invalid custom element number %d", element);
2797 // older game versions that wrote level files with CUS1 chunks used
2798 // different default push delay values (not yet stored in level file)
2799 element_info[element].push_delay_fixed = 2;
2800 element_info[element].push_delay_random = 8;
2803 level->file_has_custom_elements = TRUE;
2808 static int LoadLevel_CUS2(File *file, int chunk_size, struct LevelInfo *level)
2810 int num_changed_custom_elements = getFile16BitBE(file);
2811 int chunk_size_expected = 2 + num_changed_custom_elements * 4;
2814 if (chunk_size_expected != chunk_size)
2816 ReadUnusedBytesFromFile(file, chunk_size - 2);
2817 return chunk_size_expected;
2820 for (i = 0; i < num_changed_custom_elements; i++)
2822 int element = getMappedElement(getFile16BitBE(file));
2823 int custom_target_element = getMappedElement(getFile16BitBE(file));
2825 if (IS_CUSTOM_ELEMENT(element))
2826 element_info[element].change->target_element = custom_target_element;
2828 Warn("invalid custom element number %d", element);
2831 level->file_has_custom_elements = TRUE;
2836 static int LoadLevel_CUS3(File *file, int chunk_size, struct LevelInfo *level)
2838 int num_changed_custom_elements = getFile16BitBE(file);
2839 int chunk_size_expected = LEVEL_CHUNK_CUS3_SIZE(num_changed_custom_elements);
2842 if (chunk_size_expected != chunk_size)
2844 ReadUnusedBytesFromFile(file, chunk_size - 2);
2845 return chunk_size_expected;
2848 for (i = 0; i < num_changed_custom_elements; i++)
2850 int element = getMappedElement(getFile16BitBE(file));
2851 struct ElementInfo *ei = &element_info[element];
2852 unsigned int event_bits;
2854 if (!IS_CUSTOM_ELEMENT(element))
2856 Warn("invalid custom element number %d", element);
2858 element = EL_INTERNAL_DUMMY;
2861 for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
2862 ei->description[j] = getFile8Bit(file);
2863 ei->description[MAX_ELEMENT_NAME_LEN] = 0;
2865 ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
2867 // some free bytes for future properties and padding
2868 ReadUnusedBytesFromFile(file, 7);
2870 ei->use_gfx_element = getFile8Bit(file);
2871 ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
2873 ei->collect_score_initial = getFile8Bit(file);
2874 ei->collect_count_initial = getFile8Bit(file);
2876 ei->push_delay_fixed = getFile16BitBE(file);
2877 ei->push_delay_random = getFile16BitBE(file);
2878 ei->move_delay_fixed = getFile16BitBE(file);
2879 ei->move_delay_random = getFile16BitBE(file);
2881 ei->move_pattern = getFile16BitBE(file);
2882 ei->move_direction_initial = getFile8Bit(file);
2883 ei->move_stepsize = getFile8Bit(file);
2885 for (y = 0; y < 3; y++)
2886 for (x = 0; x < 3; x++)
2887 ei->content.e[x][y] = getMappedElement(getFile16BitBE(file));
2889 // bits 0 - 31 of "has_event[]"
2890 event_bits = getFile32BitBE(file);
2891 for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
2892 if (event_bits & (1u << j))
2893 ei->change->has_event[j] = TRUE;
2895 ei->change->target_element = getMappedElement(getFile16BitBE(file));
2897 ei->change->delay_fixed = getFile16BitBE(file);
2898 ei->change->delay_random = getFile16BitBE(file);
2899 ei->change->delay_frames = getFile16BitBE(file);
2901 ei->change->initial_trigger_element = getMappedElement(getFile16BitBE(file));
2903 ei->change->explode = getFile8Bit(file);
2904 ei->change->use_target_content = getFile8Bit(file);
2905 ei->change->only_if_complete = getFile8Bit(file);
2906 ei->change->use_random_replace = getFile8Bit(file);
2908 ei->change->random_percentage = getFile8Bit(file);
2909 ei->change->replace_when = getFile8Bit(file);
2911 for (y = 0; y < 3; y++)
2912 for (x = 0; x < 3; x++)
2913 ei->change->target_content.e[x][y] =
2914 getMappedElement(getFile16BitBE(file));
2916 ei->slippery_type = getFile8Bit(file);
2918 // some free bytes for future properties and padding
2919 ReadUnusedBytesFromFile(file, LEVEL_CPART_CUS3_UNUSED);
2921 // mark that this custom element has been modified
2922 ei->modified_settings = TRUE;
2925 level->file_has_custom_elements = TRUE;
2930 static int LoadLevel_CUS4(File *file, int chunk_size, struct LevelInfo *level)
2932 struct ElementInfo *ei;
2933 int chunk_size_expected;
2937 // ---------- custom element base property values (96 bytes) ----------------
2939 element = getMappedElement(getFile16BitBE(file));
2941 if (!IS_CUSTOM_ELEMENT(element))
2943 Warn("invalid custom element number %d", element);
2945 ReadUnusedBytesFromFile(file, chunk_size - 2);
2950 ei = &element_info[element];
2952 for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
2953 ei->description[i] = getFile8Bit(file);
2954 ei->description[MAX_ELEMENT_NAME_LEN] = 0;
2956 ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
2958 ReadUnusedBytesFromFile(file, 4); // reserved for more base properties
2960 ei->num_change_pages = getFile8Bit(file);
2962 chunk_size_expected = LEVEL_CHUNK_CUS4_SIZE(ei->num_change_pages);
2963 if (chunk_size_expected != chunk_size)
2965 ReadUnusedBytesFromFile(file, chunk_size - 43);
2966 return chunk_size_expected;
2969 ei->ce_value_fixed_initial = getFile16BitBE(file);
2970 ei->ce_value_random_initial = getFile16BitBE(file);
2971 ei->use_last_ce_value = getFile8Bit(file);
2973 ei->use_gfx_element = getFile8Bit(file);
2974 ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
2976 ei->collect_score_initial = getFile8Bit(file);
2977 ei->collect_count_initial = getFile8Bit(file);
2979 ei->drop_delay_fixed = getFile8Bit(file);
2980 ei->push_delay_fixed = getFile8Bit(file);
2981 ei->drop_delay_random = getFile8Bit(file);
2982 ei->push_delay_random = getFile8Bit(file);
2983 ei->move_delay_fixed = getFile16BitBE(file);
2984 ei->move_delay_random = getFile16BitBE(file);
2986 // bits 0 - 15 of "move_pattern" ...
2987 ei->move_pattern = getFile16BitBE(file);
2988 ei->move_direction_initial = getFile8Bit(file);
2989 ei->move_stepsize = getFile8Bit(file);
2991 ei->slippery_type = getFile8Bit(file);
2993 for (y = 0; y < 3; y++)
2994 for (x = 0; x < 3; x++)
2995 ei->content.e[x][y] = getMappedElement(getFile16BitBE(file));
2997 ei->move_enter_element = getMappedElement(getFile16BitBE(file));
2998 ei->move_leave_element = getMappedElement(getFile16BitBE(file));
2999 ei->move_leave_type = getFile8Bit(file);
3001 // ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible)
3002 ei->move_pattern |= (getFile16BitBE(file) << 16);
3004 ei->access_direction = getFile8Bit(file);
3006 ei->explosion_delay = getFile8Bit(file);
3007 ei->ignition_delay = getFile8Bit(file);
3008 ei->explosion_type = getFile8Bit(file);
3010 // some free bytes for future custom property values and padding
3011 ReadUnusedBytesFromFile(file, 1);
3013 // ---------- change page property values (48 bytes) ------------------------
3015 setElementChangePages(ei, ei->num_change_pages);
3017 for (i = 0; i < ei->num_change_pages; i++)
3019 struct ElementChangeInfo *change = &ei->change_page[i];
3020 unsigned int event_bits;
3022 // always start with reliable default values
3023 setElementChangeInfoToDefaults(change);
3025 // bits 0 - 31 of "has_event[]" ...
3026 event_bits = getFile32BitBE(file);
3027 for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
3028 if (event_bits & (1u << j))
3029 change->has_event[j] = TRUE;
3031 change->target_element = getMappedElement(getFile16BitBE(file));
3033 change->delay_fixed = getFile16BitBE(file);
3034 change->delay_random = getFile16BitBE(file);
3035 change->delay_frames = getFile16BitBE(file);
3037 change->initial_trigger_element = getMappedElement(getFile16BitBE(file));
3039 change->explode = getFile8Bit(file);
3040 change->use_target_content = getFile8Bit(file);
3041 change->only_if_complete = getFile8Bit(file);
3042 change->use_random_replace = getFile8Bit(file);
3044 change->random_percentage = getFile8Bit(file);
3045 change->replace_when = getFile8Bit(file);
3047 for (y = 0; y < 3; y++)
3048 for (x = 0; x < 3; x++)
3049 change->target_content.e[x][y]= getMappedElement(getFile16BitBE(file));
3051 change->can_change = getFile8Bit(file);
3053 change->trigger_side = getFile8Bit(file);
3055 change->trigger_player = getFile8Bit(file);
3056 change->trigger_page = getFile8Bit(file);
3058 change->trigger_page = (change->trigger_page == CH_PAGE_ANY_FILE ?
3059 CH_PAGE_ANY : (1 << change->trigger_page));
3061 change->has_action = getFile8Bit(file);
3062 change->action_type = getFile8Bit(file);
3063 change->action_mode = getFile8Bit(file);
3064 change->action_arg = getFile16BitBE(file);
3066 // ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible)
3067 event_bits = getFile8Bit(file);
3068 for (j = 32; j < NUM_CHANGE_EVENTS; j++)
3069 if (event_bits & (1u << (j - 32)))
3070 change->has_event[j] = TRUE;
3073 // mark this custom element as modified
3074 ei->modified_settings = TRUE;
3076 level->file_has_custom_elements = TRUE;
3081 static int LoadLevel_GRP1(File *file, int chunk_size, struct LevelInfo *level)
3083 struct ElementInfo *ei;
3084 struct ElementGroupInfo *group;
3088 element = getMappedElement(getFile16BitBE(file));
3090 if (!IS_GROUP_ELEMENT(element))
3092 Warn("invalid group element number %d", element);
3094 ReadUnusedBytesFromFile(file, chunk_size - 2);
3099 ei = &element_info[element];
3101 for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
3102 ei->description[i] = getFile8Bit(file);
3103 ei->description[MAX_ELEMENT_NAME_LEN] = 0;
3105 group = element_info[element].group;
3107 group->num_elements = getFile8Bit(file);
3109 ei->use_gfx_element = getFile8Bit(file);
3110 ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
3112 group->choice_mode = getFile8Bit(file);
3114 // some free bytes for future values and padding
3115 ReadUnusedBytesFromFile(file, 3);
3117 for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
3118 group->element[i] = getMappedElement(getFile16BitBE(file));
3120 // mark this group element as modified
3121 element_info[element].modified_settings = TRUE;
3123 level->file_has_custom_elements = TRUE;
3128 static int LoadLevel_MicroChunk(File *file, struct LevelFileConfigInfo *conf,
3129 int element, int real_element)
3131 int micro_chunk_size = 0;
3132 int conf_type = getFile8Bit(file);
3133 int byte_mask = conf_type & CONF_MASK_BYTES;
3134 boolean element_found = FALSE;
3137 micro_chunk_size += 1;
3139 if (byte_mask == CONF_MASK_MULTI_BYTES)
3141 int num_bytes = getFile16BitBE(file);
3142 byte *buffer = checked_malloc(num_bytes);
3144 ReadBytesFromFile(file, buffer, num_bytes);
3146 for (i = 0; conf[i].data_type != -1; i++)
3148 if (conf[i].element == element &&
3149 conf[i].conf_type == conf_type)
3151 int data_type = conf[i].data_type;
3152 int num_entities = num_bytes / CONF_ENTITY_NUM_BYTES(data_type);
3153 int max_num_entities = conf[i].max_num_entities;
3155 if (num_entities > max_num_entities)
3157 Warn("truncating number of entities for element %d from %d to %d",
3158 element, num_entities, max_num_entities);
3160 num_entities = max_num_entities;
3163 if (num_entities == 0 && (data_type == TYPE_ELEMENT_LIST ||
3164 data_type == TYPE_CONTENT_LIST))
3166 // for element and content lists, zero entities are not allowed
3167 Warn("found empty list of entities for element %d", element);
3169 // do not set "num_entities" here to prevent reading behind buffer
3171 *(int *)(conf[i].num_entities) = 1; // at least one is required
3175 *(int *)(conf[i].num_entities) = num_entities;
3178 element_found = TRUE;
3180 if (data_type == TYPE_STRING)
3182 char *string = (char *)(conf[i].value);
3185 for (j = 0; j < max_num_entities; j++)
3186 string[j] = (j < num_entities ? buffer[j] : '\0');
3188 else if (data_type == TYPE_ELEMENT_LIST)
3190 int *element_array = (int *)(conf[i].value);
3193 for (j = 0; j < num_entities; j++)
3195 getMappedElement(CONF_ELEMENTS_ELEMENT(buffer, j));
3197 else if (data_type == TYPE_CONTENT_LIST)
3199 struct Content *content= (struct Content *)(conf[i].value);
3202 for (c = 0; c < num_entities; c++)
3203 for (y = 0; y < 3; y++)
3204 for (x = 0; x < 3; x++)
3205 content[c].e[x][y] =
3206 getMappedElement(CONF_CONTENTS_ELEMENT(buffer, c, x, y));
3209 element_found = FALSE;
3215 checked_free(buffer);
3217 micro_chunk_size += 2 + num_bytes;
3219 else // constant size configuration data (1, 2 or 4 bytes)
3221 int value = (byte_mask == CONF_MASK_1_BYTE ? getFile8Bit (file) :
3222 byte_mask == CONF_MASK_2_BYTE ? getFile16BitBE(file) :
3223 byte_mask == CONF_MASK_4_BYTE ? getFile32BitBE(file) : 0);
3225 for (i = 0; conf[i].data_type != -1; i++)
3227 if (conf[i].element == element &&
3228 conf[i].conf_type == conf_type)
3230 int data_type = conf[i].data_type;
3232 if (data_type == TYPE_ELEMENT)
3233 value = getMappedElement(value);
3235 if (data_type == TYPE_BOOLEAN)
3236 *(boolean *)(conf[i].value) = (value ? TRUE : FALSE);
3238 *(int *) (conf[i].value) = value;
3240 element_found = TRUE;
3246 micro_chunk_size += CONF_VALUE_NUM_BYTES(byte_mask);
3251 char *error_conf_chunk_bytes =
3252 (byte_mask == CONF_MASK_1_BYTE ? "CONF_VALUE_8_BIT" :
3253 byte_mask == CONF_MASK_2_BYTE ? "CONF_VALUE_16_BIT" :
3254 byte_mask == CONF_MASK_4_BYTE ? "CONF_VALUE_32_BIT" :"CONF_VALUE_BYTES");
3255 int error_conf_chunk_token = conf_type & CONF_MASK_TOKEN;
3256 int error_element = real_element;
3258 Warn("cannot load micro chunk '%s(%d)' value for element %d ['%s']",
3259 error_conf_chunk_bytes, error_conf_chunk_token,
3260 error_element, EL_NAME(error_element));
3263 return micro_chunk_size;
3266 static int LoadLevel_INFO(File *file, int chunk_size, struct LevelInfo *level)
3268 int real_chunk_size = 0;
3270 li = *level; // copy level data into temporary buffer
3272 while (!checkEndOfFile(file))
3274 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_INFO, -1, -1);
3276 if (real_chunk_size >= chunk_size)
3280 *level = li; // copy temporary buffer back to level data
3282 return real_chunk_size;
3285 static int LoadLevel_CONF(File *file, int chunk_size, struct LevelInfo *level)
3287 int real_chunk_size = 0;
3289 li = *level; // copy level data into temporary buffer
3291 while (!checkEndOfFile(file))
3293 int element = getMappedElement(getFile16BitBE(file));
3295 real_chunk_size += 2;
3296 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CONF,
3298 if (real_chunk_size >= chunk_size)
3302 *level = li; // copy temporary buffer back to level data
3304 return real_chunk_size;
3307 static int LoadLevel_ELEM(File *file, int chunk_size, struct LevelInfo *level)
3309 int real_chunk_size = 0;
3311 li = *level; // copy level data into temporary buffer
3313 while (!checkEndOfFile(file))
3315 int element = getMappedElement(getFile16BitBE(file));
3317 real_chunk_size += 2;
3318 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_ELEM,
3320 if (real_chunk_size >= chunk_size)
3324 *level = li; // copy temporary buffer back to level data
3326 return real_chunk_size;
3329 static int LoadLevel_NOTE(File *file, int chunk_size, struct LevelInfo *level)
3331 int element = getMappedElement(getFile16BitBE(file));
3332 int envelope_nr = element - EL_ENVELOPE_1;
3333 int real_chunk_size = 2;
3335 xx_envelope = level->envelope[envelope_nr]; // copy into temporary buffer
3337 while (!checkEndOfFile(file))
3339 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_NOTE,
3342 if (real_chunk_size >= chunk_size)
3346 level->envelope[envelope_nr] = xx_envelope; // copy from temporary buffer
3348 return real_chunk_size;
3351 static int LoadLevel_CUSX(File *file, int chunk_size, struct LevelInfo *level)
3353 int element = getMappedElement(getFile16BitBE(file));
3354 int real_chunk_size = 2;
3355 struct ElementInfo *ei = &element_info[element];
3358 xx_ei = *ei; // copy element data into temporary buffer
3360 xx_ei.num_change_pages = -1;
3362 while (!checkEndOfFile(file))
3364 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CUSX_base,
3366 if (xx_ei.num_change_pages != -1)
3369 if (real_chunk_size >= chunk_size)
3375 if (ei->num_change_pages == -1)
3377 Warn("LoadLevel_CUSX(): missing 'num_change_pages' for '%s'",
3380 ei->num_change_pages = 1;
3382 setElementChangePages(ei, 1);
3383 setElementChangeInfoToDefaults(ei->change);
3385 return real_chunk_size;
3388 // initialize number of change pages stored for this custom element
3389 setElementChangePages(ei, ei->num_change_pages);
3390 for (i = 0; i < ei->num_change_pages; i++)
3391 setElementChangeInfoToDefaults(&ei->change_page[i]);
3393 // start with reading properties for the first change page
3394 xx_current_change_page = 0;
3396 while (!checkEndOfFile(file))
3398 // level file might contain invalid change page number
3399 if (xx_current_change_page >= ei->num_change_pages)
3402 struct ElementChangeInfo *change = &ei->change_page[xx_current_change_page];
3404 xx_change = *change; // copy change data into temporary buffer
3406 resetEventBits(); // reset bits; change page might have changed
3408 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CUSX_change,
3411 *change = xx_change;
3413 setEventFlagsFromEventBits(change);
3415 if (real_chunk_size >= chunk_size)
3419 level->file_has_custom_elements = TRUE;
3421 return real_chunk_size;
3424 static int LoadLevel_GRPX(File *file, int chunk_size, struct LevelInfo *level)
3426 int element = getMappedElement(getFile16BitBE(file));
3427 int real_chunk_size = 2;
3428 struct ElementInfo *ei = &element_info[element];
3429 struct ElementGroupInfo *group = ei->group;
3434 xx_ei = *ei; // copy element data into temporary buffer
3435 xx_group = *group; // copy group data into temporary buffer
3437 while (!checkEndOfFile(file))
3439 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_GRPX,
3442 if (real_chunk_size >= chunk_size)
3449 level->file_has_custom_elements = TRUE;
3451 return real_chunk_size;
3454 static int LoadLevel_EMPX(File *file, int chunk_size, struct LevelInfo *level)
3456 int element = getMappedElement(getFile16BitBE(file));
3457 int real_chunk_size = 2;
3458 struct ElementInfo *ei = &element_info[element];
3460 xx_ei = *ei; // copy element data into temporary buffer
3462 while (!checkEndOfFile(file))
3464 real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_EMPX,
3467 if (real_chunk_size >= chunk_size)
3473 level->file_has_custom_elements = TRUE;
3475 return real_chunk_size;
3478 static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
3479 struct LevelFileInfo *level_file_info,
3480 boolean level_info_only)
3482 char *filename = level_file_info->filename;
3483 char cookie[MAX_LINE_LEN];
3484 char chunk_name[CHUNK_ID_LEN + 1];
3488 if (!(file = openFile(filename, MODE_READ)))
3490 level->no_valid_file = TRUE;
3491 level->no_level_file = TRUE;
3493 if (level_info_only)
3496 Warn("cannot read level '%s' -- using empty level", filename);
3498 if (!setup.editor.use_template_for_new_levels)
3501 // if level file not found, try to initialize level data from template
3502 filename = getGlobalLevelTemplateFilename();
3504 if (!(file = openFile(filename, MODE_READ)))
3507 // default: for empty levels, use level template for custom elements
3508 level->use_custom_template = TRUE;
3510 level->no_valid_file = FALSE;
3513 getFileChunkBE(file, chunk_name, NULL);
3514 if (strEqual(chunk_name, "RND1"))
3516 getFile32BitBE(file); // not used
3518 getFileChunkBE(file, chunk_name, NULL);
3519 if (!strEqual(chunk_name, "CAVE"))
3521 level->no_valid_file = TRUE;
3523 Warn("unknown format of level file '%s'", filename);
3530 else // check for pre-2.0 file format with cookie string
3532 strcpy(cookie, chunk_name);
3533 if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
3535 if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
3536 cookie[strlen(cookie) - 1] = '\0';
3538 if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
3540 level->no_valid_file = TRUE;
3542 Warn("unknown format of level file '%s'", filename);
3549 if ((level->file_version = getFileVersionFromCookieString(cookie)) == -1)
3551 level->no_valid_file = TRUE;
3553 Warn("unsupported version of level file '%s'", filename);
3560 // pre-2.0 level files have no game version, so use file version here
3561 level->game_version = level->file_version;
3564 if (level->file_version < FILE_VERSION_1_2)
3566 // level files from versions before 1.2.0 without chunk structure
3567 LoadLevel_HEAD(file, LEVEL_CHUNK_HEAD_SIZE, level);
3568 LoadLevel_BODY(file, level->fieldx * level->fieldy, level);
3576 int (*loader)(File *, int, struct LevelInfo *);
3580 { "VERS", LEVEL_CHUNK_VERS_SIZE, LoadLevel_VERS },
3581 { "DATE", LEVEL_CHUNK_DATE_SIZE, LoadLevel_DATE },
3582 { "HEAD", LEVEL_CHUNK_HEAD_SIZE, LoadLevel_HEAD },
3583 { "NAME", LEVEL_CHUNK_NAME_SIZE, LoadLevel_NAME },
3584 { "AUTH", LEVEL_CHUNK_AUTH_SIZE, LoadLevel_AUTH },
3585 { "INFO", -1, LoadLevel_INFO },
3586 { "BODY", -1, LoadLevel_BODY },
3587 { "CONT", -1, LoadLevel_CONT },
3588 { "CNT2", LEVEL_CHUNK_CNT2_SIZE, LoadLevel_CNT2 },
3589 { "CNT3", -1, LoadLevel_CNT3 },
3590 { "CUS1", -1, LoadLevel_CUS1 },
3591 { "CUS2", -1, LoadLevel_CUS2 },
3592 { "CUS3", -1, LoadLevel_CUS3 },
3593 { "CUS4", -1, LoadLevel_CUS4 },
3594 { "GRP1", -1, LoadLevel_GRP1 },
3595 { "CONF", -1, LoadLevel_CONF },
3596 { "ELEM", -1, LoadLevel_ELEM },
3597 { "NOTE", -1, LoadLevel_NOTE },
3598 { "CUSX", -1, LoadLevel_CUSX },
3599 { "GRPX", -1, LoadLevel_GRPX },
3600 { "EMPX", -1, LoadLevel_EMPX },
3605 while (getFileChunkBE(file, chunk_name, &chunk_size))
3609 while (chunk_info[i].name != NULL &&
3610 !strEqual(chunk_name, chunk_info[i].name))
3613 if (chunk_info[i].name == NULL)
3615 Warn("unknown chunk '%s' in level file '%s'",
3616 chunk_name, filename);
3618 ReadUnusedBytesFromFile(file, chunk_size);
3620 else if (chunk_info[i].size != -1 &&
3621 chunk_info[i].size != chunk_size)
3623 Warn("wrong size (%d) of chunk '%s' in level file '%s'",
3624 chunk_size, chunk_name, filename);
3626 ReadUnusedBytesFromFile(file, chunk_size);
3630 // call function to load this level chunk
3631 int chunk_size_expected =
3632 (chunk_info[i].loader)(file, chunk_size, level);
3634 if (chunk_size_expected < 0)
3636 Warn("error reading chunk '%s' in level file '%s'",
3637 chunk_name, filename);
3642 // the size of some chunks cannot be checked before reading other
3643 // chunks first (like "HEAD" and "BODY") that contain some header
3644 // information, so check them here
3645 if (chunk_size_expected != chunk_size)
3647 Warn("wrong size (%d) of chunk '%s' in level file '%s'",
3648 chunk_size, chunk_name, filename);
3660 // ----------------------------------------------------------------------------
3661 // functions for loading BD level
3662 // ----------------------------------------------------------------------------
3664 static void CopyNativeLevel_RND_to_BD(struct LevelInfo *level)
3666 struct LevelInfo_BD *level_bd = level->native_bd_level;
3667 GdCave *cave = NULL; // will be changed below
3668 int cave_w = MIN(level->fieldx, MAX_PLAYFIELD_WIDTH);
3669 int cave_h = MIN(level->fieldy, MAX_PLAYFIELD_HEIGHT);
3672 setLevelInfoToDefaults_BD_Ext(cave_w, cave_h);
3674 // cave and map newly allocated when set to defaults above
3675 cave = level_bd->cave;
3677 for (i = 0; i < 5; i++)
3679 cave->level_time[i] = level->time;
3680 cave->level_diamonds[i] = level->gems_needed;
3681 cave->level_magic_wall_time[i] = level->time_magic_wall;
3682 cave->level_timevalue[i] = level->score[SC_TIME_BONUS];
3685 cave->diamond_value = level->score[SC_DIAMOND];
3686 cave->extra_diamond_value = level->score[SC_DIAMOND];
3688 cave->level_speed[0] = 160; // set cave speed
3690 strncpy(cave->name, level->name, sizeof(GdString));
3691 cave->name[sizeof(GdString) - 1] = '\0';
3693 for (x = 0; x < cave->w; x++)
3694 for (y = 0; y < cave->h; y++)
3695 cave->map[y][x] = map_element_RND_to_BD(level->field[x][y]);
3698 static void CopyNativeLevel_BD_to_RND(struct LevelInfo *level)
3700 struct LevelInfo_BD *level_bd = level->native_bd_level;
3701 GdCave *cave = level_bd->cave;
3702 int bd_level_nr = level_bd->level_nr;
3705 level->fieldx = MIN(cave->w, MAX_LEV_FIELDX);
3706 level->fieldy = MIN(cave->h, MAX_LEV_FIELDY);
3708 level->time = cave->level_time[bd_level_nr];
3709 level->gems_needed = cave->level_diamonds[bd_level_nr];
3710 level->time_magic_wall = cave->level_magic_wall_time[bd_level_nr];
3712 level->score[SC_TIME_BONUS] = cave->level_timevalue[bd_level_nr];
3713 level->score[SC_DIAMOND] = cave->diamond_value;
3715 strncpy(level->name, cave->name, MAX_LEVEL_NAME_LEN);
3716 level->name[MAX_LEVEL_NAME_LEN] = '\0';
3718 for (x = 0; x < level->fieldx; x++)
3719 for (y = 0; y < level->fieldy; y++)
3720 level->field[x][y] = map_element_BD_to_RND(cave->map[y][x]);
3723 static void setTapeInfoToDefaults(void);
3725 static void CopyNativeTape_BD_to_RND(struct LevelInfo *level)
3727 struct LevelInfo_BD *level_bd = level->native_bd_level;
3728 GdCave *cave = level_bd->cave;
3729 GdReplay *replay = level_bd->replay;
3735 // always start with reliable default values
3736 setTapeInfoToDefaults();
3738 tape.level_nr = level_nr; // (currently not used)
3739 tape.random_seed = replay->seed;
3741 TapeSetDateFromIsoDateString(replay->date);
3744 tape.pos[tape.counter].delay = 0;
3746 tape.bd_replay = TRUE;
3748 // all time calculations only used to display approximate tape time
3749 int cave_speed = cave->speed;
3750 int milliseconds_game = 0;
3751 int milliseconds_elapsed = 20;
3753 for (i = 0; i < replay->movements->len; i++)
3755 int replay_action = replay->movements->data[i];
3756 int tape_action = map_action_BD_to_RND(replay_action);
3757 byte action[MAX_TAPE_ACTIONS] = { tape_action };
3758 boolean success = 0;
3762 success = TapeAddAction(action);
3764 milliseconds_game += milliseconds_elapsed;
3766 if (milliseconds_game >= cave_speed)
3768 milliseconds_game -= cave_speed;
3775 tape.pos[tape.counter].delay = 0;
3776 tape.pos[tape.counter].action[0] = 0;
3780 Warn("BD replay truncated: size exceeds maximum tape size %d", MAX_TAPE_LEN);
3786 TapeHaltRecording();
3790 // ----------------------------------------------------------------------------
3791 // functions for loading EM level
3792 // ----------------------------------------------------------------------------
3794 static void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
3796 static int ball_xy[8][2] =
3807 struct LevelInfo_EM *level_em = level->native_em_level;
3808 struct CAVE *cav = level_em->cav;
3811 cav->width = MIN(level->fieldx, MAX_PLAYFIELD_WIDTH);
3812 cav->height = MIN(level->fieldy, MAX_PLAYFIELD_HEIGHT);
3814 cav->time_seconds = level->time;
3815 cav->gems_needed = level->gems_needed;
3817 cav->emerald_score = level->score[SC_EMERALD];
3818 cav->diamond_score = level->score[SC_DIAMOND];
3819 cav->alien_score = level->score[SC_ROBOT];
3820 cav->tank_score = level->score[SC_SPACESHIP];
3821 cav->bug_score = level->score[SC_BUG];
3822 cav->eater_score = level->score[SC_YAMYAM];
3823 cav->nut_score = level->score[SC_NUT];
3824 cav->dynamite_score = level->score[SC_DYNAMITE];
3825 cav->key_score = level->score[SC_KEY];
3826 cav->exit_score = level->score[SC_TIME_BONUS];
3828 cav->num_eater_arrays = level->num_yamyam_contents;
3830 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3831 for (y = 0; y < 3; y++)
3832 for (x = 0; x < 3; x++)
3833 cav->eater_array[i][y * 3 + x] =
3834 map_element_RND_to_EM_cave(level->yamyam_content[i].e[x][y]);
3836 cav->amoeba_time = level->amoeba_speed;
3837 cav->wonderwall_time = level->time_magic_wall;
3838 cav->wheel_time = level->time_wheel;
3840 cav->android_move_time = level->android_move_time;
3841 cav->android_clone_time = level->android_clone_time;
3842 cav->ball_random = level->ball_random;
3843 cav->ball_active = level->ball_active_initial;
3844 cav->ball_time = level->ball_time;
3845 cav->num_ball_arrays = level->num_ball_contents;
3847 cav->lenses_score = level->lenses_score;
3848 cav->magnify_score = level->magnify_score;
3849 cav->slurp_score = level->slurp_score;
3851 cav->lenses_time = level->lenses_time;
3852 cav->magnify_time = level->magnify_time;
3854 cav->wind_time = 9999;
3855 cav->wind_direction =
3856 map_direction_RND_to_EM(level->wind_direction_initial);
3858 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3859 for (j = 0; j < 8; j++)
3860 cav->ball_array[i][j] =
3861 map_element_RND_to_EM_cave(level->ball_content[i].
3862 e[ball_xy[j][0]][ball_xy[j][1]]);
3864 map_android_clone_elements_RND_to_EM(level);
3866 // first fill the complete playfield with the empty space element
3867 for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
3868 for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
3869 cav->cave[x][y] = Cblank;
3871 // then copy the real level contents from level file into the playfield
3872 for (y = 0; y < cav->height; y++) for (x = 0; x < cav->width; x++)
3874 int new_element = map_element_RND_to_EM_cave(level->field[x][y]);
3876 if (level->field[x][y] == EL_AMOEBA_DEAD)
3877 new_element = map_element_RND_to_EM_cave(EL_AMOEBA_WET);
3879 cav->cave[x][y] = new_element;
3882 for (i = 0; i < MAX_PLAYERS; i++)
3884 cav->player_x[i] = -1;
3885 cav->player_y[i] = -1;
3888 // initialize player positions and delete players from the playfield
3889 for (y = 0; y < cav->height; y++) for (x = 0; x < cav->width; x++)
3891 if (IS_PLAYER_ELEMENT(level->field[x][y]))
3893 int player_nr = GET_PLAYER_NR(level->field[x][y]);
3895 cav->player_x[player_nr] = x;
3896 cav->player_y[player_nr] = y;
3898 cav->cave[x][y] = map_element_RND_to_EM_cave(EL_EMPTY);
3903 static void CopyNativeLevel_EM_to_RND(struct LevelInfo *level)
3905 static int ball_xy[8][2] =
3916 struct LevelInfo_EM *level_em = level->native_em_level;
3917 struct CAVE *cav = level_em->cav;
3920 level->fieldx = MIN(cav->width, MAX_LEV_FIELDX);
3921 level->fieldy = MIN(cav->height, MAX_LEV_FIELDY);
3923 level->time = cav->time_seconds;
3924 level->gems_needed = cav->gems_needed;
3926 sprintf(level->name, "Level %d", level->file_info.nr);
3928 level->score[SC_EMERALD] = cav->emerald_score;
3929 level->score[SC_DIAMOND] = cav->diamond_score;
3930 level->score[SC_ROBOT] = cav->alien_score;
3931 level->score[SC_SPACESHIP] = cav->tank_score;
3932 level->score[SC_BUG] = cav->bug_score;
3933 level->score[SC_YAMYAM] = cav->eater_score;
3934 level->score[SC_NUT] = cav->nut_score;
3935 level->score[SC_DYNAMITE] = cav->dynamite_score;
3936 level->score[SC_KEY] = cav->key_score;
3937 level->score[SC_TIME_BONUS] = cav->exit_score;
3939 level->num_yamyam_contents = cav->num_eater_arrays;
3941 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3942 for (y = 0; y < 3; y++)
3943 for (x = 0; x < 3; x++)
3944 level->yamyam_content[i].e[x][y] =
3945 map_element_EM_to_RND_cave(cav->eater_array[i][y * 3 + x]);
3947 level->amoeba_speed = cav->amoeba_time;
3948 level->time_magic_wall = cav->wonderwall_time;
3949 level->time_wheel = cav->wheel_time;
3951 level->android_move_time = cav->android_move_time;
3952 level->android_clone_time = cav->android_clone_time;
3953 level->ball_random = cav->ball_random;
3954 level->ball_active_initial = cav->ball_active;
3955 level->ball_time = cav->ball_time;
3956 level->num_ball_contents = cav->num_ball_arrays;
3958 level->lenses_score = cav->lenses_score;
3959 level->magnify_score = cav->magnify_score;
3960 level->slurp_score = cav->slurp_score;
3962 level->lenses_time = cav->lenses_time;
3963 level->magnify_time = cav->magnify_time;
3965 level->wind_direction_initial =
3966 map_direction_EM_to_RND(cav->wind_direction);
3968 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3969 for (j = 0; j < 8; j++)
3970 level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]] =
3971 map_element_EM_to_RND_cave(cav->ball_array[i][j]);
3973 map_android_clone_elements_EM_to_RND(level);
3975 // convert the playfield (some elements need special treatment)
3976 for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
3978 int new_element = map_element_EM_to_RND_cave(cav->cave[x][y]);
3980 if (new_element == EL_AMOEBA_WET && level->amoeba_speed == 0)
3981 new_element = EL_AMOEBA_DEAD;
3983 level->field[x][y] = new_element;
3986 for (i = 0; i < MAX_PLAYERS; i++)
3988 // in case of all players set to the same field, use the first player
3989 int nr = MAX_PLAYERS - i - 1;
3990 int jx = cav->player_x[nr];
3991 int jy = cav->player_y[nr];
3993 if (jx != -1 && jy != -1)
3994 level->field[jx][jy] = EL_PLAYER_1 + nr;
3997 // time score is counted for each 10 seconds left in Emerald Mine levels
3998 level->time_score_base = 10;
4002 // ----------------------------------------------------------------------------
4003 // functions for loading SP level
4004 // ----------------------------------------------------------------------------
4006 static void CopyNativeLevel_RND_to_SP(struct LevelInfo *level)
4008 struct LevelInfo_SP *level_sp = level->native_sp_level;
4009 LevelInfoType *header = &level_sp->header;
4012 level_sp->width = level->fieldx;
4013 level_sp->height = level->fieldy;
4015 for (x = 0; x < level->fieldx; x++)
4016 for (y = 0; y < level->fieldy; y++)
4017 level_sp->playfield[x][y] = map_element_RND_to_SP(level->field[x][y]);
4019 header->InitialGravity = (level->initial_player_gravity[0] ? 1 : 0);
4021 for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
4022 header->LevelTitle[i] = level->name[i];
4023 // !!! NO STRING TERMINATION IN SUPAPLEX VB CODE YET -- FIX THIS !!!
4025 header->InfotronsNeeded = level->gems_needed;
4027 header->SpecialPortCount = 0;
4029 for (x = 0; x < level->fieldx; x++) for (y = 0; y < level->fieldy; y++)
4031 boolean gravity_port_found = FALSE;
4032 boolean gravity_port_valid = FALSE;
4033 int gravity_port_flag;
4034 int gravity_port_base_element;
4035 int element = level->field[x][y];
4037 if (element >= EL_SP_GRAVITY_ON_PORT_RIGHT &&
4038 element <= EL_SP_GRAVITY_ON_PORT_UP)
4040 gravity_port_found = TRUE;
4041 gravity_port_valid = TRUE;
4042 gravity_port_flag = 1;
4043 gravity_port_base_element = EL_SP_GRAVITY_ON_PORT_RIGHT;
4045 else if (element >= EL_SP_GRAVITY_OFF_PORT_RIGHT &&
4046 element <= EL_SP_GRAVITY_OFF_PORT_UP)
4048 gravity_port_found = TRUE;
4049 gravity_port_valid = TRUE;
4050 gravity_port_flag = 0;
4051 gravity_port_base_element = EL_SP_GRAVITY_OFF_PORT_RIGHT;
4053 else if (element >= EL_SP_GRAVITY_PORT_RIGHT &&
4054 element <= EL_SP_GRAVITY_PORT_UP)
4056 // change R'n'D style gravity inverting special port to normal port
4057 // (there are no gravity inverting ports in native Supaplex engine)
4059 gravity_port_found = TRUE;
4060 gravity_port_valid = FALSE;
4061 gravity_port_base_element = EL_SP_GRAVITY_PORT_RIGHT;
4064 if (gravity_port_found)
4066 if (gravity_port_valid &&
4067 header->SpecialPortCount < SP_MAX_SPECIAL_PORTS)
4069 SpecialPortType *port = &header->SpecialPort[header->SpecialPortCount];
4071 port->PortLocation = (y * level->fieldx + x) * 2;
4072 port->Gravity = gravity_port_flag;
4074 element += EL_SP_GRAVITY_PORT_RIGHT - gravity_port_base_element;
4076 header->SpecialPortCount++;
4080 // change special gravity port to normal port
4082 element += EL_SP_PORT_RIGHT - gravity_port_base_element;
4085 level_sp->playfield[x][y] = element - EL_SP_START;
4090 static void CopyNativeLevel_SP_to_RND(struct LevelInfo *level)
4092 struct LevelInfo_SP *level_sp = level->native_sp_level;
4093 LevelInfoType *header = &level_sp->header;
4094 boolean num_invalid_elements = 0;
4097 level->fieldx = level_sp->width;
4098 level->fieldy = level_sp->height;
4100 for (x = 0; x < level->fieldx; x++)
4102 for (y = 0; y < level->fieldy; y++)
4104 int element_old = level_sp->playfield[x][y];
4105 int element_new = getMappedElement(map_element_SP_to_RND(element_old));
4107 if (element_new == EL_UNKNOWN)
4109 num_invalid_elements++;
4111 Debug("level:native:SP", "invalid element %d at position %d, %d",
4115 level->field[x][y] = element_new;
4119 if (num_invalid_elements > 0)
4120 Warn("found %d invalid elements%s", num_invalid_elements,
4121 (!options.debug ? " (use '--debug' for more details)" : ""));
4123 for (i = 0; i < MAX_PLAYERS; i++)
4124 level->initial_player_gravity[i] =
4125 (header->InitialGravity == 1 ? TRUE : FALSE);
4127 // skip leading spaces
4128 for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
4129 if (header->LevelTitle[i] != ' ')
4133 for (j = 0; i < SP_LEVEL_NAME_LEN; i++, j++)
4134 level->name[j] = header->LevelTitle[i];
4135 level->name[j] = '\0';
4137 // cut trailing spaces
4139 if (level->name[j - 1] == ' ' && level->name[j] == '\0')
4140 level->name[j - 1] = '\0';
4142 level->gems_needed = header->InfotronsNeeded;
4144 for (i = 0; i < header->SpecialPortCount; i++)
4146 SpecialPortType *port = &header->SpecialPort[i];
4147 int port_location = port->PortLocation;
4148 int gravity = port->Gravity;
4149 int port_x, port_y, port_element;
4151 port_x = (port_location / 2) % level->fieldx;
4152 port_y = (port_location / 2) / level->fieldx;
4154 if (port_x < 0 || port_x >= level->fieldx ||
4155 port_y < 0 || port_y >= level->fieldy)
4157 Warn("special port position (%d, %d) out of bounds", port_x, port_y);
4162 port_element = level->field[port_x][port_y];
4164 if (port_element < EL_SP_GRAVITY_PORT_RIGHT ||
4165 port_element > EL_SP_GRAVITY_PORT_UP)
4167 Warn("no special port at position (%d, %d)", port_x, port_y);
4172 // change previous (wrong) gravity inverting special port to either
4173 // gravity enabling special port or gravity disabling special port
4174 level->field[port_x][port_y] +=
4175 (gravity == 1 ? EL_SP_GRAVITY_ON_PORT_RIGHT :
4176 EL_SP_GRAVITY_OFF_PORT_RIGHT) - EL_SP_GRAVITY_PORT_RIGHT;
4179 // change special gravity ports without database entries to normal ports
4180 for (x = 0; x < level->fieldx; x++)
4181 for (y = 0; y < level->fieldy; y++)
4182 if (level->field[x][y] >= EL_SP_GRAVITY_PORT_RIGHT &&
4183 level->field[x][y] <= EL_SP_GRAVITY_PORT_UP)
4184 level->field[x][y] += EL_SP_PORT_RIGHT - EL_SP_GRAVITY_PORT_RIGHT;
4186 level->time = 0; // no time limit
4187 level->amoeba_speed = 0;
4188 level->time_magic_wall = 0;
4189 level->time_wheel = 0;
4190 level->amoeba_content = EL_EMPTY;
4192 // original Supaplex does not use score values -- rate by playing time
4193 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
4194 level->score[i] = 0;
4196 level->rate_time_over_score = TRUE;
4198 // there are no yamyams in supaplex levels
4199 for (i = 0; i < level->num_yamyam_contents; i++)
4200 for (x = 0; x < 3; x++)
4201 for (y = 0; y < 3; y++)
4202 level->yamyam_content[i].e[x][y] = EL_EMPTY;
4205 static void CopyNativeTape_RND_to_SP(struct LevelInfo *level)
4207 struct LevelInfo_SP *level_sp = level->native_sp_level;
4208 struct DemoInfo_SP *demo = &level_sp->demo;
4211 // always start with reliable default values
4212 demo->is_available = FALSE;
4215 if (TAPE_IS_EMPTY(tape))
4218 demo->level_nr = tape.level_nr; // (currently not used)
4220 level_sp->header.DemoRandomSeed = tape.random_seed;
4224 for (i = 0; i < tape.length; i++)
4226 int demo_action = map_key_RND_to_SP(tape.pos[i].action[0]);
4227 int demo_repeat = tape.pos[i].delay;
4228 int demo_entries = (demo_repeat + 15) / 16;
4230 if (demo->length + demo_entries >= SP_MAX_TAPE_LEN)
4232 Warn("tape truncated: size exceeds maximum SP demo size %d",
4238 for (j = 0; j < demo_repeat / 16; j++)
4239 demo->data[demo->length++] = 0xf0 | demo_action;
4241 if (demo_repeat % 16)
4242 demo->data[demo->length++] = ((demo_repeat % 16 - 1) << 4) | demo_action;
4245 demo->is_available = TRUE;
4248 static void CopyNativeTape_SP_to_RND(struct LevelInfo *level)
4250 struct LevelInfo_SP *level_sp = level->native_sp_level;
4251 struct DemoInfo_SP *demo = &level_sp->demo;
4252 char *filename = level->file_info.filename;
4255 // always start with reliable default values
4256 setTapeInfoToDefaults();
4258 if (!demo->is_available)
4261 tape.level_nr = demo->level_nr; // (currently not used)
4262 tape.random_seed = level_sp->header.DemoRandomSeed;
4264 TapeSetDateFromEpochSeconds(getFileTimestampEpochSeconds(filename));
4267 tape.pos[tape.counter].delay = 0;
4269 for (i = 0; i < demo->length; i++)
4271 int demo_action = demo->data[i] & 0x0f;
4272 int demo_repeat = (demo->data[i] & 0xf0) >> 4;
4273 int tape_action = map_key_SP_to_RND(demo_action);
4274 int tape_repeat = demo_repeat + 1;
4275 byte action[MAX_TAPE_ACTIONS] = { tape_action };
4276 boolean success = 0;
4279 for (j = 0; j < tape_repeat; j++)
4280 success = TapeAddAction(action);
4284 Warn("SP demo truncated: size exceeds maximum tape size %d",
4291 TapeHaltRecording();
4295 // ----------------------------------------------------------------------------
4296 // functions for loading MM level
4297 // ----------------------------------------------------------------------------
4299 static void CopyNativeLevel_RND_to_MM(struct LevelInfo *level)
4301 struct LevelInfo_MM *level_mm = level->native_mm_level;
4304 level_mm->fieldx = MIN(level->fieldx, MM_MAX_PLAYFIELD_WIDTH);
4305 level_mm->fieldy = MIN(level->fieldy, MM_MAX_PLAYFIELD_HEIGHT);
4307 level_mm->time = level->time;
4308 level_mm->kettles_needed = level->gems_needed;
4309 level_mm->auto_count_kettles = level->auto_count_gems;
4311 level_mm->mm_laser_red = level->mm_laser_red;
4312 level_mm->mm_laser_green = level->mm_laser_green;
4313 level_mm->mm_laser_blue = level->mm_laser_blue;
4315 level_mm->df_laser_red = level->df_laser_red;
4316 level_mm->df_laser_green = level->df_laser_green;
4317 level_mm->df_laser_blue = level->df_laser_blue;
4319 strcpy(level_mm->name, level->name);
4320 strcpy(level_mm->author, level->author);
4322 level_mm->score[SC_EMERALD] = level->score[SC_EMERALD];
4323 level_mm->score[SC_PACMAN] = level->score[SC_PACMAN];
4324 level_mm->score[SC_KEY] = level->score[SC_KEY];
4325 level_mm->score[SC_TIME_BONUS] = level->score[SC_TIME_BONUS];
4326 level_mm->score[SC_ELEM_BONUS] = level->score[SC_ELEM_BONUS];
4328 level_mm->amoeba_speed = level->amoeba_speed;
4329 level_mm->time_fuse = level->mm_time_fuse;
4330 level_mm->time_bomb = level->mm_time_bomb;
4331 level_mm->time_ball = level->mm_time_ball;
4332 level_mm->time_block = level->mm_time_block;
4334 level_mm->num_ball_contents = level->num_mm_ball_contents;
4335 level_mm->ball_choice_mode = level->mm_ball_choice_mode;
4336 level_mm->rotate_ball_content = level->rotate_mm_ball_content;
4337 level_mm->explode_ball = level->explode_mm_ball;
4339 for (i = 0; i < level->num_mm_ball_contents; i++)
4340 level_mm->ball_content[i] =
4341 map_element_RND_to_MM(level->mm_ball_content[i]);
4343 for (x = 0; x < level->fieldx; x++)
4344 for (y = 0; y < level->fieldy; y++)
4346 level_mm->field[x][y] = map_element_RND_to_MM(level->field[x][y]);
4349 static void CopyNativeLevel_MM_to_RND(struct LevelInfo *level)
4351 struct LevelInfo_MM *level_mm = level->native_mm_level;
4354 level->fieldx = MIN(level_mm->fieldx, MAX_LEV_FIELDX);
4355 level->fieldy = MIN(level_mm->fieldy, MAX_LEV_FIELDY);
4357 level->time = level_mm->time;
4358 level->gems_needed = level_mm->kettles_needed;
4359 level->auto_count_gems = level_mm->auto_count_kettles;
4361 level->mm_laser_red = level_mm->mm_laser_red;
4362 level->mm_laser_green = level_mm->mm_laser_green;
4363 level->mm_laser_blue = level_mm->mm_laser_blue;
4365 level->df_laser_red = level_mm->df_laser_red;
4366 level->df_laser_green = level_mm->df_laser_green;
4367 level->df_laser_blue = level_mm->df_laser_blue;
4369 strcpy(level->name, level_mm->name);
4371 // only overwrite author from 'levelinfo.conf' if author defined in level
4372 if (!strEqual(level_mm->author, ANONYMOUS_NAME))
4373 strcpy(level->author, level_mm->author);
4375 level->score[SC_EMERALD] = level_mm->score[SC_EMERALD];
4376 level->score[SC_PACMAN] = level_mm->score[SC_PACMAN];
4377 level->score[SC_KEY] = level_mm->score[SC_KEY];
4378 level->score[SC_TIME_BONUS] = level_mm->score[SC_TIME_BONUS];
4379 level->score[SC_ELEM_BONUS] = level_mm->score[SC_ELEM_BONUS];
4381 level->amoeba_speed = level_mm->amoeba_speed;
4382 level->mm_time_fuse = level_mm->time_fuse;
4383 level->mm_time_bomb = level_mm->time_bomb;
4384 level->mm_time_ball = level_mm->time_ball;
4385 level->mm_time_block = level_mm->time_block;
4387 level->num_mm_ball_contents = level_mm->num_ball_contents;
4388 level->mm_ball_choice_mode = level_mm->ball_choice_mode;
4389 level->rotate_mm_ball_content = level_mm->rotate_ball_content;
4390 level->explode_mm_ball = level_mm->explode_ball;
4392 for (i = 0; i < level->num_mm_ball_contents; i++)
4393 level->mm_ball_content[i] =
4394 map_element_MM_to_RND(level_mm->ball_content[i]);
4396 for (x = 0; x < level->fieldx; x++)
4397 for (y = 0; y < level->fieldy; y++)
4398 level->field[x][y] = map_element_MM_to_RND(level_mm->field[x][y]);
4402 // ----------------------------------------------------------------------------
4403 // functions for loading DC level
4404 // ----------------------------------------------------------------------------
4406 #define DC_LEVEL_HEADER_SIZE 344
4408 static unsigned short getDecodedWord_DC(unsigned short data_encoded,
4411 static int last_data_encoded;
4415 int diff_hi, diff_lo;
4416 int data_hi, data_lo;
4417 unsigned short data_decoded;
4421 last_data_encoded = 0;
4428 diff = data_encoded - last_data_encoded;
4429 diff_hi = diff & ~0xff;
4430 diff_lo = diff & 0xff;
4434 data_hi = diff_hi - (offset1 << 8) + (offset2 & 0xff00);
4435 data_lo = (diff_lo + (data_hi >> 16)) & 0x00ff;
4436 data_hi = data_hi & 0xff00;
4438 data_decoded = data_hi | data_lo;
4440 last_data_encoded = data_encoded;
4442 offset1 = (offset1 + 1) % 31;
4443 offset2 = offset2 & 0xff;
4445 return data_decoded;
4448 static int getMappedElement_DC(int element)
4456 // 0x0117 - 0x036e: (?)
4459 // 0x042d - 0x0684: (?)
4475 element = EL_CRYSTAL;
4478 case 0x0e77: // quicksand (boulder)
4479 element = EL_QUICKSAND_FAST_FULL;
4482 case 0x0e99: // slow quicksand (boulder)
4483 element = EL_QUICKSAND_FULL;
4487 element = EL_EM_EXIT_OPEN;
4491 element = EL_EM_EXIT_CLOSED;
4495 element = EL_EM_STEEL_EXIT_OPEN;
4499 element = EL_EM_STEEL_EXIT_CLOSED;
4502 case 0x0f4f: // dynamite (lit 1)
4503 element = EL_EM_DYNAMITE_ACTIVE;
4506 case 0x0f57: // dynamite (lit 2)
4507 element = EL_EM_DYNAMITE_ACTIVE;
4510 case 0x0f5f: // dynamite (lit 3)
4511 element = EL_EM_DYNAMITE_ACTIVE;
4514 case 0x0f67: // dynamite (lit 4)
4515 element = EL_EM_DYNAMITE_ACTIVE;
4522 element = EL_AMOEBA_WET;
4526 element = EL_AMOEBA_DROP;
4530 element = EL_DC_MAGIC_WALL;
4534 element = EL_SPACESHIP_UP;
4538 element = EL_SPACESHIP_DOWN;
4542 element = EL_SPACESHIP_LEFT;
4546 element = EL_SPACESHIP_RIGHT;
4550 element = EL_BUG_UP;
4554 element = EL_BUG_DOWN;
4558 element = EL_BUG_LEFT;
4562 element = EL_BUG_RIGHT;
4566 element = EL_MOLE_UP;
4570 element = EL_MOLE_DOWN;
4574 element = EL_MOLE_LEFT;
4578 element = EL_MOLE_RIGHT;
4586 element = EL_YAMYAM_UP;
4590 element = EL_SWITCHGATE_OPEN;
4594 element = EL_SWITCHGATE_CLOSED;
4598 element = EL_DC_SWITCHGATE_SWITCH_UP;
4602 element = EL_TIMEGATE_CLOSED;
4605 case 0x144c: // conveyor belt switch (green)
4606 element = EL_CONVEYOR_BELT_3_SWITCH_MIDDLE;
4609 case 0x144f: // conveyor belt switch (red)
4610 element = EL_CONVEYOR_BELT_1_SWITCH_MIDDLE;
4613 case 0x1452: // conveyor belt switch (blue)
4614 element = EL_CONVEYOR_BELT_4_SWITCH_MIDDLE;
4618 element = EL_CONVEYOR_BELT_3_MIDDLE;
4622 element = EL_CONVEYOR_BELT_3_LEFT;
4626 element = EL_CONVEYOR_BELT_3_RIGHT;
4630 element = EL_CONVEYOR_BELT_1_MIDDLE;
4634 element = EL_CONVEYOR_BELT_1_LEFT;
4638 element = EL_CONVEYOR_BELT_1_RIGHT;
4642 element = EL_CONVEYOR_BELT_4_MIDDLE;
4646 element = EL_CONVEYOR_BELT_4_LEFT;
4650 element = EL_CONVEYOR_BELT_4_RIGHT;
4654 element = EL_EXPANDABLE_WALL_HORIZONTAL;
4658 element = EL_EXPANDABLE_WALL_VERTICAL;
4662 element = EL_EXPANDABLE_WALL_ANY;
4665 case 0x14ce: // growing steel wall (left/right)
4666 element = EL_EXPANDABLE_STEELWALL_HORIZONTAL;
4669 case 0x14df: // growing steel wall (up/down)
4670 element = EL_EXPANDABLE_STEELWALL_VERTICAL;
4673 case 0x14e8: // growing steel wall (up/down/left/right)
4674 element = EL_EXPANDABLE_STEELWALL_ANY;
4678 element = EL_SHIELD_DEADLY;
4682 element = EL_EXTRA_TIME;
4690 element = EL_EMPTY_SPACE;
4693 case 0x1578: // quicksand (empty)
4694 element = EL_QUICKSAND_FAST_EMPTY;
4697 case 0x1579: // slow quicksand (empty)
4698 element = EL_QUICKSAND_EMPTY;
4708 element = EL_EM_DYNAMITE;
4711 case 0x15a1: // key (red)
4712 element = EL_EM_KEY_1;
4715 case 0x15a2: // key (yellow)
4716 element = EL_EM_KEY_2;
4719 case 0x15a3: // key (blue)
4720 element = EL_EM_KEY_4;
4723 case 0x15a4: // key (green)
4724 element = EL_EM_KEY_3;
4727 case 0x15a5: // key (white)
4728 element = EL_DC_KEY_WHITE;
4732 element = EL_WALL_SLIPPERY;
4739 case 0x15a8: // wall (not round)
4743 case 0x15a9: // (blue)
4744 element = EL_CHAR_A;
4747 case 0x15aa: // (blue)
4748 element = EL_CHAR_B;
4751 case 0x15ab: // (blue)
4752 element = EL_CHAR_C;
4755 case 0x15ac: // (blue)
4756 element = EL_CHAR_D;
4759 case 0x15ad: // (blue)
4760 element = EL_CHAR_E;
4763 case 0x15ae: // (blue)
4764 element = EL_CHAR_F;
4767 case 0x15af: // (blue)
4768 element = EL_CHAR_G;
4771 case 0x15b0: // (blue)
4772 element = EL_CHAR_H;
4775 case 0x15b1: // (blue)
4776 element = EL_CHAR_I;
4779 case 0x15b2: // (blue)
4780 element = EL_CHAR_J;
4783 case 0x15b3: // (blue)
4784 element = EL_CHAR_K;
4787 case 0x15b4: // (blue)
4788 element = EL_CHAR_L;
4791 case 0x15b5: // (blue)
4792 element = EL_CHAR_M;
4795 case 0x15b6: // (blue)
4796 element = EL_CHAR_N;
4799 case 0x15b7: // (blue)
4800 element = EL_CHAR_O;
4803 case 0x15b8: // (blue)
4804 element = EL_CHAR_P;
4807 case 0x15b9: // (blue)
4808 element = EL_CHAR_Q;
4811 case 0x15ba: // (blue)
4812 element = EL_CHAR_R;
4815 case 0x15bb: // (blue)
4816 element = EL_CHAR_S;
4819 case 0x15bc: // (blue)
4820 element = EL_CHAR_T;
4823 case 0x15bd: // (blue)
4824 element = EL_CHAR_U;
4827 case 0x15be: // (blue)
4828 element = EL_CHAR_V;
4831 case 0x15bf: // (blue)
4832 element = EL_CHAR_W;
4835 case 0x15c0: // (blue)
4836 element = EL_CHAR_X;
4839 case 0x15c1: // (blue)
4840 element = EL_CHAR_Y;
4843 case 0x15c2: // (blue)
4844 element = EL_CHAR_Z;
4847 case 0x15c3: // (blue)
4848 element = EL_CHAR_AUMLAUT;
4851 case 0x15c4: // (blue)
4852 element = EL_CHAR_OUMLAUT;
4855 case 0x15c5: // (blue)
4856 element = EL_CHAR_UUMLAUT;
4859 case 0x15c6: // (blue)
4860 element = EL_CHAR_0;
4863 case 0x15c7: // (blue)
4864 element = EL_CHAR_1;
4867 case 0x15c8: // (blue)
4868 element = EL_CHAR_2;
4871 case 0x15c9: // (blue)
4872 element = EL_CHAR_3;
4875 case 0x15ca: // (blue)
4876 element = EL_CHAR_4;
4879 case 0x15cb: // (blue)
4880 element = EL_CHAR_5;
4883 case 0x15cc: // (blue)
4884 element = EL_CHAR_6;
4887 case 0x15cd: // (blue)
4888 element = EL_CHAR_7;
4891 case 0x15ce: // (blue)
4892 element = EL_CHAR_8;
4895 case 0x15cf: // (blue)
4896 element = EL_CHAR_9;
4899 case 0x15d0: // (blue)
4900 element = EL_CHAR_PERIOD;
4903 case 0x15d1: // (blue)
4904 element = EL_CHAR_EXCLAM;
4907 case 0x15d2: // (blue)
4908 element = EL_CHAR_COLON;
4911 case 0x15d3: // (blue)
4912 element = EL_CHAR_LESS;
4915 case 0x15d4: // (blue)
4916 element = EL_CHAR_GREATER;
4919 case 0x15d5: // (blue)
4920 element = EL_CHAR_QUESTION;
4923 case 0x15d6: // (blue)
4924 element = EL_CHAR_COPYRIGHT;
4927 case 0x15d7: // (blue)
4928 element = EL_CHAR_UP;
4931 case 0x15d8: // (blue)
4932 element = EL_CHAR_DOWN;
4935 case 0x15d9: // (blue)
4936 element = EL_CHAR_BUTTON;
4939 case 0x15da: // (blue)
4940 element = EL_CHAR_PLUS;
4943 case 0x15db: // (blue)
4944 element = EL_CHAR_MINUS;
4947 case 0x15dc: // (blue)
4948 element = EL_CHAR_APOSTROPHE;
4951 case 0x15dd: // (blue)
4952 element = EL_CHAR_PARENLEFT;
4955 case 0x15de: // (blue)
4956 element = EL_CHAR_PARENRIGHT;
4959 case 0x15df: // (green)
4960 element = EL_CHAR_A;
4963 case 0x15e0: // (green)
4964 element = EL_CHAR_B;
4967 case 0x15e1: // (green)
4968 element = EL_CHAR_C;
4971 case 0x15e2: // (green)
4972 element = EL_CHAR_D;
4975 case 0x15e3: // (green)
4976 element = EL_CHAR_E;
4979 case 0x15e4: // (green)
4980 element = EL_CHAR_F;
4983 case 0x15e5: // (green)
4984 element = EL_CHAR_G;
4987 case 0x15e6: // (green)
4988 element = EL_CHAR_H;
4991 case 0x15e7: // (green)
4992 element = EL_CHAR_I;
4995 case 0x15e8: // (green)
4996 element = EL_CHAR_J;
4999 case 0x15e9: // (green)
5000 element = EL_CHAR_K;
5003 case 0x15ea: // (green)
5004 element = EL_CHAR_L;
5007 case 0x15eb: // (green)
5008 element = EL_CHAR_M;
5011 case 0x15ec: // (green)
5012 element = EL_CHAR_N;
5015 case 0x15ed: // (green)
5016 element = EL_CHAR_O;
5019 case 0x15ee: // (green)
5020 element = EL_CHAR_P;
5023 case 0x15ef: // (green)
5024 element = EL_CHAR_Q;
5027 case 0x15f0: // (green)
5028 element = EL_CHAR_R;
5031 case 0x15f1: // (green)
5032 element = EL_CHAR_S;
5035 case 0x15f2: // (green)
5036 element = EL_CHAR_T;
5039 case 0x15f3: // (green)
5040 element = EL_CHAR_U;
5043 case 0x15f4: // (green)
5044 element = EL_CHAR_V;
5047 case 0x15f5: // (green)
5048 element = EL_CHAR_W;
5051 case 0x15f6: // (green)
5052 element = EL_CHAR_X;
5055 case 0x15f7: // (green)
5056 element = EL_CHAR_Y;
5059 case 0x15f8: // (green)
5060 element = EL_CHAR_Z;
5063 case 0x15f9: // (green)
5064 element = EL_CHAR_AUMLAUT;
5067 case 0x15fa: // (green)
5068 element = EL_CHAR_OUMLAUT;
5071 case 0x15fb: // (green)
5072 element = EL_CHAR_UUMLAUT;
5075 case 0x15fc: // (green)
5076 element = EL_CHAR_0;
5079 case 0x15fd: // (green)
5080 element = EL_CHAR_1;
5083 case 0x15fe: // (green)
5084 element = EL_CHAR_2;
5087 case 0x15ff: // (green)
5088 element = EL_CHAR_3;
5091 case 0x1600: // (green)
5092 element = EL_CHAR_4;
5095 case 0x1601: // (green)
5096 element = EL_CHAR_5;
5099 case 0x1602: // (green)
5100 element = EL_CHAR_6;
5103 case 0x1603: // (green)
5104 element = EL_CHAR_7;
5107 case 0x1604: // (green)
5108 element = EL_CHAR_8;
5111 case 0x1605: // (green)
5112 element = EL_CHAR_9;
5115 case 0x1606: // (green)
5116 element = EL_CHAR_PERIOD;
5119 case 0x1607: // (green)
5120 element = EL_CHAR_EXCLAM;
5123 case 0x1608: // (green)
5124 element = EL_CHAR_COLON;
5127 case 0x1609: // (green)
5128 element = EL_CHAR_LESS;
5131 case 0x160a: // (green)
5132 element = EL_CHAR_GREATER;
5135 case 0x160b: // (green)
5136 element = EL_CHAR_QUESTION;
5139 case 0x160c: // (green)
5140 element = EL_CHAR_COPYRIGHT;
5143 case 0x160d: // (green)
5144 element = EL_CHAR_UP;
5147 case 0x160e: // (green)
5148 element = EL_CHAR_DOWN;
5151 case 0x160f: // (green)
5152 element = EL_CHAR_BUTTON;
5155 case 0x1610: // (green)
5156 element = EL_CHAR_PLUS;
5159 case 0x1611: // (green)
5160 element = EL_CHAR_MINUS;
5163 case 0x1612: // (green)
5164 element = EL_CHAR_APOSTROPHE;
5167 case 0x1613: // (green)
5168 element = EL_CHAR_PARENLEFT;
5171 case 0x1614: // (green)
5172 element = EL_CHAR_PARENRIGHT;
5175 case 0x1615: // (blue steel)
5176 element = EL_STEEL_CHAR_A;
5179 case 0x1616: // (blue steel)
5180 element = EL_STEEL_CHAR_B;
5183 case 0x1617: // (blue steel)
5184 element = EL_STEEL_CHAR_C;
5187 case 0x1618: // (blue steel)
5188 element = EL_STEEL_CHAR_D;
5191 case 0x1619: // (blue steel)
5192 element = EL_STEEL_CHAR_E;
5195 case 0x161a: // (blue steel)
5196 element = EL_STEEL_CHAR_F;
5199 case 0x161b: // (blue steel)
5200 element = EL_STEEL_CHAR_G;
5203 case 0x161c: // (blue steel)
5204 element = EL_STEEL_CHAR_H;
5207 case 0x161d: // (blue steel)
5208 element = EL_STEEL_CHAR_I;
5211 case 0x161e: // (blue steel)
5212 element = EL_STEEL_CHAR_J;
5215 case 0x161f: // (blue steel)
5216 element = EL_STEEL_CHAR_K;
5219 case 0x1620: // (blue steel)
5220 element = EL_STEEL_CHAR_L;
5223 case 0x1621: // (blue steel)
5224 element = EL_STEEL_CHAR_M;
5227 case 0x1622: // (blue steel)
5228 element = EL_STEEL_CHAR_N;
5231 case 0x1623: // (blue steel)
5232 element = EL_STEEL_CHAR_O;
5235 case 0x1624: // (blue steel)
5236 element = EL_STEEL_CHAR_P;
5239 case 0x1625: // (blue steel)
5240 element = EL_STEEL_CHAR_Q;
5243 case 0x1626: // (blue steel)
5244 element = EL_STEEL_CHAR_R;
5247 case 0x1627: // (blue steel)
5248 element = EL_STEEL_CHAR_S;
5251 case 0x1628: // (blue steel)
5252 element = EL_STEEL_CHAR_T;
5255 case 0x1629: // (blue steel)
5256 element = EL_STEEL_CHAR_U;
5259 case 0x162a: // (blue steel)
5260 element = EL_STEEL_CHAR_V;
5263 case 0x162b: // (blue steel)
5264 element = EL_STEEL_CHAR_W;
5267 case 0x162c: // (blue steel)
5268 element = EL_STEEL_CHAR_X;
5271 case 0x162d: // (blue steel)
5272 element = EL_STEEL_CHAR_Y;
5275 case 0x162e: // (blue steel)
5276 element = EL_STEEL_CHAR_Z;
5279 case 0x162f: // (blue steel)
5280 element = EL_STEEL_CHAR_AUMLAUT;
5283 case 0x1630: // (blue steel)
5284 element = EL_STEEL_CHAR_OUMLAUT;
5287 case 0x1631: // (blue steel)
5288 element = EL_STEEL_CHAR_UUMLAUT;
5291 case 0x1632: // (blue steel)
5292 element = EL_STEEL_CHAR_0;
5295 case 0x1633: // (blue steel)
5296 element = EL_STEEL_CHAR_1;
5299 case 0x1634: // (blue steel)
5300 element = EL_STEEL_CHAR_2;
5303 case 0x1635: // (blue steel)
5304 element = EL_STEEL_CHAR_3;
5307 case 0x1636: // (blue steel)
5308 element = EL_STEEL_CHAR_4;
5311 case 0x1637: // (blue steel)
5312 element = EL_STEEL_CHAR_5;
5315 case 0x1638: // (blue steel)
5316 element = EL_STEEL_CHAR_6;
5319 case 0x1639: // (blue steel)
5320 element = EL_STEEL_CHAR_7;
5323 case 0x163a: // (blue steel)
5324 element = EL_STEEL_CHAR_8;
5327 case 0x163b: // (blue steel)
5328 element = EL_STEEL_CHAR_9;
5331 case 0x163c: // (blue steel)
5332 element = EL_STEEL_CHAR_PERIOD;
5335 case 0x163d: // (blue steel)
5336 element = EL_STEEL_CHAR_EXCLAM;
5339 case 0x163e: // (blue steel)
5340 element = EL_STEEL_CHAR_COLON;
5343 case 0x163f: // (blue steel)
5344 element = EL_STEEL_CHAR_LESS;
5347 case 0x1640: // (blue steel)
5348 element = EL_STEEL_CHAR_GREATER;
5351 case 0x1641: // (blue steel)
5352 element = EL_STEEL_CHAR_QUESTION;
5355 case 0x1642: // (blue steel)
5356 element = EL_STEEL_CHAR_COPYRIGHT;
5359 case 0x1643: // (blue steel)
5360 element = EL_STEEL_CHAR_UP;
5363 case 0x1644: // (blue steel)
5364 element = EL_STEEL_CHAR_DOWN;
5367 case 0x1645: // (blue steel)
5368 element = EL_STEEL_CHAR_BUTTON;
5371 case 0x1646: // (blue steel)
5372 element = EL_STEEL_CHAR_PLUS;
5375 case 0x1647: // (blue steel)
5376 element = EL_STEEL_CHAR_MINUS;
5379 case 0x1648: // (blue steel)
5380 element = EL_STEEL_CHAR_APOSTROPHE;
5383 case 0x1649: // (blue steel)
5384 element = EL_STEEL_CHAR_PARENLEFT;
5387 case 0x164a: // (blue steel)
5388 element = EL_STEEL_CHAR_PARENRIGHT;
5391 case 0x164b: // (green steel)
5392 element = EL_STEEL_CHAR_A;
5395 case 0x164c: // (green steel)
5396 element = EL_STEEL_CHAR_B;
5399 case 0x164d: // (green steel)
5400 element = EL_STEEL_CHAR_C;
5403 case 0x164e: // (green steel)
5404 element = EL_STEEL_CHAR_D;
5407 case 0x164f: // (green steel)
5408 element = EL_STEEL_CHAR_E;
5411 case 0x1650: // (green steel)
5412 element = EL_STEEL_CHAR_F;
5415 case 0x1651: // (green steel)
5416 element = EL_STEEL_CHAR_G;
5419 case 0x1652: // (green steel)
5420 element = EL_STEEL_CHAR_H;
5423 case 0x1653: // (green steel)
5424 element = EL_STEEL_CHAR_I;
5427 case 0x1654: // (green steel)
5428 element = EL_STEEL_CHAR_J;
5431 case 0x1655: // (green steel)
5432 element = EL_STEEL_CHAR_K;
5435 case 0x1656: // (green steel)
5436 element = EL_STEEL_CHAR_L;
5439 case 0x1657: // (green steel)
5440 element = EL_STEEL_CHAR_M;
5443 case 0x1658: // (green steel)
5444 element = EL_STEEL_CHAR_N;
5447 case 0x1659: // (green steel)
5448 element = EL_STEEL_CHAR_O;
5451 case 0x165a: // (green steel)
5452 element = EL_STEEL_CHAR_P;
5455 case 0x165b: // (green steel)
5456 element = EL_STEEL_CHAR_Q;
5459 case 0x165c: // (green steel)
5460 element = EL_STEEL_CHAR_R;
5463 case 0x165d: // (green steel)
5464 element = EL_STEEL_CHAR_S;
5467 case 0x165e: // (green steel)
5468 element = EL_STEEL_CHAR_T;
5471 case 0x165f: // (green steel)
5472 element = EL_STEEL_CHAR_U;
5475 case 0x1660: // (green steel)
5476 element = EL_STEEL_CHAR_V;
5479 case 0x1661: // (green steel)
5480 element = EL_STEEL_CHAR_W;
5483 case 0x1662: // (green steel)
5484 element = EL_STEEL_CHAR_X;
5487 case 0x1663: // (green steel)
5488 element = EL_STEEL_CHAR_Y;
5491 case 0x1664: // (green steel)
5492 element = EL_STEEL_CHAR_Z;
5495 case 0x1665: // (green steel)
5496 element = EL_STEEL_CHAR_AUMLAUT;
5499 case 0x1666: // (green steel)
5500 element = EL_STEEL_CHAR_OUMLAUT;
5503 case 0x1667: // (green steel)
5504 element = EL_STEEL_CHAR_UUMLAUT;
5507 case 0x1668: // (green steel)
5508 element = EL_STEEL_CHAR_0;
5511 case 0x1669: // (green steel)
5512 element = EL_STEEL_CHAR_1;
5515 case 0x166a: // (green steel)
5516 element = EL_STEEL_CHAR_2;
5519 case 0x166b: // (green steel)
5520 element = EL_STEEL_CHAR_3;
5523 case 0x166c: // (green steel)
5524 element = EL_STEEL_CHAR_4;
5527 case 0x166d: // (green steel)
5528 element = EL_STEEL_CHAR_5;
5531 case 0x166e: // (green steel)
5532 element = EL_STEEL_CHAR_6;
5535 case 0x166f: // (green steel)
5536 element = EL_STEEL_CHAR_7;
5539 case 0x1670: // (green steel)
5540 element = EL_STEEL_CHAR_8;
5543 case 0x1671: // (green steel)
5544 element = EL_STEEL_CHAR_9;
5547 case 0x1672: // (green steel)
5548 element = EL_STEEL_CHAR_PERIOD;
5551 case 0x1673: // (green steel)
5552 element = EL_STEEL_CHAR_EXCLAM;
5555 case 0x1674: // (green steel)
5556 element = EL_STEEL_CHAR_COLON;
5559 case 0x1675: // (green steel)
5560 element = EL_STEEL_CHAR_LESS;
5563 case 0x1676: // (green steel)
5564 element = EL_STEEL_CHAR_GREATER;
5567 case 0x1677: // (green steel)
5568 element = EL_STEEL_CHAR_QUESTION;
5571 case 0x1678: // (green steel)
5572 element = EL_STEEL_CHAR_COPYRIGHT;
5575 case 0x1679: // (green steel)
5576 element = EL_STEEL_CHAR_UP;
5579 case 0x167a: // (green steel)
5580 element = EL_STEEL_CHAR_DOWN;
5583 case 0x167b: // (green steel)
5584 element = EL_STEEL_CHAR_BUTTON;
5587 case 0x167c: // (green steel)
5588 element = EL_STEEL_CHAR_PLUS;
5591 case 0x167d: // (green steel)
5592 element = EL_STEEL_CHAR_MINUS;
5595 case 0x167e: // (green steel)
5596 element = EL_STEEL_CHAR_APOSTROPHE;
5599 case 0x167f: // (green steel)
5600 element = EL_STEEL_CHAR_PARENLEFT;
5603 case 0x1680: // (green steel)
5604 element = EL_STEEL_CHAR_PARENRIGHT;
5607 case 0x1681: // gate (red)
5608 element = EL_EM_GATE_1;
5611 case 0x1682: // secret gate (red)
5612 element = EL_EM_GATE_1_GRAY;
5615 case 0x1683: // gate (yellow)
5616 element = EL_EM_GATE_2;
5619 case 0x1684: // secret gate (yellow)
5620 element = EL_EM_GATE_2_GRAY;
5623 case 0x1685: // gate (blue)
5624 element = EL_EM_GATE_4;
5627 case 0x1686: // secret gate (blue)
5628 element = EL_EM_GATE_4_GRAY;
5631 case 0x1687: // gate (green)
5632 element = EL_EM_GATE_3;
5635 case 0x1688: // secret gate (green)
5636 element = EL_EM_GATE_3_GRAY;
5639 case 0x1689: // gate (white)
5640 element = EL_DC_GATE_WHITE;
5643 case 0x168a: // secret gate (white)
5644 element = EL_DC_GATE_WHITE_GRAY;
5647 case 0x168b: // secret gate (no key)
5648 element = EL_DC_GATE_FAKE_GRAY;
5652 element = EL_ROBOT_WHEEL;
5656 element = EL_DC_TIMEGATE_SWITCH;
5660 element = EL_ACID_POOL_BOTTOM;
5664 element = EL_ACID_POOL_TOPLEFT;
5668 element = EL_ACID_POOL_TOPRIGHT;
5672 element = EL_ACID_POOL_BOTTOMLEFT;
5676 element = EL_ACID_POOL_BOTTOMRIGHT;
5680 element = EL_STEELWALL;
5684 element = EL_STEELWALL_SLIPPERY;
5687 case 0x1695: // steel wall (not round)
5688 element = EL_STEELWALL;
5691 case 0x1696: // steel wall (left)
5692 element = EL_DC_STEELWALL_1_LEFT;
5695 case 0x1697: // steel wall (bottom)
5696 element = EL_DC_STEELWALL_1_BOTTOM;
5699 case 0x1698: // steel wall (right)
5700 element = EL_DC_STEELWALL_1_RIGHT;
5703 case 0x1699: // steel wall (top)
5704 element = EL_DC_STEELWALL_1_TOP;
5707 case 0x169a: // steel wall (left/bottom)
5708 element = EL_DC_STEELWALL_1_BOTTOMLEFT;
5711 case 0x169b: // steel wall (right/bottom)
5712 element = EL_DC_STEELWALL_1_BOTTOMRIGHT;
5715 case 0x169c: // steel wall (right/top)
5716 element = EL_DC_STEELWALL_1_TOPRIGHT;
5719 case 0x169d: // steel wall (left/top)
5720 element = EL_DC_STEELWALL_1_TOPLEFT;
5723 case 0x169e: // steel wall (right/bottom small)
5724 element = EL_DC_STEELWALL_1_BOTTOMRIGHT_2;
5727 case 0x169f: // steel wall (left/bottom small)
5728 element = EL_DC_STEELWALL_1_BOTTOMLEFT_2;
5731 case 0x16a0: // steel wall (right/top small)
5732 element = EL_DC_STEELWALL_1_TOPRIGHT_2;
5735 case 0x16a1: // steel wall (left/top small)
5736 element = EL_DC_STEELWALL_1_TOPLEFT_2;
5739 case 0x16a2: // steel wall (left/right)
5740 element = EL_DC_STEELWALL_1_VERTICAL;
5743 case 0x16a3: // steel wall (top/bottom)
5744 element = EL_DC_STEELWALL_1_HORIZONTAL;
5747 case 0x16a4: // steel wall 2 (left end)
5748 element = EL_DC_STEELWALL_2_LEFT;
5751 case 0x16a5: // steel wall 2 (right end)
5752 element = EL_DC_STEELWALL_2_RIGHT;
5755 case 0x16a6: // steel wall 2 (top end)
5756 element = EL_DC_STEELWALL_2_TOP;
5759 case 0x16a7: // steel wall 2 (bottom end)
5760 element = EL_DC_STEELWALL_2_BOTTOM;
5763 case 0x16a8: // steel wall 2 (left/right)
5764 element = EL_DC_STEELWALL_2_HORIZONTAL;
5767 case 0x16a9: // steel wall 2 (up/down)
5768 element = EL_DC_STEELWALL_2_VERTICAL;
5771 case 0x16aa: // steel wall 2 (mid)
5772 element = EL_DC_STEELWALL_2_MIDDLE;
5776 element = EL_SIGN_EXCLAMATION;
5780 element = EL_SIGN_RADIOACTIVITY;
5784 element = EL_SIGN_STOP;
5788 element = EL_SIGN_WHEELCHAIR;
5792 element = EL_SIGN_PARKING;
5796 element = EL_SIGN_NO_ENTRY;
5800 element = EL_SIGN_HEART;
5804 element = EL_SIGN_GIVE_WAY;
5808 element = EL_SIGN_ENTRY_FORBIDDEN;
5812 element = EL_SIGN_EMERGENCY_EXIT;
5816 element = EL_SIGN_YIN_YANG;
5820 element = EL_WALL_EMERALD;
5824 element = EL_WALL_DIAMOND;
5828 element = EL_WALL_PEARL;
5832 element = EL_WALL_CRYSTAL;
5836 element = EL_INVISIBLE_WALL;
5840 element = EL_INVISIBLE_STEELWALL;
5844 // EL_INVISIBLE_SAND
5847 element = EL_LIGHT_SWITCH;
5851 element = EL_ENVELOPE_1;
5855 if (element >= 0x0117 && element <= 0x036e) // (?)
5856 element = EL_DIAMOND;
5857 else if (element >= 0x042d && element <= 0x0684) // (?)
5858 element = EL_EMERALD;
5859 else if (element >= 0x157c && element <= 0x158b)
5861 else if (element >= 0x1590 && element <= 0x159f)
5862 element = EL_DC_LANDMINE;
5863 else if (element >= 0x16bc && element <= 0x16cb)
5864 element = EL_INVISIBLE_SAND;
5867 Warn("unknown Diamond Caves element 0x%04x", element);
5869 element = EL_UNKNOWN;
5874 return getMappedElement(element);
5877 static void LoadLevelFromFileStream_DC(File *file, struct LevelInfo *level)
5879 byte header[DC_LEVEL_HEADER_SIZE];
5881 int envelope_header_pos = 62;
5882 int envelope_content_pos = 94;
5883 int level_name_pos = 251;
5884 int level_author_pos = 292;
5885 int envelope_header_len;
5886 int envelope_content_len;
5888 int level_author_len;
5890 int num_yamyam_contents;
5893 getDecodedWord_DC(0, TRUE); // initialize DC2 decoding engine
5895 for (i = 0; i < DC_LEVEL_HEADER_SIZE / 2; i++)
5897 unsigned short header_word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5899 header[i * 2 + 0] = header_word >> 8;
5900 header[i * 2 + 1] = header_word & 0xff;
5903 // read some values from level header to check level decoding integrity
5904 fieldx = header[6] | (header[7] << 8);
5905 fieldy = header[8] | (header[9] << 8);
5906 num_yamyam_contents = header[60] | (header[61] << 8);
5908 // do some simple sanity checks to ensure that level was correctly decoded
5909 if (fieldx < 1 || fieldx > 256 ||
5910 fieldy < 1 || fieldy > 256 ||
5911 num_yamyam_contents < 1 || num_yamyam_contents > 8)
5913 level->no_valid_file = TRUE;
5915 Warn("cannot decode level from stream -- using empty level");
5920 // maximum envelope header size is 31 bytes
5921 envelope_header_len = header[envelope_header_pos];
5922 // maximum envelope content size is 110 (156?) bytes
5923 envelope_content_len = header[envelope_content_pos];
5925 // maximum level title size is 40 bytes
5926 level_name_len = MIN(header[level_name_pos], MAX_LEVEL_NAME_LEN);
5927 // maximum level author size is 30 (51?) bytes
5928 level_author_len = MIN(header[level_author_pos], MAX_LEVEL_AUTHOR_LEN);
5932 for (i = 0; i < envelope_header_len; i++)
5933 if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5934 level->envelope[0].text[envelope_size++] =
5935 header[envelope_header_pos + 1 + i];
5937 if (envelope_header_len > 0 && envelope_content_len > 0)
5939 if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5940 level->envelope[0].text[envelope_size++] = '\n';
5941 if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5942 level->envelope[0].text[envelope_size++] = '\n';
5945 for (i = 0; i < envelope_content_len; i++)
5946 if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5947 level->envelope[0].text[envelope_size++] =
5948 header[envelope_content_pos + 1 + i];
5950 level->envelope[0].text[envelope_size] = '\0';
5952 level->envelope[0].xsize = MAX_ENVELOPE_XSIZE;
5953 level->envelope[0].ysize = 10;
5954 level->envelope[0].autowrap = TRUE;
5955 level->envelope[0].centered = TRUE;
5957 for (i = 0; i < level_name_len; i++)
5958 level->name[i] = header[level_name_pos + 1 + i];
5959 level->name[level_name_len] = '\0';
5961 for (i = 0; i < level_author_len; i++)
5962 level->author[i] = header[level_author_pos + 1 + i];
5963 level->author[level_author_len] = '\0';
5965 num_yamyam_contents = header[60] | (header[61] << 8);
5966 level->num_yamyam_contents =
5967 MIN(MAX(MIN_ELEMENT_CONTENTS, num_yamyam_contents), MAX_ELEMENT_CONTENTS);
5969 for (i = 0; i < num_yamyam_contents; i++)
5971 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
5973 unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5974 int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5976 if (i < MAX_ELEMENT_CONTENTS)
5977 level->yamyam_content[i].e[x][y] = getMappedElement_DC(element_dc);
5981 fieldx = header[6] | (header[7] << 8);
5982 fieldy = header[8] | (header[9] << 8);
5983 level->fieldx = MIN(MAX(MIN_LEV_FIELDX, fieldx), MAX_LEV_FIELDX);
5984 level->fieldy = MIN(MAX(MIN_LEV_FIELDY, fieldy), MAX_LEV_FIELDY);
5986 for (y = 0; y < fieldy; y++) for (x = 0; x < fieldx; x++)
5988 unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5989 int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5991 if (x < MAX_LEV_FIELDX && y < MAX_LEV_FIELDY)
5992 level->field[x][y] = getMappedElement_DC(element_dc);
5995 x = MIN(MAX(0, (header[10] | (header[11] << 8)) - 1), MAX_LEV_FIELDX - 1);
5996 y = MIN(MAX(0, (header[12] | (header[13] << 8)) - 1), MAX_LEV_FIELDY - 1);
5997 level->field[x][y] = EL_PLAYER_1;
5999 x = MIN(MAX(0, (header[14] | (header[15] << 8)) - 1), MAX_LEV_FIELDX - 1);
6000 y = MIN(MAX(0, (header[16] | (header[17] << 8)) - 1), MAX_LEV_FIELDY - 1);
6001 level->field[x][y] = EL_PLAYER_2;
6003 level->gems_needed = header[18] | (header[19] << 8);
6005 level->score[SC_EMERALD] = header[20] | (header[21] << 8);
6006 level->score[SC_DIAMOND] = header[22] | (header[23] << 8);
6007 level->score[SC_PEARL] = header[24] | (header[25] << 8);
6008 level->score[SC_CRYSTAL] = header[26] | (header[27] << 8);
6009 level->score[SC_NUT] = header[28] | (header[29] << 8);
6010 level->score[SC_ROBOT] = header[30] | (header[31] << 8);
6011 level->score[SC_SPACESHIP] = header[32] | (header[33] << 8);
6012 level->score[SC_BUG] = header[34] | (header[35] << 8);
6013 level->score[SC_YAMYAM] = header[36] | (header[37] << 8);
6014 level->score[SC_DYNAMITE] = header[38] | (header[39] << 8);
6015 level->score[SC_KEY] = header[40] | (header[41] << 8);
6016 level->score[SC_TIME_BONUS] = header[42] | (header[43] << 8);
6018 level->time = header[44] | (header[45] << 8);
6020 level->amoeba_speed = header[46] | (header[47] << 8);
6021 level->time_light = header[48] | (header[49] << 8);
6022 level->time_timegate = header[50] | (header[51] << 8);
6023 level->time_wheel = header[52] | (header[53] << 8);
6024 level->time_magic_wall = header[54] | (header[55] << 8);
6025 level->extra_time = header[56] | (header[57] << 8);
6026 level->shield_normal_time = header[58] | (header[59] << 8);
6028 // shield and extra time elements do not have a score
6029 level->score[SC_SHIELD] = 0;
6030 level->extra_time_score = 0;
6032 // set time for normal and deadly shields to the same value
6033 level->shield_deadly_time = level->shield_normal_time;
6035 // Diamond Caves has the same (strange) behaviour as Emerald Mine that gems
6036 // can slip down from flat walls, like normal walls and steel walls
6037 level->em_slippery_gems = TRUE;
6039 // time score is counted for each 10 seconds left in Diamond Caves levels
6040 level->time_score_base = 10;
6043 static void LoadLevelFromFileInfo_DC(struct LevelInfo *level,
6044 struct LevelFileInfo *level_file_info,
6045 boolean level_info_only)
6047 char *filename = level_file_info->filename;
6049 int num_magic_bytes = 8;
6050 char magic_bytes[num_magic_bytes + 1];
6051 int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
6053 if (!(file = openFile(filename, MODE_READ)))
6055 level->no_valid_file = TRUE;
6057 if (!level_info_only)
6058 Warn("cannot read level '%s' -- using empty level", filename);
6063 // fseek(file, 0x0000, SEEK_SET);
6065 if (level_file_info->packed)
6067 // read "magic bytes" from start of file
6068 if (getStringFromFile(file, magic_bytes, num_magic_bytes + 1) == NULL)
6069 magic_bytes[0] = '\0';
6071 // check "magic bytes" for correct file format
6072 if (!strPrefix(magic_bytes, "DC2"))
6074 level->no_valid_file = TRUE;
6076 Warn("unknown DC level file '%s' -- using empty level", filename);
6081 if (strPrefix(magic_bytes, "DC2Win95") ||
6082 strPrefix(magic_bytes, "DC2Win98"))
6084 int position_first_level = 0x00fa;
6085 int extra_bytes = 4;
6088 // advance file stream to first level inside the level package
6089 skip_bytes = position_first_level - num_magic_bytes - extra_bytes;
6091 // each block of level data is followed by block of non-level data
6092 num_levels_to_skip *= 2;
6094 // at least skip header bytes, therefore use ">= 0" instead of "> 0"
6095 while (num_levels_to_skip >= 0)
6097 // advance file stream to next level inside the level package
6098 if (seekFile(file, skip_bytes, SEEK_CUR) != 0)
6100 level->no_valid_file = TRUE;
6102 Warn("cannot fseek in file '%s' -- using empty level", filename);
6107 // skip apparently unused extra bytes following each level
6108 ReadUnusedBytesFromFile(file, extra_bytes);
6110 // read size of next level in level package
6111 skip_bytes = getFile32BitLE(file);
6113 num_levels_to_skip--;
6118 level->no_valid_file = TRUE;
6120 Warn("unknown DC2 level file '%s' -- using empty level", filename);
6126 LoadLevelFromFileStream_DC(file, level);
6132 // ----------------------------------------------------------------------------
6133 // functions for loading SB level
6134 // ----------------------------------------------------------------------------
6136 int getMappedElement_SB(int element_ascii, boolean use_ces)
6144 sb_element_mapping[] =
6146 { ' ', EL_EMPTY, EL_CUSTOM_1 }, // floor (space)
6147 { '#', EL_STEELWALL, EL_CUSTOM_2 }, // wall
6148 { '@', EL_PLAYER_1, EL_CUSTOM_3 }, // player
6149 { '$', EL_SOKOBAN_OBJECT, EL_CUSTOM_4 }, // box
6150 { '.', EL_SOKOBAN_FIELD_EMPTY, EL_CUSTOM_5 }, // goal square
6151 { '*', EL_SOKOBAN_FIELD_FULL, EL_CUSTOM_6 }, // box on goal square
6152 { '+', EL_SOKOBAN_FIELD_PLAYER, EL_CUSTOM_7 }, // player on goal square
6153 { '_', EL_INVISIBLE_STEELWALL, EL_FROM_LEVEL_TEMPLATE }, // floor beyond border
6160 for (i = 0; sb_element_mapping[i].ascii != 0; i++)
6161 if (element_ascii == sb_element_mapping[i].ascii)
6162 return (use_ces ? sb_element_mapping[i].ce : sb_element_mapping[i].sb);
6164 return EL_UNDEFINED;
6167 static void SetLevelSettings_SB(struct LevelInfo *level)
6171 level->use_step_counter = TRUE;
6174 level->score[SC_TIME_BONUS] = 0;
6175 level->time_score_base = 1;
6176 level->rate_time_over_score = TRUE;
6179 level->auto_exit_sokoban = TRUE;
6182 static void LoadLevelFromFileInfo_SB(struct LevelInfo *level,
6183 struct LevelFileInfo *level_file_info,
6184 boolean level_info_only)
6186 char *filename = level_file_info->filename;
6187 char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
6188 char last_comment[MAX_LINE_LEN];
6189 char level_name[MAX_LINE_LEN];
6192 int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
6193 boolean read_continued_line = FALSE;
6194 boolean reading_playfield = FALSE;
6195 boolean got_valid_playfield_line = FALSE;
6196 boolean invalid_playfield_char = FALSE;
6197 boolean load_xsb_to_ces = check_special_flags("load_xsb_to_ces");
6198 int file_level_nr = 0;
6200 int x = 0, y = 0; // initialized to make compilers happy
6202 last_comment[0] = '\0';
6203 level_name[0] = '\0';
6205 if (!(file = openFile(filename, MODE_READ)))
6207 level->no_valid_file = TRUE;
6209 if (!level_info_only)
6210 Warn("cannot read level '%s' -- using empty level", filename);
6215 while (!checkEndOfFile(file))
6217 // level successfully read, but next level may follow here
6218 if (!got_valid_playfield_line && reading_playfield)
6220 // read playfield from single level file -- skip remaining file
6221 if (!level_file_info->packed)
6224 if (file_level_nr >= num_levels_to_skip)
6229 last_comment[0] = '\0';
6230 level_name[0] = '\0';
6232 reading_playfield = FALSE;
6235 got_valid_playfield_line = FALSE;
6237 // read next line of input file
6238 if (!getStringFromFile(file, line, MAX_LINE_LEN))
6241 // check if line was completely read and is terminated by line break
6242 if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
6245 // cut trailing line break (this can be newline and/or carriage return)
6246 for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
6247 if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
6250 // copy raw input line for later use (mainly debugging output)
6251 strcpy(line_raw, line);
6253 if (read_continued_line)
6255 // append new line to existing line, if there is enough space
6256 if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
6257 strcat(previous_line, line_ptr);
6259 strcpy(line, previous_line); // copy storage buffer to line
6261 read_continued_line = FALSE;
6264 // if the last character is '\', continue at next line
6265 if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
6267 line[strlen(line) - 1] = '\0'; // cut off trailing backslash
6268 strcpy(previous_line, line); // copy line to storage buffer
6270 read_continued_line = TRUE;
6276 if (line[0] == '\0')
6279 // extract comment text from comment line
6282 for (line_ptr = line; *line_ptr; line_ptr++)
6283 if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != ';')
6286 strcpy(last_comment, line_ptr);
6291 // extract level title text from line containing level title
6292 if (line[0] == '\'')
6294 strcpy(level_name, &line[1]);
6296 if (strlen(level_name) > 0 && level_name[strlen(level_name) - 1] == '\'')
6297 level_name[strlen(level_name) - 1] = '\0';
6302 // skip lines containing only spaces (or empty lines)
6303 for (line_ptr = line; *line_ptr; line_ptr++)
6304 if (*line_ptr != ' ')
6306 if (*line_ptr == '\0')
6309 // at this point, we have found a line containing part of a playfield
6311 got_valid_playfield_line = TRUE;
6313 if (!reading_playfield)
6315 reading_playfield = TRUE;
6316 invalid_playfield_char = FALSE;
6318 for (x = 0; x < MAX_LEV_FIELDX; x++)
6319 for (y = 0; y < MAX_LEV_FIELDY; y++)
6320 level->field[x][y] = getMappedElement_SB(' ', load_xsb_to_ces);
6325 // start with topmost tile row
6329 // skip playfield line if larger row than allowed
6330 if (y >= MAX_LEV_FIELDY)
6333 // start with leftmost tile column
6336 // read playfield elements from line
6337 for (line_ptr = line; *line_ptr; line_ptr++)
6339 int mapped_sb_element = getMappedElement_SB(*line_ptr, load_xsb_to_ces);
6341 // stop parsing playfield line if larger column than allowed
6342 if (x >= MAX_LEV_FIELDX)
6345 if (mapped_sb_element == EL_UNDEFINED)
6347 invalid_playfield_char = TRUE;
6352 level->field[x][y] = mapped_sb_element;
6354 // continue with next tile column
6357 level->fieldx = MAX(x, level->fieldx);
6360 if (invalid_playfield_char)
6362 // if first playfield line, treat invalid lines as comment lines
6364 reading_playfield = FALSE;
6369 // continue with next tile row
6377 level->fieldx = MIN(MAX(MIN_LEV_FIELDX, level->fieldx), MAX_LEV_FIELDX);
6378 level->fieldy = MIN(MAX(MIN_LEV_FIELDY, level->fieldy), MAX_LEV_FIELDY);
6380 if (!reading_playfield)
6382 level->no_valid_file = TRUE;
6384 Warn("cannot read level '%s' -- using empty level", filename);
6389 if (*level_name != '\0')
6391 strncpy(level->name, level_name, MAX_LEVEL_NAME_LEN);
6392 level->name[MAX_LEVEL_NAME_LEN] = '\0';
6394 else if (*last_comment != '\0')
6396 strncpy(level->name, last_comment, MAX_LEVEL_NAME_LEN);
6397 level->name[MAX_LEVEL_NAME_LEN] = '\0';
6401 sprintf(level->name, "--> Level %d <--", level_file_info->nr);
6404 // set all empty fields beyond the border walls to invisible steel wall
6405 for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
6407 if ((x == 0 || x == level->fieldx - 1 ||
6408 y == 0 || y == level->fieldy - 1) &&
6409 level->field[x][y] == getMappedElement_SB(' ', load_xsb_to_ces))
6410 FloodFillLevel(x, y, getMappedElement_SB('_', load_xsb_to_ces),
6411 level->field, level->fieldx, level->fieldy);
6414 // set special level settings for Sokoban levels
6415 SetLevelSettings_SB(level);
6417 if (load_xsb_to_ces)
6419 // special global settings can now be set in level template
6420 level->use_custom_template = TRUE;
6425 // -------------------------------------------------------------------------
6426 // functions for handling native levels
6427 // -------------------------------------------------------------------------
6429 static void LoadLevelFromFileInfo_BD(struct LevelInfo *level,
6430 struct LevelFileInfo *level_file_info,
6431 boolean level_info_only)
6435 // determine position of requested level inside level package
6436 if (level_file_info->packed)
6437 pos = level_file_info->nr - leveldir_current->first_level;
6439 if (!LoadNativeLevel_BD(level_file_info->filename, pos, level_info_only))
6440 level->no_valid_file = TRUE;
6443 static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
6444 struct LevelFileInfo *level_file_info,
6445 boolean level_info_only)
6447 if (!LoadNativeLevel_EM(level_file_info->filename, level_info_only))
6448 level->no_valid_file = TRUE;
6451 static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
6452 struct LevelFileInfo *level_file_info,
6453 boolean level_info_only)
6457 // determine position of requested level inside level package
6458 if (level_file_info->packed)
6459 pos = level_file_info->nr - leveldir_current->first_level;
6461 if (!LoadNativeLevel_SP(level_file_info->filename, pos, level_info_only))
6462 level->no_valid_file = TRUE;
6465 static void LoadLevelFromFileInfo_MM(struct LevelInfo *level,
6466 struct LevelFileInfo *level_file_info,
6467 boolean level_info_only)
6469 if (!LoadNativeLevel_MM(level_file_info->filename, level_info_only))
6470 level->no_valid_file = TRUE;
6473 void CopyNativeLevel_RND_to_Native(struct LevelInfo *level)
6475 if (level->game_engine_type == GAME_ENGINE_TYPE_BD)
6476 CopyNativeLevel_RND_to_BD(level);
6477 else if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
6478 CopyNativeLevel_RND_to_EM(level);
6479 else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
6480 CopyNativeLevel_RND_to_SP(level);
6481 else if (level->game_engine_type == GAME_ENGINE_TYPE_MM)
6482 CopyNativeLevel_RND_to_MM(level);
6485 void CopyNativeLevel_Native_to_RND(struct LevelInfo *level)
6487 if (level->game_engine_type == GAME_ENGINE_TYPE_BD)
6488 CopyNativeLevel_BD_to_RND(level);
6489 else if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
6490 CopyNativeLevel_EM_to_RND(level);
6491 else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
6492 CopyNativeLevel_SP_to_RND(level);
6493 else if (level->game_engine_type == GAME_ENGINE_TYPE_MM)
6494 CopyNativeLevel_MM_to_RND(level);
6497 void SaveNativeLevel(struct LevelInfo *level)
6499 if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
6501 char *basename = getSingleLevelBasenameExt(level->file_info.nr, "sp");
6502 char *filename = getLevelFilenameFromBasename(basename);
6504 CopyNativeLevel_RND_to_SP(level);
6505 CopyNativeTape_RND_to_SP(level);
6507 SaveNativeLevel_SP(filename);
6512 // ----------------------------------------------------------------------------
6513 // functions for loading generic level
6514 // ----------------------------------------------------------------------------
6516 static void LoadLevelFromFileInfo(struct LevelInfo *level,
6517 struct LevelFileInfo *level_file_info,
6518 boolean level_info_only)
6520 // always start with reliable default values
6521 setLevelInfoToDefaults(level, level_info_only, TRUE);
6523 switch (level_file_info->type)
6525 case LEVEL_FILE_TYPE_RND:
6526 LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
6529 case LEVEL_FILE_TYPE_BD:
6530 LoadLevelFromFileInfo_BD(level, level_file_info, level_info_only);
6531 level->game_engine_type = GAME_ENGINE_TYPE_BD;
6534 case LEVEL_FILE_TYPE_EM:
6535 LoadLevelFromFileInfo_EM(level, level_file_info, level_info_only);
6536 level->game_engine_type = GAME_ENGINE_TYPE_EM;
6539 case LEVEL_FILE_TYPE_SP:
6540 LoadLevelFromFileInfo_SP(level, level_file_info, level_info_only);
6541 level->game_engine_type = GAME_ENGINE_TYPE_SP;
6544 case LEVEL_FILE_TYPE_MM:
6545 LoadLevelFromFileInfo_MM(level, level_file_info, level_info_only);
6546 level->game_engine_type = GAME_ENGINE_TYPE_MM;
6549 case LEVEL_FILE_TYPE_DC:
6550 LoadLevelFromFileInfo_DC(level, level_file_info, level_info_only);
6553 case LEVEL_FILE_TYPE_SB:
6554 LoadLevelFromFileInfo_SB(level, level_file_info, level_info_only);
6558 LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
6562 // if level file is invalid, restore level structure to default values
6563 if (level->no_valid_file)
6564 setLevelInfoToDefaults(level, level_info_only, FALSE);
6566 if (level->game_engine_type == GAME_ENGINE_TYPE_UNKNOWN)
6567 level->game_engine_type = GAME_ENGINE_TYPE_RND;
6569 if (level_file_info->type != LEVEL_FILE_TYPE_RND)
6570 CopyNativeLevel_Native_to_RND(level);
6573 void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
6575 static struct LevelFileInfo level_file_info;
6577 // always start with reliable default values
6578 setFileInfoToDefaults(&level_file_info);
6580 level_file_info.nr = 0; // unknown level number
6581 level_file_info.type = LEVEL_FILE_TYPE_RND; // no others supported yet
6583 setString(&level_file_info.filename, filename);
6585 LoadLevelFromFileInfo(level, &level_file_info, FALSE);
6588 static void LoadLevel_InitVersion(struct LevelInfo *level)
6592 if (leveldir_current == NULL) // only when dumping level
6595 // all engine modifications also valid for levels which use latest engine
6596 if (level->game_version < VERSION_IDENT(3,2,0,5))
6598 // time bonus score was given for 10 s instead of 1 s before 3.2.0-5
6599 level->time_score_base = 10;
6602 if (leveldir_current->latest_engine)
6604 // ---------- use latest game engine --------------------------------------
6606 /* For all levels which are forced to use the latest game engine version
6607 (normally all but user contributed, private and undefined levels), set
6608 the game engine version to the actual version; this allows for actual
6609 corrections in the game engine to take effect for existing, converted
6610 levels (from "classic" or other existing games) to make the emulation
6611 of the corresponding game more accurate, while (hopefully) not breaking
6612 existing levels created from other players. */
6614 level->game_version = GAME_VERSION_ACTUAL;
6616 /* Set special EM style gems behaviour: EM style gems slip down from
6617 normal, steel and growing wall. As this is a more fundamental change,
6618 it seems better to set the default behaviour to "off" (as it is more
6619 natural) and make it configurable in the level editor (as a property
6620 of gem style elements). Already existing converted levels (neither
6621 private nor contributed levels) are changed to the new behaviour. */
6623 if (level->file_version < FILE_VERSION_2_0)
6624 level->em_slippery_gems = TRUE;
6629 // ---------- use game engine the level was created with --------------------
6631 /* For all levels which are not forced to use the latest game engine
6632 version (normally user contributed, private and undefined levels),
6633 use the version of the game engine the levels were created for.
6635 Since 2.0.1, the game engine version is now directly stored
6636 in the level file (chunk "VERS"), so there is no need anymore
6637 to set the game version from the file version (except for old,
6638 pre-2.0 levels, where the game version is still taken from the
6639 file format version used to store the level -- see above). */
6641 // player was faster than enemies in 1.0.0 and before
6642 if (level->file_version == FILE_VERSION_1_0)
6643 for (i = 0; i < MAX_PLAYERS; i++)
6644 level->initial_player_stepsize[i] = STEPSIZE_FAST;
6646 // default behaviour for EM style gems was "slippery" only in 2.0.1
6647 if (level->game_version == VERSION_IDENT(2,0,1,0))
6648 level->em_slippery_gems = TRUE;
6650 // springs could be pushed over pits before (pre-release version) 2.2.0
6651 if (level->game_version < VERSION_IDENT(2,2,0,0))
6652 level->use_spring_bug = TRUE;
6654 if (level->game_version < VERSION_IDENT(3,2,0,5))
6656 // time orb caused limited time in endless time levels before 3.2.0-5
6657 level->use_time_orb_bug = TRUE;
6659 // default behaviour for snapping was "no snap delay" before 3.2.0-5
6660 level->block_snap_field = FALSE;
6662 // extra time score was same value as time left score before 3.2.0-5
6663 level->extra_time_score = level->score[SC_TIME_BONUS];
6666 if (level->game_version < VERSION_IDENT(3,2,0,7))
6668 // default behaviour for snapping was "not continuous" before 3.2.0-7
6669 level->continuous_snapping = FALSE;
6672 // only few elements were able to actively move into acid before 3.1.0
6673 // trigger settings did not exist before 3.1.0; set to default "any"
6674 if (level->game_version < VERSION_IDENT(3,1,0,0))
6676 // correct "can move into acid" settings (all zero in old levels)
6678 level->can_move_into_acid_bits = 0; // nothing can move into acid
6679 level->dont_collide_with_bits = 0; // nothing is deadly when colliding
6681 setMoveIntoAcidProperty(level, EL_ROBOT, TRUE);
6682 setMoveIntoAcidProperty(level, EL_SATELLITE, TRUE);
6683 setMoveIntoAcidProperty(level, EL_PENGUIN, TRUE);
6684 setMoveIntoAcidProperty(level, EL_BALLOON, TRUE);
6686 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6687 SET_PROPERTY(EL_CUSTOM_START + i, EP_CAN_MOVE_INTO_ACID, TRUE);
6689 // correct trigger settings (stored as zero == "none" in old levels)
6691 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6693 int element = EL_CUSTOM_START + i;
6694 struct ElementInfo *ei = &element_info[element];
6696 for (j = 0; j < ei->num_change_pages; j++)
6698 struct ElementChangeInfo *change = &ei->change_page[j];
6700 change->trigger_player = CH_PLAYER_ANY;
6701 change->trigger_page = CH_PAGE_ANY;
6706 // try to detect and fix "Snake Bite" levels, which are broken with 3.2.0
6708 int element = EL_CUSTOM_256;
6709 struct ElementInfo *ei = &element_info[element];
6710 struct ElementChangeInfo *change = &ei->change_page[0];
6712 /* This is needed to fix a problem that was caused by a bugfix in function
6713 game.c/CreateFieldExt() introduced with 3.2.0 that corrects the behaviour
6714 when a custom element changes to EL_SOKOBAN_FIELD_PLAYER (before, it did
6715 not replace walkable elements, but instead just placed the player on it,
6716 without placing the Sokoban field under the player). Unfortunately, this
6717 breaks "Snake Bite" style levels when the snake is halfway through a door
6718 that just closes (the snake head is still alive and can be moved in this
6719 case). This can be fixed by replacing the EL_SOKOBAN_FIELD_PLAYER by the
6720 player (without Sokoban element) which then gets killed as designed). */
6722 if ((strncmp(leveldir_current->identifier, "snake_bite", 10) == 0 ||
6723 strncmp(ei->description, "pause b4 death", 14) == 0) &&
6724 change->target_element == EL_SOKOBAN_FIELD_PLAYER)
6725 change->target_element = EL_PLAYER_1;
6728 // try to detect and fix "Zelda" style levels, which are broken with 3.2.5
6729 if (level->game_version < VERSION_IDENT(3,2,5,0))
6731 /* This is needed to fix a problem that was caused by a bugfix in function
6732 game.c/CheckTriggeredElementChangeExt() introduced with 3.2.5 that
6733 corrects the behaviour when a custom element changes to another custom
6734 element with a higher element number that has change actions defined.
6735 Normally, only one change per frame is allowed for custom elements.
6736 Therefore, it is checked if a custom element already changed in the
6737 current frame; if it did, subsequent changes are suppressed.
6738 Unfortunately, this is only checked for element changes, but not for
6739 change actions, which are still executed. As the function above loops
6740 through all custom elements from lower to higher, an element change
6741 resulting in a lower CE number won't be checked again, while a target
6742 element with a higher number will also be checked, and potential change
6743 actions will get executed for this CE, too (which is wrong), while
6744 further changes are ignored (which is correct). As this bugfix breaks
6745 Zelda II (and introduces graphical bugs to Zelda I, and also breaks a
6746 few other levels like Alan Bond's "FMV"), allow the previous, incorrect
6747 behaviour for existing levels and tapes that make use of this bug */
6749 level->use_action_after_change_bug = TRUE;
6752 // not centering level after relocating player was default only in 3.2.3
6753 if (level->game_version == VERSION_IDENT(3,2,3,0)) // (no pre-releases)
6754 level->shifted_relocation = TRUE;
6756 // EM style elements always chain-exploded in R'n'D engine before 3.2.6
6757 if (level->game_version < VERSION_IDENT(3,2,6,0))
6758 level->em_explodes_by_fire = TRUE;
6760 // levels were solved by the first player entering an exit up to 4.1.0.0
6761 if (level->game_version <= VERSION_IDENT(4,1,0,0))
6762 level->solved_by_one_player = TRUE;
6764 // game logic of "game of life" and "biomaze" was buggy before 4.1.1.1
6765 if (level->game_version < VERSION_IDENT(4,1,1,1))
6766 level->use_life_bugs = TRUE;
6768 // only Sokoban fields (but not objects) had to be solved before 4.1.1.1
6769 if (level->game_version < VERSION_IDENT(4,1,1,1))
6770 level->sb_objects_needed = FALSE;
6772 // CE actions were triggered by unfinished digging/collecting up to 4.2.2.0
6773 if (level->game_version <= VERSION_IDENT(4,2,2,0))
6774 level->finish_dig_collect = FALSE;
6776 // CE changing to player was kept under the player if walkable up to 4.2.3.1
6777 if (level->game_version <= VERSION_IDENT(4,2,3,1))
6778 level->keep_walkable_ce = TRUE;
6781 static void LoadLevel_InitSettings_SB(struct LevelInfo *level)
6783 boolean is_sokoban_level = TRUE; // unless non-Sokoban elements found
6786 // check if this level is (not) a Sokoban level
6787 for (y = 0; y < level->fieldy; y++)
6788 for (x = 0; x < level->fieldx; x++)
6789 if (!IS_SB_ELEMENT(Tile[x][y]))
6790 is_sokoban_level = FALSE;
6792 if (is_sokoban_level)
6794 // set special level settings for Sokoban levels
6795 SetLevelSettings_SB(level);
6799 static void LoadLevel_InitSettings(struct LevelInfo *level)
6801 // adjust level settings for (non-native) Sokoban-style levels
6802 LoadLevel_InitSettings_SB(level);
6804 // rename levels with title "nameless level" or if renaming is forced
6805 if (leveldir_current->empty_level_name != NULL &&
6806 (strEqual(level->name, NAMELESS_LEVEL_NAME) ||
6807 leveldir_current->force_level_name))
6808 snprintf(level->name, MAX_LEVEL_NAME_LEN + 1,
6809 leveldir_current->empty_level_name, level_nr);
6812 static void LoadLevel_InitStandardElements(struct LevelInfo *level)
6816 // map elements that have changed in newer versions
6817 level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
6818 level->game_version);
6819 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6820 for (x = 0; x < 3; x++)
6821 for (y = 0; y < 3; y++)
6822 level->yamyam_content[i].e[x][y] =
6823 getMappedElementByVersion(level->yamyam_content[i].e[x][y],
6824 level->game_version);
6828 static void LoadLevel_InitCustomElements(struct LevelInfo *level)
6832 // map custom element change events that have changed in newer versions
6833 // (these following values were accidentally changed in version 3.0.1)
6834 // (this seems to be needed only for 'ab_levelset3' and 'ab_levelset4')
6835 if (level->game_version <= VERSION_IDENT(3,0,0,0))
6837 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6839 int element = EL_CUSTOM_START + i;
6841 // order of checking and copying events to be mapped is important
6842 // (do not change the start and end value -- they are constant)
6843 for (j = CE_BY_OTHER_ACTION; j >= CE_VALUE_GETS_ZERO; j--)
6845 if (HAS_CHANGE_EVENT(element, j - 2))
6847 SET_CHANGE_EVENT(element, j - 2, FALSE);
6848 SET_CHANGE_EVENT(element, j, TRUE);
6852 // order of checking and copying events to be mapped is important
6853 // (do not change the start and end value -- they are constant)
6854 for (j = CE_PLAYER_COLLECTS_X; j >= CE_HITTING_SOMETHING; j--)
6856 if (HAS_CHANGE_EVENT(element, j - 1))
6858 SET_CHANGE_EVENT(element, j - 1, FALSE);
6859 SET_CHANGE_EVENT(element, j, TRUE);
6865 // initialize "can_change" field for old levels with only one change page
6866 if (level->game_version <= VERSION_IDENT(3,0,2,0))
6868 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6870 int element = EL_CUSTOM_START + i;
6872 if (CAN_CHANGE(element))
6873 element_info[element].change->can_change = TRUE;
6877 // correct custom element values (for old levels without these options)
6878 if (level->game_version < VERSION_IDENT(3,1,1,0))
6880 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6882 int element = EL_CUSTOM_START + i;
6883 struct ElementInfo *ei = &element_info[element];
6885 if (ei->access_direction == MV_NO_DIRECTION)
6886 ei->access_direction = MV_ALL_DIRECTIONS;
6890 // correct custom element values (fix invalid values for all versions)
6893 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6895 int element = EL_CUSTOM_START + i;
6896 struct ElementInfo *ei = &element_info[element];
6898 for (j = 0; j < ei->num_change_pages; j++)
6900 struct ElementChangeInfo *change = &ei->change_page[j];
6902 if (change->trigger_player == CH_PLAYER_NONE)
6903 change->trigger_player = CH_PLAYER_ANY;
6905 if (change->trigger_side == CH_SIDE_NONE)
6906 change->trigger_side = CH_SIDE_ANY;
6911 // initialize "can_explode" field for old levels which did not store this
6912 // !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!!
6913 if (level->game_version <= VERSION_IDENT(3,1,0,0))
6915 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6917 int element = EL_CUSTOM_START + i;
6919 if (EXPLODES_1X1_OLD(element))
6920 element_info[element].explosion_type = EXPLODES_1X1;
6922 SET_PROPERTY(element, EP_CAN_EXPLODE, (EXPLODES_BY_FIRE(element) ||
6923 EXPLODES_SMASHED(element) ||
6924 EXPLODES_IMPACT(element)));
6928 // correct previously hard-coded move delay values for maze runner style
6929 if (level->game_version < VERSION_IDENT(3,1,1,0))
6931 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6933 int element = EL_CUSTOM_START + i;
6935 if (element_info[element].move_pattern & MV_MAZE_RUNNER_STYLE)
6937 // previously hard-coded and therefore ignored
6938 element_info[element].move_delay_fixed = 9;
6939 element_info[element].move_delay_random = 0;
6944 // set some other uninitialized values of custom elements in older levels
6945 if (level->game_version < VERSION_IDENT(3,1,0,0))
6947 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6949 int element = EL_CUSTOM_START + i;
6951 element_info[element].access_direction = MV_ALL_DIRECTIONS;
6953 element_info[element].explosion_delay = 17;
6954 element_info[element].ignition_delay = 8;
6958 // set mouse click change events to work for left/middle/right mouse button
6959 if (level->game_version < VERSION_IDENT(4,2,3,0))
6961 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6963 int element = EL_CUSTOM_START + i;
6964 struct ElementInfo *ei = &element_info[element];
6966 for (j = 0; j < ei->num_change_pages; j++)
6968 struct ElementChangeInfo *change = &ei->change_page[j];
6970 if (change->has_event[CE_CLICKED_BY_MOUSE] ||
6971 change->has_event[CE_PRESSED_BY_MOUSE] ||
6972 change->has_event[CE_MOUSE_CLICKED_ON_X] ||
6973 change->has_event[CE_MOUSE_PRESSED_ON_X])
6974 change->trigger_side = CH_SIDE_ANY;
6980 static void LoadLevel_InitElements(struct LevelInfo *level)
6982 LoadLevel_InitStandardElements(level);
6984 if (level->file_has_custom_elements)
6985 LoadLevel_InitCustomElements(level);
6987 // initialize element properties for level editor etc.
6988 InitElementPropertiesEngine(level->game_version);
6989 InitElementPropertiesGfxElement();
6992 static void LoadLevel_InitPlayfield(struct LevelInfo *level)
6996 // map elements that have changed in newer versions
6997 for (y = 0; y < level->fieldy; y++)
6998 for (x = 0; x < level->fieldx; x++)
6999 level->field[x][y] = getMappedElementByVersion(level->field[x][y],
7000 level->game_version);
7002 // clear unused playfield data (nicer if level gets resized in editor)
7003 for (x = 0; x < MAX_LEV_FIELDX; x++)
7004 for (y = 0; y < MAX_LEV_FIELDY; y++)
7005 if (x >= level->fieldx || y >= level->fieldy)
7006 level->field[x][y] = EL_EMPTY;
7008 // copy elements to runtime playfield array
7009 for (x = 0; x < MAX_LEV_FIELDX; x++)
7010 for (y = 0; y < MAX_LEV_FIELDY; y++)
7011 Tile[x][y] = level->field[x][y];
7013 // initialize level size variables for faster access
7014 lev_fieldx = level->fieldx;
7015 lev_fieldy = level->fieldy;
7017 // determine border element for this level
7018 if (level->file_info.type == LEVEL_FILE_TYPE_DC)
7019 BorderElement = EL_EMPTY; // (in editor, SetBorderElement() is used)
7024 static void LoadLevel_InitNativeEngines(struct LevelInfo *level)
7026 struct LevelFileInfo *level_file_info = &level->file_info;
7028 if (level_file_info->type == LEVEL_FILE_TYPE_RND)
7029 CopyNativeLevel_RND_to_Native(level);
7032 static void LoadLevelTemplate_LoadAndInit(void)
7034 LoadLevelFromFileInfo(&level_template, &level_template.file_info, FALSE);
7036 LoadLevel_InitVersion(&level_template);
7037 LoadLevel_InitElements(&level_template);
7038 LoadLevel_InitSettings(&level_template);
7040 ActivateLevelTemplate();
7043 void LoadLevelTemplate(int nr)
7045 if (!fileExists(getGlobalLevelTemplateFilename()))
7047 Warn("no level template found for this level");
7052 setLevelFileInfo(&level_template.file_info, nr);
7054 LoadLevelTemplate_LoadAndInit();
7057 static void LoadNetworkLevelTemplate(struct NetworkLevelInfo *network_level)
7059 copyLevelFileInfo(&network_level->tmpl_info, &level_template.file_info);
7061 LoadLevelTemplate_LoadAndInit();
7064 static void LoadLevel_LoadAndInit(struct NetworkLevelInfo *network_level)
7066 LoadLevelFromFileInfo(&level, &level.file_info, FALSE);
7068 if (level.use_custom_template)
7070 if (network_level != NULL)
7071 LoadNetworkLevelTemplate(network_level);
7073 LoadLevelTemplate(-1);
7076 LoadLevel_InitVersion(&level);
7077 LoadLevel_InitElements(&level);
7078 LoadLevel_InitPlayfield(&level);
7079 LoadLevel_InitSettings(&level);
7081 LoadLevel_InitNativeEngines(&level);
7084 void LoadLevel(int nr)
7086 SetLevelSetInfo(leveldir_current->identifier, nr);
7088 setLevelFileInfo(&level.file_info, nr);
7090 LoadLevel_LoadAndInit(NULL);
7093 void LoadLevelInfoOnly(int nr)
7095 setLevelFileInfo(&level.file_info, nr);
7097 LoadLevelFromFileInfo(&level, &level.file_info, TRUE);
7100 void LoadNetworkLevel(struct NetworkLevelInfo *network_level)
7102 SetLevelSetInfo(network_level->leveldir_identifier,
7103 network_level->file_info.nr);
7105 copyLevelFileInfo(&network_level->file_info, &level.file_info);
7107 LoadLevel_LoadAndInit(network_level);
7110 static int SaveLevel_VERS(FILE *file, struct LevelInfo *level)
7114 chunk_size += putFileVersion(file, level->file_version);
7115 chunk_size += putFileVersion(file, level->game_version);
7120 static int SaveLevel_DATE(FILE *file, struct LevelInfo *level)
7124 chunk_size += putFile16BitBE(file, level->creation_date.year);
7125 chunk_size += putFile8Bit(file, level->creation_date.month);
7126 chunk_size += putFile8Bit(file, level->creation_date.day);
7131 #if ENABLE_HISTORIC_CHUNKS
7132 static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
7136 putFile8Bit(file, level->fieldx);
7137 putFile8Bit(file, level->fieldy);
7139 putFile16BitBE(file, level->time);
7140 putFile16BitBE(file, level->gems_needed);
7142 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
7143 putFile8Bit(file, level->name[i]);
7145 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
7146 putFile8Bit(file, level->score[i]);
7148 for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
7149 for (y = 0; y < 3; y++)
7150 for (x = 0; x < 3; x++)
7151 putFile8Bit(file, (level->encoding_16bit_yamyam ? EL_EMPTY :
7152 level->yamyam_content[i].e[x][y]));
7153 putFile8Bit(file, level->amoeba_speed);
7154 putFile8Bit(file, level->time_magic_wall);
7155 putFile8Bit(file, level->time_wheel);
7156 putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
7157 level->amoeba_content));
7158 putFile8Bit(file, (level->initial_player_stepsize == STEPSIZE_FAST ? 1 : 0));
7159 putFile8Bit(file, (level->initial_gravity ? 1 : 0));
7160 putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
7161 putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
7163 putFile8Bit(file, (level->use_custom_template ? 1 : 0));
7165 putFile8Bit(file, (level->block_last_field ? 1 : 0));
7166 putFile8Bit(file, (level->sp_block_last_field ? 1 : 0));
7167 putFile32BitBE(file, level->can_move_into_acid_bits);
7168 putFile8Bit(file, level->dont_collide_with_bits);
7170 putFile8Bit(file, (level->use_spring_bug ? 1 : 0));
7171 putFile8Bit(file, (level->use_step_counter ? 1 : 0));
7173 putFile8Bit(file, (level->instant_relocation ? 1 : 0));
7174 putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
7175 putFile8Bit(file, (level->grow_into_diggable ? 1 : 0));
7177 putFile8Bit(file, level->game_engine_type);
7179 WriteUnusedBytesToFile(file, LEVEL_CHUNK_HEAD_UNUSED);
7183 static int SaveLevel_NAME(FILE *file, struct LevelInfo *level)
7188 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
7189 chunk_size += putFile8Bit(file, level->name[i]);
7194 static int SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
7199 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
7200 chunk_size += putFile8Bit(file, level->author[i]);
7205 #if ENABLE_HISTORIC_CHUNKS
7206 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
7211 for (y = 0; y < level->fieldy; y++)
7212 for (x = 0; x < level->fieldx; x++)
7213 if (level->encoding_16bit_field)
7214 chunk_size += putFile16BitBE(file, level->field[x][y]);
7216 chunk_size += putFile8Bit(file, level->field[x][y]);
7222 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
7227 for (y = 0; y < level->fieldy; y++)
7228 for (x = 0; x < level->fieldx; x++)
7229 chunk_size += putFile16BitBE(file, level->field[x][y]);
7234 #if ENABLE_HISTORIC_CHUNKS
7235 static void SaveLevel_CONT(FILE *file, struct LevelInfo *level)
7239 putFile8Bit(file, EL_YAMYAM);
7240 putFile8Bit(file, level->num_yamyam_contents);
7241 putFile8Bit(file, 0);
7242 putFile8Bit(file, 0);
7244 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
7245 for (y = 0; y < 3; y++)
7246 for (x = 0; x < 3; x++)
7247 if (level->encoding_16bit_field)
7248 putFile16BitBE(file, level->yamyam_content[i].e[x][y]);
7250 putFile8Bit(file, level->yamyam_content[i].e[x][y]);
7254 #if ENABLE_HISTORIC_CHUNKS
7255 static void SaveLevel_CNT2(FILE *file, struct LevelInfo *level, int element)
7258 int num_contents, content_xsize, content_ysize;
7259 int content_array[MAX_ELEMENT_CONTENTS][3][3];
7261 if (element == EL_YAMYAM)
7263 num_contents = level->num_yamyam_contents;
7267 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
7268 for (y = 0; y < 3; y++)
7269 for (x = 0; x < 3; x++)
7270 content_array[i][x][y] = level->yamyam_content[i].e[x][y];
7272 else if (element == EL_BD_AMOEBA)
7278 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
7279 for (y = 0; y < 3; y++)
7280 for (x = 0; x < 3; x++)
7281 content_array[i][x][y] = EL_EMPTY;
7282 content_array[0][0][0] = level->amoeba_content;
7286 // chunk header already written -- write empty chunk data
7287 WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
7289 Warn("cannot save content for element '%d'", element);
7294 putFile16BitBE(file, element);
7295 putFile8Bit(file, num_contents);
7296 putFile8Bit(file, content_xsize);
7297 putFile8Bit(file, content_ysize);
7299 WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
7301 for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
7302 for (y = 0; y < 3; y++)
7303 for (x = 0; x < 3; x++)
7304 putFile16BitBE(file, content_array[i][x][y]);
7308 #if ENABLE_HISTORIC_CHUNKS
7309 static int SaveLevel_CNT3(FILE *file, struct LevelInfo *level, int element)
7311 int envelope_nr = element - EL_ENVELOPE_1;
7312 int envelope_len = strlen(level->envelope_text[envelope_nr]) + 1;
7316 chunk_size += putFile16BitBE(file, element);
7317 chunk_size += putFile16BitBE(file, envelope_len);
7318 chunk_size += putFile8Bit(file, level->envelope_xsize[envelope_nr]);
7319 chunk_size += putFile8Bit(file, level->envelope_ysize[envelope_nr]);
7321 WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT3_UNUSED);
7322 chunk_size += LEVEL_CHUNK_CNT3_UNUSED;
7324 for (i = 0; i < envelope_len; i++)
7325 chunk_size += putFile8Bit(file, level->envelope_text[envelope_nr][i]);
7331 #if ENABLE_HISTORIC_CHUNKS
7332 static void SaveLevel_CUS1(FILE *file, struct LevelInfo *level,
7333 int num_changed_custom_elements)
7337 putFile16BitBE(file, num_changed_custom_elements);
7339 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7341 int element = EL_CUSTOM_START + i;
7343 struct ElementInfo *ei = &element_info[element];
7345 if (ei->properties[EP_BITFIELD_BASE_NR] != EP_BITMASK_DEFAULT)
7347 if (check < num_changed_custom_elements)
7349 putFile16BitBE(file, element);
7350 putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
7357 if (check != num_changed_custom_elements) // should not happen
7358 Warn("inconsistent number of custom element properties");
7362 #if ENABLE_HISTORIC_CHUNKS
7363 static void SaveLevel_CUS2(FILE *file, struct LevelInfo *level,
7364 int num_changed_custom_elements)
7368 putFile16BitBE(file, num_changed_custom_elements);
7370 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7372 int element = EL_CUSTOM_START + i;
7374 if (element_info[element].change->target_element != EL_EMPTY_SPACE)
7376 if (check < num_changed_custom_elements)
7378 putFile16BitBE(file, element);
7379 putFile16BitBE(file, element_info[element].change->target_element);
7386 if (check != num_changed_custom_elements) // should not happen
7387 Warn("inconsistent number of custom target elements");
7391 #if ENABLE_HISTORIC_CHUNKS
7392 static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
7393 int num_changed_custom_elements)
7395 int i, j, x, y, check = 0;
7397 putFile16BitBE(file, num_changed_custom_elements);
7399 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7401 int element = EL_CUSTOM_START + i;
7402 struct ElementInfo *ei = &element_info[element];
7404 if (ei->modified_settings)
7406 if (check < num_changed_custom_elements)
7408 putFile16BitBE(file, element);
7410 for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
7411 putFile8Bit(file, ei->description[j]);
7413 putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
7415 // some free bytes for future properties and padding
7416 WriteUnusedBytesToFile(file, 7);
7418 putFile8Bit(file, ei->use_gfx_element);
7419 putFile16BitBE(file, ei->gfx_element_initial);
7421 putFile8Bit(file, ei->collect_score_initial);
7422 putFile8Bit(file, ei->collect_count_initial);
7424 putFile16BitBE(file, ei->push_delay_fixed);
7425 putFile16BitBE(file, ei->push_delay_random);
7426 putFile16BitBE(file, ei->move_delay_fixed);
7427 putFile16BitBE(file, ei->move_delay_random);
7429 putFile16BitBE(file, ei->move_pattern);
7430 putFile8Bit(file, ei->move_direction_initial);
7431 putFile8Bit(file, ei->move_stepsize);
7433 for (y = 0; y < 3; y++)
7434 for (x = 0; x < 3; x++)
7435 putFile16BitBE(file, ei->content.e[x][y]);
7437 putFile32BitBE(file, ei->change->events);
7439 putFile16BitBE(file, ei->change->target_element);
7441 putFile16BitBE(file, ei->change->delay_fixed);
7442 putFile16BitBE(file, ei->change->delay_random);
7443 putFile16BitBE(file, ei->change->delay_frames);
7445 putFile16BitBE(file, ei->change->initial_trigger_element);
7447 putFile8Bit(file, ei->change->explode);
7448 putFile8Bit(file, ei->change->use_target_content);
7449 putFile8Bit(file, ei->change->only_if_complete);
7450 putFile8Bit(file, ei->change->use_random_replace);
7452 putFile8Bit(file, ei->change->random_percentage);
7453 putFile8Bit(file, ei->change->replace_when);
7455 for (y = 0; y < 3; y++)
7456 for (x = 0; x < 3; x++)
7457 putFile16BitBE(file, ei->change->content.e[x][y]);
7459 putFile8Bit(file, ei->slippery_type);
7461 // some free bytes for future properties and padding
7462 WriteUnusedBytesToFile(file, LEVEL_CPART_CUS3_UNUSED);
7469 if (check != num_changed_custom_elements) // should not happen
7470 Warn("inconsistent number of custom element properties");
7474 #if ENABLE_HISTORIC_CHUNKS
7475 static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
7477 struct ElementInfo *ei = &element_info[element];
7480 // ---------- custom element base property values (96 bytes) ----------------
7482 putFile16BitBE(file, element);
7484 for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
7485 putFile8Bit(file, ei->description[i]);
7487 putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
7489 WriteUnusedBytesToFile(file, 4); // reserved for more base properties
7491 putFile8Bit(file, ei->num_change_pages);
7493 putFile16BitBE(file, ei->ce_value_fixed_initial);
7494 putFile16BitBE(file, ei->ce_value_random_initial);
7495 putFile8Bit(file, ei->use_last_ce_value);
7497 putFile8Bit(file, ei->use_gfx_element);
7498 putFile16BitBE(file, ei->gfx_element_initial);
7500 putFile8Bit(file, ei->collect_score_initial);
7501 putFile8Bit(file, ei->collect_count_initial);
7503 putFile8Bit(file, ei->drop_delay_fixed);
7504 putFile8Bit(file, ei->push_delay_fixed);
7505 putFile8Bit(file, ei->drop_delay_random);
7506 putFile8Bit(file, ei->push_delay_random);
7507 putFile16BitBE(file, ei->move_delay_fixed);
7508 putFile16BitBE(file, ei->move_delay_random);
7510 // bits 0 - 15 of "move_pattern" ...
7511 putFile16BitBE(file, ei->move_pattern & 0xffff);
7512 putFile8Bit(file, ei->move_direction_initial);
7513 putFile8Bit(file, ei->move_stepsize);
7515 putFile8Bit(file, ei->slippery_type);
7517 for (y = 0; y < 3; y++)
7518 for (x = 0; x < 3; x++)
7519 putFile16BitBE(file, ei->content.e[x][y]);
7521 putFile16BitBE(file, ei->move_enter_element);
7522 putFile16BitBE(file, ei->move_leave_element);
7523 putFile8Bit(file, ei->move_leave_type);
7525 // ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible)
7526 putFile16BitBE(file, (ei->move_pattern >> 16) & 0xffff);
7528 putFile8Bit(file, ei->access_direction);
7530 putFile8Bit(file, ei->explosion_delay);
7531 putFile8Bit(file, ei->ignition_delay);
7532 putFile8Bit(file, ei->explosion_type);
7534 // some free bytes for future custom property values and padding
7535 WriteUnusedBytesToFile(file, 1);
7537 // ---------- change page property values (48 bytes) ------------------------
7539 for (i = 0; i < ei->num_change_pages; i++)
7541 struct ElementChangeInfo *change = &ei->change_page[i];
7542 unsigned int event_bits;
7544 // bits 0 - 31 of "has_event[]" ...
7546 for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
7547 if (change->has_event[j])
7548 event_bits |= (1u << j);
7549 putFile32BitBE(file, event_bits);
7551 putFile16BitBE(file, change->target_element);
7553 putFile16BitBE(file, change->delay_fixed);
7554 putFile16BitBE(file, change->delay_random);
7555 putFile16BitBE(file, change->delay_frames);
7557 putFile16BitBE(file, change->initial_trigger_element);
7559 putFile8Bit(file, change->explode);
7560 putFile8Bit(file, change->use_target_content);
7561 putFile8Bit(file, change->only_if_complete);
7562 putFile8Bit(file, change->use_random_replace);
7564 putFile8Bit(file, change->random_percentage);
7565 putFile8Bit(file, change->replace_when);
7567 for (y = 0; y < 3; y++)
7568 for (x = 0; x < 3; x++)
7569 putFile16BitBE(file, change->target_content.e[x][y]);
7571 putFile8Bit(file, change->can_change);
7573 putFile8Bit(file, change->trigger_side);
7575 putFile8Bit(file, change->trigger_player);
7576 putFile8Bit(file, (change->trigger_page == CH_PAGE_ANY ? CH_PAGE_ANY_FILE :
7577 log_2(change->trigger_page)));
7579 putFile8Bit(file, change->has_action);
7580 putFile8Bit(file, change->action_type);
7581 putFile8Bit(file, change->action_mode);
7582 putFile16BitBE(file, change->action_arg);
7584 // ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible)
7586 for (j = 32; j < NUM_CHANGE_EVENTS; j++)
7587 if (change->has_event[j])
7588 event_bits |= (1u << (j - 32));
7589 putFile8Bit(file, event_bits);
7594 #if ENABLE_HISTORIC_CHUNKS
7595 static void SaveLevel_GRP1(FILE *file, struct LevelInfo *level, int element)
7597 struct ElementInfo *ei = &element_info[element];
7598 struct ElementGroupInfo *group = ei->group;
7601 putFile16BitBE(file, element);
7603 for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
7604 putFile8Bit(file, ei->description[i]);
7606 putFile8Bit(file, group->num_elements);
7608 putFile8Bit(file, ei->use_gfx_element);
7609 putFile16BitBE(file, ei->gfx_element_initial);
7611 putFile8Bit(file, group->choice_mode);
7613 // some free bytes for future values and padding
7614 WriteUnusedBytesToFile(file, 3);
7616 for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
7617 putFile16BitBE(file, group->element[i]);
7621 static int SaveLevel_MicroChunk(FILE *file, struct LevelFileConfigInfo *entry,
7622 boolean write_element)
7624 int save_type = entry->save_type;
7625 int data_type = entry->data_type;
7626 int conf_type = entry->conf_type;
7627 int byte_mask = conf_type & CONF_MASK_BYTES;
7628 int element = entry->element;
7629 int default_value = entry->default_value;
7631 boolean modified = FALSE;
7633 if (byte_mask != CONF_MASK_MULTI_BYTES)
7635 void *value_ptr = entry->value;
7636 int value = (data_type == TYPE_BOOLEAN ? *(boolean *)value_ptr :
7639 // check if any settings have been modified before saving them
7640 if (value != default_value)
7643 // do not save if explicitly told or if unmodified default settings
7644 if ((save_type == SAVE_CONF_NEVER) ||
7645 (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
7649 num_bytes += putFile16BitBE(file, element);
7651 num_bytes += putFile8Bit(file, conf_type);
7652 num_bytes += (byte_mask == CONF_MASK_1_BYTE ? putFile8Bit (file, value) :
7653 byte_mask == CONF_MASK_2_BYTE ? putFile16BitBE(file, value) :
7654 byte_mask == CONF_MASK_4_BYTE ? putFile32BitBE(file, value) :
7657 else if (data_type == TYPE_STRING)
7659 char *default_string = entry->default_string;
7660 char *string = (char *)(entry->value);
7661 int string_length = strlen(string);
7664 // check if any settings have been modified before saving them
7665 if (!strEqual(string, default_string))
7668 // do not save if explicitly told or if unmodified default settings
7669 if ((save_type == SAVE_CONF_NEVER) ||
7670 (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
7674 num_bytes += putFile16BitBE(file, element);
7676 num_bytes += putFile8Bit(file, conf_type);
7677 num_bytes += putFile16BitBE(file, string_length);
7679 for (i = 0; i < string_length; i++)
7680 num_bytes += putFile8Bit(file, string[i]);
7682 else if (data_type == TYPE_ELEMENT_LIST)
7684 int *element_array = (int *)(entry->value);
7685 int num_elements = *(int *)(entry->num_entities);
7688 // check if any settings have been modified before saving them
7689 for (i = 0; i < num_elements; i++)
7690 if (element_array[i] != default_value)
7693 // do not save if explicitly told or if unmodified default settings
7694 if ((save_type == SAVE_CONF_NEVER) ||
7695 (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
7699 num_bytes += putFile16BitBE(file, element);
7701 num_bytes += putFile8Bit(file, conf_type);
7702 num_bytes += putFile16BitBE(file, num_elements * CONF_ELEMENT_NUM_BYTES);
7704 for (i = 0; i < num_elements; i++)
7705 num_bytes += putFile16BitBE(file, element_array[i]);
7707 else if (data_type == TYPE_CONTENT_LIST)
7709 struct Content *content = (struct Content *)(entry->value);
7710 int num_contents = *(int *)(entry->num_entities);
7713 // check if any settings have been modified before saving them
7714 for (i = 0; i < num_contents; i++)
7715 for (y = 0; y < 3; y++)
7716 for (x = 0; x < 3; x++)
7717 if (content[i].e[x][y] != default_value)
7720 // do not save if explicitly told or if unmodified default settings
7721 if ((save_type == SAVE_CONF_NEVER) ||
7722 (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
7726 num_bytes += putFile16BitBE(file, element);
7728 num_bytes += putFile8Bit(file, conf_type);
7729 num_bytes += putFile16BitBE(file, num_contents * CONF_CONTENT_NUM_BYTES);
7731 for (i = 0; i < num_contents; i++)
7732 for (y = 0; y < 3; y++)
7733 for (x = 0; x < 3; x++)
7734 num_bytes += putFile16BitBE(file, content[i].e[x][y]);
7740 static int SaveLevel_INFO(FILE *file, struct LevelInfo *level)
7745 li = *level; // copy level data into temporary buffer
7747 for (i = 0; chunk_config_INFO[i].data_type != -1; i++)
7748 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_INFO[i], FALSE);
7753 static int SaveLevel_ELEM(FILE *file, struct LevelInfo *level)
7758 li = *level; // copy level data into temporary buffer
7760 for (i = 0; chunk_config_ELEM[i].data_type != -1; i++)
7761 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_ELEM[i], TRUE);
7766 static int SaveLevel_NOTE(FILE *file, struct LevelInfo *level, int element)
7768 int envelope_nr = element - EL_ENVELOPE_1;
7772 chunk_size += putFile16BitBE(file, element);
7774 // copy envelope data into temporary buffer
7775 xx_envelope = level->envelope[envelope_nr];
7777 for (i = 0; chunk_config_NOTE[i].data_type != -1; i++)
7778 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_NOTE[i], FALSE);
7783 static int SaveLevel_CUSX(FILE *file, struct LevelInfo *level, int element)
7785 struct ElementInfo *ei = &element_info[element];
7789 chunk_size += putFile16BitBE(file, element);
7791 xx_ei = *ei; // copy element data into temporary buffer
7793 // set default description string for this specific element
7794 strcpy(xx_default_description, getDefaultElementDescription(ei));
7796 for (i = 0; chunk_config_CUSX_base[i].data_type != -1; i++)
7797 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_base[i], FALSE);
7799 for (i = 0; i < ei->num_change_pages; i++)
7801 struct ElementChangeInfo *change = &ei->change_page[i];
7803 xx_current_change_page = i;
7805 xx_change = *change; // copy change data into temporary buffer
7808 setEventBitsFromEventFlags(change);
7810 for (j = 0; chunk_config_CUSX_change[j].data_type != -1; j++)
7811 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_change[j],
7818 static int SaveLevel_GRPX(FILE *file, struct LevelInfo *level, int element)
7820 struct ElementInfo *ei = &element_info[element];
7821 struct ElementGroupInfo *group = ei->group;
7825 chunk_size += putFile16BitBE(file, element);
7827 xx_ei = *ei; // copy element data into temporary buffer
7828 xx_group = *group; // copy group data into temporary buffer
7830 // set default description string for this specific element
7831 strcpy(xx_default_description, getDefaultElementDescription(ei));
7833 for (i = 0; chunk_config_GRPX[i].data_type != -1; i++)
7834 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_GRPX[i], FALSE);
7839 static int SaveLevel_EMPX(FILE *file, struct LevelInfo *level, int element)
7841 struct ElementInfo *ei = &element_info[element];
7845 chunk_size += putFile16BitBE(file, element);
7847 xx_ei = *ei; // copy element data into temporary buffer
7849 for (i = 0; chunk_config_EMPX[i].data_type != -1; i++)
7850 chunk_size += SaveLevel_MicroChunk(file, &chunk_config_EMPX[i], FALSE);
7855 static void SaveLevelFromFilename(struct LevelInfo *level, char *filename,
7856 boolean save_as_template)
7862 if (!(file = fopen(filename, MODE_WRITE)))
7864 Warn("cannot save level file '%s'", filename);
7869 level->file_version = FILE_VERSION_ACTUAL;
7870 level->game_version = GAME_VERSION_ACTUAL;
7872 level->creation_date = getCurrentDate();
7874 putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
7875 putFileChunkBE(file, "CAVE", CHUNK_SIZE_NONE);
7877 chunk_size = SaveLevel_VERS(NULL, level);
7878 putFileChunkBE(file, "VERS", chunk_size);
7879 SaveLevel_VERS(file, level);
7881 chunk_size = SaveLevel_DATE(NULL, level);
7882 putFileChunkBE(file, "DATE", chunk_size);
7883 SaveLevel_DATE(file, level);
7885 chunk_size = SaveLevel_NAME(NULL, level);
7886 putFileChunkBE(file, "NAME", chunk_size);
7887 SaveLevel_NAME(file, level);
7889 chunk_size = SaveLevel_AUTH(NULL, level);
7890 putFileChunkBE(file, "AUTH", chunk_size);
7891 SaveLevel_AUTH(file, level);
7893 chunk_size = SaveLevel_INFO(NULL, level);
7894 putFileChunkBE(file, "INFO", chunk_size);
7895 SaveLevel_INFO(file, level);
7897 chunk_size = SaveLevel_BODY(NULL, level);
7898 putFileChunkBE(file, "BODY", chunk_size);
7899 SaveLevel_BODY(file, level);
7901 chunk_size = SaveLevel_ELEM(NULL, level);
7902 if (chunk_size > LEVEL_CHUNK_ELEM_UNCHANGED) // save if changed
7904 putFileChunkBE(file, "ELEM", chunk_size);
7905 SaveLevel_ELEM(file, level);
7908 for (i = 0; i < NUM_ENVELOPES; i++)
7910 int element = EL_ENVELOPE_1 + i;
7912 chunk_size = SaveLevel_NOTE(NULL, level, element);
7913 if (chunk_size > LEVEL_CHUNK_NOTE_UNCHANGED) // save if changed
7915 putFileChunkBE(file, "NOTE", chunk_size);
7916 SaveLevel_NOTE(file, level, element);
7920 // if not using template level, check for non-default custom/group elements
7921 if (!level->use_custom_template || save_as_template)
7923 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7925 int element = EL_CUSTOM_START + i;
7927 chunk_size = SaveLevel_CUSX(NULL, level, element);
7928 if (chunk_size > LEVEL_CHUNK_CUSX_UNCHANGED) // save if changed
7930 putFileChunkBE(file, "CUSX", chunk_size);
7931 SaveLevel_CUSX(file, level, element);
7935 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
7937 int element = EL_GROUP_START + i;
7939 chunk_size = SaveLevel_GRPX(NULL, level, element);
7940 if (chunk_size > LEVEL_CHUNK_GRPX_UNCHANGED) // save if changed
7942 putFileChunkBE(file, "GRPX", chunk_size);
7943 SaveLevel_GRPX(file, level, element);
7947 for (i = 0; i < NUM_EMPTY_ELEMENTS_ALL; i++)
7949 int element = GET_EMPTY_ELEMENT(i);
7951 chunk_size = SaveLevel_EMPX(NULL, level, element);
7952 if (chunk_size > LEVEL_CHUNK_EMPX_UNCHANGED) // save if changed
7954 putFileChunkBE(file, "EMPX", chunk_size);
7955 SaveLevel_EMPX(file, level, element);
7962 SetFilePermissions(filename, PERMS_PRIVATE);
7965 void SaveLevel(int nr)
7967 char *filename = getDefaultLevelFilename(nr);
7969 SaveLevelFromFilename(&level, filename, FALSE);
7972 void SaveLevelTemplate(void)
7974 char *filename = getLocalLevelTemplateFilename();
7976 SaveLevelFromFilename(&level, filename, TRUE);
7979 boolean SaveLevelChecked(int nr)
7981 char *filename = getDefaultLevelFilename(nr);
7982 boolean new_level = !fileExists(filename);
7983 boolean level_saved = FALSE;
7985 if (new_level || Request("Save this level and kill the old?", REQ_ASK))
7990 Request("Level saved!", REQ_CONFIRM);
7998 void DumpLevel(struct LevelInfo *level)
8000 if (level->no_level_file || level->no_valid_file)
8002 Warn("cannot dump -- no valid level file found");
8008 Print("Level xxx (file version %08d, game version %08d)\n",
8009 level->file_version, level->game_version);
8012 Print("Level author: '%s'\n", level->author);
8013 Print("Level title: '%s'\n", level->name);
8015 Print("Playfield size: %d x %d\n", level->fieldx, level->fieldy);
8017 Print("Level time: %d seconds\n", level->time);
8018 Print("Gems needed: %d\n", level->gems_needed);
8020 Print("Time for magic wall: %d seconds\n", level->time_magic_wall);
8021 Print("Time for wheel: %d seconds\n", level->time_wheel);
8022 Print("Time for light: %d seconds\n", level->time_light);
8023 Print("Time for timegate: %d seconds\n", level->time_timegate);
8025 Print("Amoeba speed: %d\n", level->amoeba_speed);
8028 Print("EM style slippery gems: %s\n", (level->em_slippery_gems ? "yes" : "no"));
8029 Print("Player blocks last field: %s\n", (level->block_last_field ? "yes" : "no"));
8030 Print("SP player blocks last field: %s\n", (level->sp_block_last_field ? "yes" : "no"));
8031 Print("use spring bug: %s\n", (level->use_spring_bug ? "yes" : "no"));
8032 Print("use step counter: %s\n", (level->use_step_counter ? "yes" : "no"));
8033 Print("rate time over score: %s\n", (level->rate_time_over_score ? "yes" : "no"));
8039 for (i = 0; i < NUM_ENVELOPES; i++)
8041 char *text = level->envelope[i].text;
8042 int text_len = strlen(text);
8043 boolean has_text = FALSE;
8045 for (j = 0; j < text_len; j++)
8046 if (text[j] != ' ' && text[j] != '\n')
8052 Print("Envelope %d:\n'%s'\n", i + 1, text);
8060 void DumpLevels(void)
8062 static LevelDirTree *dumplevel_leveldir = NULL;
8064 dumplevel_leveldir = getTreeInfoFromIdentifier(leveldir_first,
8065 global.dumplevel_leveldir);
8067 if (dumplevel_leveldir == NULL)
8068 Fail("no such level identifier: '%s'", global.dumplevel_leveldir);
8070 if (global.dumplevel_level_nr < dumplevel_leveldir->first_level ||
8071 global.dumplevel_level_nr > dumplevel_leveldir->last_level)
8072 Fail("no such level number: %d", global.dumplevel_level_nr);
8074 leveldir_current = dumplevel_leveldir;
8076 LoadLevel(global.dumplevel_level_nr);
8083 // ============================================================================
8084 // tape file functions
8085 // ============================================================================
8087 static void setTapeInfoToDefaults(void)
8091 // always start with reliable default values (empty tape)
8094 // default values (also for pre-1.2 tapes) with only the first player
8095 tape.player_participates[0] = TRUE;
8096 for (i = 1; i < MAX_PLAYERS; i++)
8097 tape.player_participates[i] = FALSE;
8099 // at least one (default: the first) player participates in every tape
8100 tape.num_participating_players = 1;
8102 tape.property_bits = TAPE_PROPERTY_NONE;
8104 tape.level_nr = level_nr;
8106 tape.changed = FALSE;
8107 tape.solved = FALSE;
8109 tape.recording = FALSE;
8110 tape.playing = FALSE;
8111 tape.pausing = FALSE;
8113 tape.scr_fieldx = SCR_FIELDX_DEFAULT;
8114 tape.scr_fieldy = SCR_FIELDY_DEFAULT;
8116 tape.no_info_chunk = TRUE;
8117 tape.no_valid_file = FALSE;
8120 static int getTapePosSize(struct TapeInfo *tape)
8122 int tape_pos_size = 0;
8124 if (tape->use_key_actions)
8125 tape_pos_size += tape->num_participating_players;
8127 if (tape->use_mouse_actions)
8128 tape_pos_size += 3; // x and y position and mouse button mask
8130 tape_pos_size += 1; // tape action delay value
8132 return tape_pos_size;
8135 static void setTapeActionFlags(struct TapeInfo *tape, int value)
8137 tape->use_key_actions = FALSE;
8138 tape->use_mouse_actions = FALSE;
8140 if (value != TAPE_USE_MOUSE_ACTIONS_ONLY)
8141 tape->use_key_actions = TRUE;
8143 if (value != TAPE_USE_KEY_ACTIONS_ONLY)
8144 tape->use_mouse_actions = TRUE;
8147 static int getTapeActionValue(struct TapeInfo *tape)
8149 return (tape->use_key_actions &&
8150 tape->use_mouse_actions ? TAPE_USE_KEY_AND_MOUSE_ACTIONS :
8151 tape->use_key_actions ? TAPE_USE_KEY_ACTIONS_ONLY :
8152 tape->use_mouse_actions ? TAPE_USE_MOUSE_ACTIONS_ONLY :
8153 TAPE_ACTIONS_DEFAULT);
8156 static int LoadTape_VERS(File *file, int chunk_size, struct TapeInfo *tape)
8158 tape->file_version = getFileVersion(file);
8159 tape->game_version = getFileVersion(file);
8164 static int LoadTape_HEAD(File *file, int chunk_size, struct TapeInfo *tape)
8168 tape->random_seed = getFile32BitBE(file);
8169 tape->date = getFile32BitBE(file);
8170 tape->length = getFile32BitBE(file);
8172 // read header fields that are new since version 1.2
8173 if (tape->file_version >= FILE_VERSION_1_2)
8175 byte store_participating_players = getFile8Bit(file);
8178 // since version 1.2, tapes store which players participate in the tape
8179 tape->num_participating_players = 0;
8180 for (i = 0; i < MAX_PLAYERS; i++)
8182 tape->player_participates[i] = FALSE;
8184 if (store_participating_players & (1 << i))
8186 tape->player_participates[i] = TRUE;
8187 tape->num_participating_players++;
8191 setTapeActionFlags(tape, getFile8Bit(file));
8193 tape->property_bits = getFile8Bit(file);
8194 tape->solved = getFile8Bit(file);
8196 engine_version = getFileVersion(file);
8197 if (engine_version > 0)
8198 tape->engine_version = engine_version;
8200 tape->engine_version = tape->game_version;
8206 static int LoadTape_SCRN(File *file, int chunk_size, struct TapeInfo *tape)
8208 tape->scr_fieldx = getFile8Bit(file);
8209 tape->scr_fieldy = getFile8Bit(file);
8214 static int LoadTape_INFO(File *file, int chunk_size, struct TapeInfo *tape)
8216 char *level_identifier = NULL;
8217 int level_identifier_size;
8220 tape->no_info_chunk = FALSE;
8222 level_identifier_size = getFile16BitBE(file);
8224 level_identifier = checked_malloc(level_identifier_size);
8226 for (i = 0; i < level_identifier_size; i++)
8227 level_identifier[i] = getFile8Bit(file);
8229 strncpy(tape->level_identifier, level_identifier, MAX_FILENAME_LEN);
8230 tape->level_identifier[MAX_FILENAME_LEN] = '\0';
8232 checked_free(level_identifier);
8234 tape->level_nr = getFile16BitBE(file);
8236 chunk_size = 2 + level_identifier_size + 2;
8241 static int LoadTape_BODY(File *file, int chunk_size, struct TapeInfo *tape)
8244 int tape_pos_size = getTapePosSize(tape);
8245 int chunk_size_expected = tape_pos_size * tape->length;
8247 if (chunk_size_expected != chunk_size)
8249 ReadUnusedBytesFromFile(file, chunk_size);
8250 return chunk_size_expected;
8253 for (i = 0; i < tape->length; i++)
8255 if (i >= MAX_TAPE_LEN)
8257 Warn("tape truncated -- size exceeds maximum tape size %d",
8260 // tape too large; read and ignore remaining tape data from this chunk
8261 for (;i < tape->length; i++)
8262 ReadUnusedBytesFromFile(file, tape_pos_size);
8267 if (tape->use_key_actions)
8269 for (j = 0; j < MAX_PLAYERS; j++)
8271 tape->pos[i].action[j] = MV_NONE;
8273 if (tape->player_participates[j])
8274 tape->pos[i].action[j] = getFile8Bit(file);
8278 if (tape->use_mouse_actions)
8280 tape->pos[i].action[TAPE_ACTION_LX] = getFile8Bit(file);
8281 tape->pos[i].action[TAPE_ACTION_LY] = getFile8Bit(file);
8282 tape->pos[i].action[TAPE_ACTION_BUTTON] = getFile8Bit(file);
8285 tape->pos[i].delay = getFile8Bit(file);
8287 if (tape->file_version == FILE_VERSION_1_0)
8289 // eliminate possible diagonal moves in old tapes
8290 // this is only for backward compatibility
8292 byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
8293 byte action = tape->pos[i].action[0];
8294 int k, num_moves = 0;
8296 for (k = 0; k < 4; k++)
8298 if (action & joy_dir[k])
8300 tape->pos[i + num_moves].action[0] = joy_dir[k];
8302 tape->pos[i + num_moves].delay = 0;
8311 tape->length += num_moves;
8314 else if (tape->file_version < FILE_VERSION_2_0)
8316 // convert pre-2.0 tapes to new tape format
8318 if (tape->pos[i].delay > 1)
8321 tape->pos[i + 1] = tape->pos[i];
8322 tape->pos[i + 1].delay = 1;
8325 for (j = 0; j < MAX_PLAYERS; j++)
8326 tape->pos[i].action[j] = MV_NONE;
8327 tape->pos[i].delay--;
8334 if (checkEndOfFile(file))
8338 if (i != tape->length)
8339 chunk_size = tape_pos_size * i;
8344 static void LoadTape_SokobanSolution(char *filename)
8347 int move_delay = TILESIZE / level.initial_player_stepsize[0];
8349 if (!(file = openFile(filename, MODE_READ)))
8351 tape.no_valid_file = TRUE;
8356 while (!checkEndOfFile(file))
8358 unsigned char c = getByteFromFile(file);
8360 if (checkEndOfFile(file))
8367 tape.pos[tape.length].action[0] = MV_UP;
8368 tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
8374 tape.pos[tape.length].action[0] = MV_DOWN;
8375 tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
8381 tape.pos[tape.length].action[0] = MV_LEFT;
8382 tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
8388 tape.pos[tape.length].action[0] = MV_RIGHT;
8389 tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
8397 // ignore white-space characters
8401 tape.no_valid_file = TRUE;
8403 Warn("unsupported Sokoban solution file '%s' ['%d']", filename, c);
8411 if (tape.no_valid_file)
8414 tape.length_frames = GetTapeLengthFrames();
8415 tape.length_seconds = GetTapeLengthSeconds();
8418 void LoadTapeFromFilename(char *filename)
8420 char cookie[MAX_LINE_LEN];
8421 char chunk_name[CHUNK_ID_LEN + 1];
8425 // always start with reliable default values
8426 setTapeInfoToDefaults();
8428 if (strSuffix(filename, ".sln"))
8430 LoadTape_SokobanSolution(filename);
8435 if (!(file = openFile(filename, MODE_READ)))
8437 tape.no_valid_file = TRUE;
8442 getFileChunkBE(file, chunk_name, NULL);
8443 if (strEqual(chunk_name, "RND1"))
8445 getFile32BitBE(file); // not used
8447 getFileChunkBE(file, chunk_name, NULL);
8448 if (!strEqual(chunk_name, "TAPE"))
8450 tape.no_valid_file = TRUE;
8452 Warn("unknown format of tape file '%s'", filename);
8459 else // check for pre-2.0 file format with cookie string
8461 strcpy(cookie, chunk_name);
8462 if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
8464 if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
8465 cookie[strlen(cookie) - 1] = '\0';
8467 if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
8469 tape.no_valid_file = TRUE;
8471 Warn("unknown format of tape file '%s'", filename);
8478 if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
8480 tape.no_valid_file = TRUE;
8482 Warn("unsupported version of tape file '%s'", filename);
8489 // pre-2.0 tape files have no game version, so use file version here
8490 tape.game_version = tape.file_version;
8493 if (tape.file_version < FILE_VERSION_1_2)
8495 // tape files from versions before 1.2.0 without chunk structure
8496 LoadTape_HEAD(file, TAPE_CHUNK_HEAD_SIZE, &tape);
8497 LoadTape_BODY(file, 2 * tape.length, &tape);
8505 int (*loader)(File *, int, struct TapeInfo *);
8509 { "VERS", TAPE_CHUNK_VERS_SIZE, LoadTape_VERS },
8510 { "HEAD", TAPE_CHUNK_HEAD_SIZE, LoadTape_HEAD },
8511 { "SCRN", TAPE_CHUNK_SCRN_SIZE, LoadTape_SCRN },
8512 { "INFO", -1, LoadTape_INFO },
8513 { "BODY", -1, LoadTape_BODY },
8517 while (getFileChunkBE(file, chunk_name, &chunk_size))
8521 while (chunk_info[i].name != NULL &&
8522 !strEqual(chunk_name, chunk_info[i].name))
8525 if (chunk_info[i].name == NULL)
8527 Warn("unknown chunk '%s' in tape file '%s'",
8528 chunk_name, filename);
8530 ReadUnusedBytesFromFile(file, chunk_size);
8532 else if (chunk_info[i].size != -1 &&
8533 chunk_info[i].size != chunk_size)
8535 Warn("wrong size (%d) of chunk '%s' in tape file '%s'",
8536 chunk_size, chunk_name, filename);
8538 ReadUnusedBytesFromFile(file, chunk_size);
8542 // call function to load this tape chunk
8543 int chunk_size_expected =
8544 (chunk_info[i].loader)(file, chunk_size, &tape);
8546 // the size of some chunks cannot be checked before reading other
8547 // chunks first (like "HEAD" and "BODY") that contain some header
8548 // information, so check them here
8549 if (chunk_size_expected != chunk_size)
8551 Warn("wrong size (%d) of chunk '%s' in tape file '%s'",
8552 chunk_size, chunk_name, filename);
8560 tape.length_frames = GetTapeLengthFrames();
8561 tape.length_seconds = GetTapeLengthSeconds();
8564 Debug("files:LoadTapeFromFilename", "tape file version: %d",
8566 Debug("files:LoadTapeFromFilename", "tape game version: %d",
8568 Debug("files:LoadTapeFromFilename", "tape engine version: %d",
8569 tape.engine_version);
8573 void LoadTape(int nr)
8575 char *filename = getTapeFilename(nr);
8577 LoadTapeFromFilename(filename);
8580 void LoadSolutionTape(int nr)
8582 char *filename = getSolutionTapeFilename(nr);
8584 LoadTapeFromFilename(filename);
8586 if (TAPE_IS_EMPTY(tape))
8588 if (level.game_engine_type == GAME_ENGINE_TYPE_BD &&
8589 level.native_bd_level->replay != NULL)
8590 CopyNativeTape_BD_to_RND(&level);
8591 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP &&
8592 level.native_sp_level->demo.is_available)
8593 CopyNativeTape_SP_to_RND(&level);
8597 void LoadScoreTape(char *score_tape_basename, int nr)
8599 char *filename = getScoreTapeFilename(score_tape_basename, nr);
8601 LoadTapeFromFilename(filename);
8604 void LoadScoreCacheTape(char *score_tape_basename, int nr)
8606 char *filename = getScoreCacheTapeFilename(score_tape_basename, nr);
8608 LoadTapeFromFilename(filename);
8611 static boolean checkSaveTape_SCRN(struct TapeInfo *tape)
8613 // chunk required for team mode tapes with non-default screen size
8614 return (tape->num_participating_players > 1 &&
8615 (tape->scr_fieldx != SCR_FIELDX_DEFAULT ||
8616 tape->scr_fieldy != SCR_FIELDY_DEFAULT));
8619 static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)
8621 putFileVersion(file, tape->file_version);
8622 putFileVersion(file, tape->game_version);
8625 static void SaveTape_HEAD(FILE *file, struct TapeInfo *tape)
8628 byte store_participating_players = 0;
8630 // set bits for participating players for compact storage
8631 for (i = 0; i < MAX_PLAYERS; i++)
8632 if (tape->player_participates[i])
8633 store_participating_players |= (1 << i);
8635 putFile32BitBE(file, tape->random_seed);
8636 putFile32BitBE(file, tape->date);
8637 putFile32BitBE(file, tape->length);
8639 putFile8Bit(file, store_participating_players);
8641 putFile8Bit(file, getTapeActionValue(tape));
8643 putFile8Bit(file, tape->property_bits);
8644 putFile8Bit(file, tape->solved);
8646 putFileVersion(file, tape->engine_version);
8649 static void SaveTape_SCRN(FILE *file, struct TapeInfo *tape)
8651 putFile8Bit(file, tape->scr_fieldx);
8652 putFile8Bit(file, tape->scr_fieldy);
8655 static void SaveTape_INFO(FILE *file, struct TapeInfo *tape)
8657 int level_identifier_size = strlen(tape->level_identifier) + 1;
8660 putFile16BitBE(file, level_identifier_size);
8662 for (i = 0; i < level_identifier_size; i++)
8663 putFile8Bit(file, tape->level_identifier[i]);
8665 putFile16BitBE(file, tape->level_nr);
8668 static void SaveTape_BODY(FILE *file, struct TapeInfo *tape)
8672 for (i = 0; i < tape->length; i++)
8674 if (tape->use_key_actions)
8676 for (j = 0; j < MAX_PLAYERS; j++)
8677 if (tape->player_participates[j])
8678 putFile8Bit(file, tape->pos[i].action[j]);
8681 if (tape->use_mouse_actions)
8683 putFile8Bit(file, tape->pos[i].action[TAPE_ACTION_LX]);
8684 putFile8Bit(file, tape->pos[i].action[TAPE_ACTION_LY]);
8685 putFile8Bit(file, tape->pos[i].action[TAPE_ACTION_BUTTON]);
8688 putFile8Bit(file, tape->pos[i].delay);
8692 void SaveTapeToFilename(char *filename)
8696 int info_chunk_size;
8697 int body_chunk_size;
8699 if (!(file = fopen(filename, MODE_WRITE)))
8701 Warn("cannot save level recording file '%s'", filename);
8706 tape_pos_size = getTapePosSize(&tape);
8708 info_chunk_size = 2 + (strlen(tape.level_identifier) + 1) + 2;
8709 body_chunk_size = tape_pos_size * tape.length;
8711 putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
8712 putFileChunkBE(file, "TAPE", CHUNK_SIZE_NONE);
8714 putFileChunkBE(file, "VERS", TAPE_CHUNK_VERS_SIZE);
8715 SaveTape_VERS(file, &tape);
8717 putFileChunkBE(file, "HEAD", TAPE_CHUNK_HEAD_SIZE);
8718 SaveTape_HEAD(file, &tape);
8720 if (checkSaveTape_SCRN(&tape))
8722 putFileChunkBE(file, "SCRN", TAPE_CHUNK_SCRN_SIZE);
8723 SaveTape_SCRN(file, &tape);
8726 putFileChunkBE(file, "INFO", info_chunk_size);
8727 SaveTape_INFO(file, &tape);
8729 putFileChunkBE(file, "BODY", body_chunk_size);
8730 SaveTape_BODY(file, &tape);
8734 SetFilePermissions(filename, PERMS_PRIVATE);
8737 static void SaveTapeExt(char *filename)
8741 tape.file_version = FILE_VERSION_ACTUAL;
8742 tape.game_version = GAME_VERSION_ACTUAL;
8744 tape.num_participating_players = 0;
8746 // count number of participating players
8747 for (i = 0; i < MAX_PLAYERS; i++)
8748 if (tape.player_participates[i])
8749 tape.num_participating_players++;
8751 SaveTapeToFilename(filename);
8753 tape.changed = FALSE;
8756 void SaveTape(int nr)
8758 char *filename = getTapeFilename(nr);
8760 InitTapeDirectory(leveldir_current->subdir);
8762 SaveTapeExt(filename);
8765 void SaveScoreTape(int nr)
8767 char *filename = getScoreTapeFilename(tape.score_tape_basename, nr);
8769 // used instead of "leveldir_current->subdir" (for network games)
8770 InitScoreTapeDirectory(levelset.identifier, nr);
8772 SaveTapeExt(filename);
8775 static boolean SaveTapeCheckedExt(int nr, char *msg_replace, char *msg_saved,
8776 unsigned int req_state_added)
8778 char *filename = getTapeFilename(nr);
8779 boolean new_tape = !fileExists(filename);
8780 boolean tape_saved = FALSE;
8782 if (new_tape || Request(msg_replace, REQ_ASK | req_state_added))
8787 Request(msg_saved, REQ_CONFIRM | req_state_added);
8795 boolean SaveTapeChecked(int nr)
8797 return SaveTapeCheckedExt(nr, "Replace old tape?", "Tape saved!", 0);
8800 boolean SaveTapeChecked_LevelSolved(int nr)
8802 return SaveTapeCheckedExt(nr, "Level solved! Replace old tape?",
8803 "Level solved! Tape saved!", REQ_STAY_OPEN);
8806 void DumpTape(struct TapeInfo *tape)
8808 int tape_frame_counter;
8811 if (tape->no_valid_file)
8813 Warn("cannot dump -- no valid tape file found");
8820 Print("Tape of Level %03d (file version %08d, game version %08d)\n",
8821 tape->level_nr, tape->file_version, tape->game_version);
8822 Print(" (effective engine version %08d)\n",
8823 tape->engine_version);
8824 Print("Level series identifier: '%s'\n", tape->level_identifier);
8826 Print("Solution tape: %s\n",
8827 tape->solved ? "yes" :
8828 tape->game_version < VERSION_IDENT(4,3,2,3) ? "unknown" : "no");
8830 Print("Special tape properties: ");
8831 if (tape->property_bits == TAPE_PROPERTY_NONE)
8833 if (tape->property_bits & TAPE_PROPERTY_EM_RANDOM_BUG)
8834 Print("[em_random_bug]");
8835 if (tape->property_bits & TAPE_PROPERTY_GAME_SPEED)
8836 Print("[game_speed]");
8837 if (tape->property_bits & TAPE_PROPERTY_PAUSE_MODE)
8839 if (tape->property_bits & TAPE_PROPERTY_SINGLE_STEP)
8840 Print("[single_step]");
8841 if (tape->property_bits & TAPE_PROPERTY_SNAPSHOT)
8842 Print("[snapshot]");
8843 if (tape->property_bits & TAPE_PROPERTY_REPLAYED)
8844 Print("[replayed]");
8845 if (tape->property_bits & TAPE_PROPERTY_TAS_KEYS)
8846 Print("[tas_keys]");
8847 if (tape->property_bits & TAPE_PROPERTY_SMALL_GRAPHICS)
8848 Print("[small_graphics]");
8851 int year2 = tape->date / 10000;
8852 int year4 = (year2 < 70 ? 2000 + year2 : 1900 + year2);
8853 int month_index_raw = (tape->date / 100) % 100;
8854 int month_index = month_index_raw % 12; // prevent invalid index
8855 int month = month_index + 1;
8856 int day = tape->date % 100;
8858 Print("Tape date: %04d-%02d-%02d\n", year4, month, day);
8862 tape_frame_counter = 0;
8864 for (i = 0; i < tape->length; i++)
8866 if (i >= MAX_TAPE_LEN)
8871 for (j = 0; j < MAX_PLAYERS; j++)
8873 if (tape->player_participates[j])
8875 int action = tape->pos[i].action[j];
8877 Print("%d:%02x ", j, action);
8878 Print("[%c%c%c%c|%c%c] - ",
8879 (action & JOY_LEFT ? '<' : ' '),
8880 (action & JOY_RIGHT ? '>' : ' '),
8881 (action & JOY_UP ? '^' : ' '),
8882 (action & JOY_DOWN ? 'v' : ' '),
8883 (action & JOY_BUTTON_1 ? '1' : ' '),
8884 (action & JOY_BUTTON_2 ? '2' : ' '));
8888 Print("(%03d) ", tape->pos[i].delay);
8889 Print("[%05d]\n", tape_frame_counter);
8891 tape_frame_counter += tape->pos[i].delay;
8897 void DumpTapes(void)
8899 static LevelDirTree *dumptape_leveldir = NULL;
8901 dumptape_leveldir = getTreeInfoFromIdentifier(leveldir_first,
8902 global.dumptape_leveldir);
8904 if (dumptape_leveldir == NULL)
8905 Fail("no such level identifier: '%s'", global.dumptape_leveldir);
8907 if (global.dumptape_level_nr < dumptape_leveldir->first_level ||
8908 global.dumptape_level_nr > dumptape_leveldir->last_level)
8909 Fail("no such level number: %d", global.dumptape_level_nr);
8911 leveldir_current = dumptape_leveldir;
8913 if (options.mytapes)
8914 LoadTape(global.dumptape_level_nr);
8916 LoadSolutionTape(global.dumptape_level_nr);
8924 // ============================================================================
8925 // score file functions
8926 // ============================================================================
8928 static void setScoreInfoToDefaultsExt(struct ScoreInfo *scores)
8932 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
8934 strcpy(scores->entry[i].tape_basename, UNDEFINED_FILENAME);
8935 strcpy(scores->entry[i].name, EMPTY_PLAYER_NAME);
8936 scores->entry[i].score = 0;
8937 scores->entry[i].time = 0;
8939 scores->entry[i].id = -1;
8940 strcpy(scores->entry[i].tape_date, UNKNOWN_NAME);
8941 strcpy(scores->entry[i].platform, UNKNOWN_NAME);
8942 strcpy(scores->entry[i].version, UNKNOWN_NAME);
8943 strcpy(scores->entry[i].country_name, UNKNOWN_NAME);
8944 strcpy(scores->entry[i].country_code, "??");
8947 scores->num_entries = 0;
8948 scores->last_added = -1;
8949 scores->last_added_local = -1;
8951 scores->updated = FALSE;
8952 scores->uploaded = FALSE;
8953 scores->tape_downloaded = FALSE;
8954 scores->force_last_added = FALSE;
8956 // The following values are intentionally not reset here:
8960 // - continue_playing
8961 // - continue_on_return
8964 static void setScoreInfoToDefaults(void)
8966 setScoreInfoToDefaultsExt(&scores);
8969 static void setServerScoreInfoToDefaults(void)
8971 setScoreInfoToDefaultsExt(&server_scores);
8974 static void LoadScore_OLD(int nr)
8977 char *filename = getScoreFilename(nr);
8978 char cookie[MAX_LINE_LEN];
8979 char line[MAX_LINE_LEN];
8983 if (!(file = fopen(filename, MODE_READ)))
8986 // check file identifier
8987 if (fgets(cookie, MAX_LINE_LEN, file) == NULL)
8989 if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
8990 cookie[strlen(cookie) - 1] = '\0';
8992 if (!checkCookieString(cookie, SCORE_COOKIE_TMPL))
8994 Warn("unknown format of score file '%s'", filename);
9001 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
9003 if (fscanf(file, "%d", &scores.entry[i].score) == EOF)
9004 Warn("fscanf() failed; %s", strerror(errno));
9006 if (fgets(line, MAX_LINE_LEN, file) == NULL)
9009 if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
9010 line[strlen(line) - 1] = '\0';
9012 for (line_ptr = line; *line_ptr; line_ptr++)
9014 if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
9016 strncpy(scores.entry[i].name, line_ptr, MAX_PLAYER_NAME_LEN);
9017 scores.entry[i].name[MAX_PLAYER_NAME_LEN] = '\0';
9026 static void ConvertScore_OLD(void)
9028 // only convert score to time for levels that rate playing time over score
9029 if (!level.rate_time_over_score)
9032 // convert old score to playing time for score-less levels (like Supaplex)
9033 int time_final_max = 999;
9036 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
9038 int score = scores.entry[i].score;
9040 if (score > 0 && score < time_final_max)
9041 scores.entry[i].time = (time_final_max - score - 1) * FRAMES_PER_SECOND;
9045 static int LoadScore_VERS(File *file, int chunk_size, struct ScoreInfo *scores)
9047 scores->file_version = getFileVersion(file);
9048 scores->game_version = getFileVersion(file);
9053 static int LoadScore_INFO(File *file, int chunk_size, struct ScoreInfo *scores)
9055 char *level_identifier = NULL;
9056 int level_identifier_size;
9059 level_identifier_size = getFile16BitBE(file);
9061 level_identifier = checked_malloc(level_identifier_size);
9063 for (i = 0; i < level_identifier_size; i++)
9064 level_identifier[i] = getFile8Bit(file);
9066 strncpy(scores->level_identifier, level_identifier, MAX_FILENAME_LEN);
9067 scores->level_identifier[MAX_FILENAME_LEN] = '\0';
9069 checked_free(level_identifier);
9071 scores->level_nr = getFile16BitBE(file);
9072 scores->num_entries = getFile16BitBE(file);
9074 chunk_size = 2 + level_identifier_size + 2 + 2;
9079 static int LoadScore_NAME(File *file, int chunk_size, struct ScoreInfo *scores)
9083 for (i = 0; i < scores->num_entries; i++)
9085 for (j = 0; j < MAX_PLAYER_NAME_LEN; j++)
9086 scores->entry[i].name[j] = getFile8Bit(file);
9088 scores->entry[i].name[MAX_PLAYER_NAME_LEN] = '\0';
9091 chunk_size = scores->num_entries * MAX_PLAYER_NAME_LEN;
9096 static int LoadScore_SCOR(File *file, int chunk_size, struct ScoreInfo *scores)
9100 for (i = 0; i < scores->num_entries; i++)
9101 scores->entry[i].score = getFile16BitBE(file);
9103 chunk_size = scores->num_entries * 2;
9108 static int LoadScore_SC4R(File *file, int chunk_size, struct ScoreInfo *scores)
9112 for (i = 0; i < scores->num_entries; i++)
9113 scores->entry[i].score = getFile32BitBE(file);
9115 chunk_size = scores->num_entries * 4;
9120 static int LoadScore_TIME(File *file, int chunk_size, struct ScoreInfo *scores)
9124 for (i = 0; i < scores->num_entries; i++)
9125 scores->entry[i].time = getFile32BitBE(file);
9127 chunk_size = scores->num_entries * 4;
9132 static int LoadScore_TAPE(File *file, int chunk_size, struct ScoreInfo *scores)
9136 for (i = 0; i < scores->num_entries; i++)
9138 for (j = 0; j < MAX_SCORE_TAPE_BASENAME_LEN; j++)
9139 scores->entry[i].tape_basename[j] = getFile8Bit(file);
9141 scores->entry[i].tape_basename[MAX_SCORE_TAPE_BASENAME_LEN] = '\0';
9144 chunk_size = scores->num_entries * MAX_SCORE_TAPE_BASENAME_LEN;
9149 void LoadScore(int nr)
9151 char *filename = getScoreFilename(nr);
9152 char cookie[MAX_LINE_LEN];
9153 char chunk_name[CHUNK_ID_LEN + 1];
9155 boolean old_score_file_format = FALSE;
9158 // always start with reliable default values
9159 setScoreInfoToDefaults();
9161 if (!(file = openFile(filename, MODE_READ)))
9164 getFileChunkBE(file, chunk_name, NULL);
9165 if (strEqual(chunk_name, "RND1"))
9167 getFile32BitBE(file); // not used
9169 getFileChunkBE(file, chunk_name, NULL);
9170 if (!strEqual(chunk_name, "SCOR"))
9172 Warn("unknown format of score file '%s'", filename);
9179 else // check for old file format with cookie string
9181 strcpy(cookie, chunk_name);
9182 if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
9184 if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
9185 cookie[strlen(cookie) - 1] = '\0';
9187 if (!checkCookieString(cookie, SCORE_COOKIE_TMPL))
9189 Warn("unknown format of score file '%s'", filename);
9196 old_score_file_format = TRUE;
9199 if (old_score_file_format)
9201 // score files from versions before 4.2.4.0 without chunk structure
9204 // convert score to time, if possible (mainly for Supaplex levels)
9213 int (*loader)(File *, int, struct ScoreInfo *);
9217 { "VERS", SCORE_CHUNK_VERS_SIZE, LoadScore_VERS },
9218 { "INFO", -1, LoadScore_INFO },
9219 { "NAME", -1, LoadScore_NAME },
9220 { "SCOR", -1, LoadScore_SCOR },
9221 { "SC4R", -1, LoadScore_SC4R },
9222 { "TIME", -1, LoadScore_TIME },
9223 { "TAPE", -1, LoadScore_TAPE },
9228 while (getFileChunkBE(file, chunk_name, &chunk_size))
9232 while (chunk_info[i].name != NULL &&
9233 !strEqual(chunk_name, chunk_info[i].name))
9236 if (chunk_info[i].name == NULL)
9238 Warn("unknown chunk '%s' in score file '%s'",
9239 chunk_name, filename);
9241 ReadUnusedBytesFromFile(file, chunk_size);
9243 else if (chunk_info[i].size != -1 &&
9244 chunk_info[i].size != chunk_size)
9246 Warn("wrong size (%d) of chunk '%s' in score file '%s'",
9247 chunk_size, chunk_name, filename);
9249 ReadUnusedBytesFromFile(file, chunk_size);
9253 // call function to load this score chunk
9254 int chunk_size_expected =
9255 (chunk_info[i].loader)(file, chunk_size, &scores);
9257 // the size of some chunks cannot be checked before reading other
9258 // chunks first (like "HEAD" and "BODY") that contain some header
9259 // information, so check them here
9260 if (chunk_size_expected != chunk_size)
9262 Warn("wrong size (%d) of chunk '%s' in score file '%s'",
9263 chunk_size, chunk_name, filename);
9272 #if ENABLE_HISTORIC_CHUNKS
9273 void SaveScore_OLD(int nr)
9276 char *filename = getScoreFilename(nr);
9279 // used instead of "leveldir_current->subdir" (for network games)
9280 InitScoreDirectory(levelset.identifier);
9282 if (!(file = fopen(filename, MODE_WRITE)))
9284 Warn("cannot save score for level %d", nr);
9289 fprintf(file, "%s\n\n", SCORE_COOKIE);
9291 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
9292 fprintf(file, "%d %s\n", scores.entry[i].score, scores.entry[i].name);
9296 SetFilePermissions(filename, PERMS_PRIVATE);
9300 static void SaveScore_VERS(FILE *file, struct ScoreInfo *scores)
9302 putFileVersion(file, scores->file_version);
9303 putFileVersion(file, scores->game_version);
9306 static void SaveScore_INFO(FILE *file, struct ScoreInfo *scores)
9308 int level_identifier_size = strlen(scores->level_identifier) + 1;
9311 putFile16BitBE(file, level_identifier_size);
9313 for (i = 0; i < level_identifier_size; i++)
9314 putFile8Bit(file, scores->level_identifier[i]);
9316 putFile16BitBE(file, scores->level_nr);
9317 putFile16BitBE(file, scores->num_entries);
9320 static void SaveScore_NAME(FILE *file, struct ScoreInfo *scores)
9324 for (i = 0; i < scores->num_entries; i++)
9326 int name_size = strlen(scores->entry[i].name);
9328 for (j = 0; j < MAX_PLAYER_NAME_LEN; j++)
9329 putFile8Bit(file, (j < name_size ? scores->entry[i].name[j] : 0));
9333 static void SaveScore_SCOR(FILE *file, struct ScoreInfo *scores)
9337 for (i = 0; i < scores->num_entries; i++)
9338 putFile16BitBE(file, scores->entry[i].score);
9341 static void SaveScore_SC4R(FILE *file, struct ScoreInfo *scores)
9345 for (i = 0; i < scores->num_entries; i++)
9346 putFile32BitBE(file, scores->entry[i].score);
9349 static void SaveScore_TIME(FILE *file, struct ScoreInfo *scores)
9353 for (i = 0; i < scores->num_entries; i++)
9354 putFile32BitBE(file, scores->entry[i].time);
9357 static void SaveScore_TAPE(FILE *file, struct ScoreInfo *scores)
9361 for (i = 0; i < scores->num_entries; i++)
9363 int size = strlen(scores->entry[i].tape_basename);
9365 for (j = 0; j < MAX_SCORE_TAPE_BASENAME_LEN; j++)
9366 putFile8Bit(file, (j < size ? scores->entry[i].tape_basename[j] : 0));
9370 static void SaveScoreToFilename(char *filename)
9373 int info_chunk_size;
9374 int name_chunk_size;
9375 int scor_chunk_size;
9376 int sc4r_chunk_size;
9377 int time_chunk_size;
9378 int tape_chunk_size;
9379 boolean has_large_score_values;
9382 if (!(file = fopen(filename, MODE_WRITE)))
9384 Warn("cannot save score file '%s'", filename);
9389 info_chunk_size = 2 + (strlen(scores.level_identifier) + 1) + 2 + 2;
9390 name_chunk_size = scores.num_entries * MAX_PLAYER_NAME_LEN;
9391 scor_chunk_size = scores.num_entries * 2;
9392 sc4r_chunk_size = scores.num_entries * 4;
9393 time_chunk_size = scores.num_entries * 4;
9394 tape_chunk_size = scores.num_entries * MAX_SCORE_TAPE_BASENAME_LEN;
9396 has_large_score_values = FALSE;
9397 for (i = 0; i < scores.num_entries; i++)
9398 if (scores.entry[i].score > 0xffff)
9399 has_large_score_values = TRUE;
9401 putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
9402 putFileChunkBE(file, "SCOR", CHUNK_SIZE_NONE);
9404 putFileChunkBE(file, "VERS", SCORE_CHUNK_VERS_SIZE);
9405 SaveScore_VERS(file, &scores);
9407 putFileChunkBE(file, "INFO", info_chunk_size);
9408 SaveScore_INFO(file, &scores);
9410 putFileChunkBE(file, "NAME", name_chunk_size);
9411 SaveScore_NAME(file, &scores);
9413 if (has_large_score_values)
9415 putFileChunkBE(file, "SC4R", sc4r_chunk_size);
9416 SaveScore_SC4R(file, &scores);
9420 putFileChunkBE(file, "SCOR", scor_chunk_size);
9421 SaveScore_SCOR(file, &scores);
9424 putFileChunkBE(file, "TIME", time_chunk_size);
9425 SaveScore_TIME(file, &scores);
9427 putFileChunkBE(file, "TAPE", tape_chunk_size);
9428 SaveScore_TAPE(file, &scores);
9432 SetFilePermissions(filename, PERMS_PRIVATE);
9435 void SaveScore(int nr)
9437 char *filename = getScoreFilename(nr);
9440 // used instead of "leveldir_current->subdir" (for network games)
9441 InitScoreDirectory(levelset.identifier);
9443 scores.file_version = FILE_VERSION_ACTUAL;
9444 scores.game_version = GAME_VERSION_ACTUAL;
9446 strncpy(scores.level_identifier, levelset.identifier, MAX_FILENAME_LEN);
9447 scores.level_identifier[MAX_FILENAME_LEN] = '\0';
9448 scores.level_nr = level_nr;
9450 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
9451 if (scores.entry[i].score == 0 &&
9452 scores.entry[i].time == 0 &&
9453 strEqual(scores.entry[i].name, EMPTY_PLAYER_NAME))
9456 scores.num_entries = i;
9458 if (scores.num_entries == 0)
9461 SaveScoreToFilename(filename);
9464 static void LoadServerScoreFromCache(int nr)
9466 struct ScoreEntry score_entry;
9475 { &score_entry.score, FALSE, 0 },
9476 { &score_entry.time, FALSE, 0 },
9477 { score_entry.name, TRUE, MAX_PLAYER_NAME_LEN },
9478 { score_entry.tape_basename, TRUE, MAX_FILENAME_LEN },
9479 { score_entry.tape_date, TRUE, MAX_ISO_DATE_LEN },
9480 { &score_entry.id, FALSE, 0 },
9481 { score_entry.platform, TRUE, MAX_PLATFORM_TEXT_LEN },
9482 { score_entry.version, TRUE, MAX_VERSION_TEXT_LEN },
9483 { score_entry.country_code, TRUE, MAX_COUNTRY_CODE_LEN },
9484 { score_entry.country_name, TRUE, MAX_COUNTRY_NAME_LEN },
9488 char *filename = getScoreCacheFilename(nr);
9489 SetupFileHash *score_hash = loadSetupFileHash(filename);
9492 server_scores.num_entries = 0;
9494 if (score_hash == NULL)
9497 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
9499 score_entry = server_scores.entry[i];
9501 for (j = 0; score_mapping[j].value != NULL; j++)
9505 sprintf(token, "%02d.%d", i, j);
9507 char *value = getHashEntry(score_hash, token);
9512 if (score_mapping[j].is_string)
9514 char *score_value = (char *)score_mapping[j].value;
9515 int value_size = score_mapping[j].string_size;
9517 strncpy(score_value, value, value_size);
9518 score_value[value_size] = '\0';
9522 int *score_value = (int *)score_mapping[j].value;
9524 *score_value = atoi(value);
9527 server_scores.num_entries = i + 1;
9530 server_scores.entry[i] = score_entry;
9533 freeSetupFileHash(score_hash);
9536 void LoadServerScore(int nr, boolean download_score)
9538 if (!setup.use_api_server)
9541 // always start with reliable default values
9542 setServerScoreInfoToDefaults();
9544 // 1st step: load server scores from cache file (which may not exist)
9545 // (this should prevent reading it while the thread is writing to it)
9546 LoadServerScoreFromCache(nr);
9548 if (download_score && runtime.use_api_server)
9550 // 2nd step: download server scores from score server to cache file
9551 // (as thread, as it might time out if the server is not reachable)
9552 ApiGetScoreAsThread(nr);
9556 void PrepareScoreTapesForUpload(char *leveldir_subdir)
9558 MarkTapeDirectoryUploadsAsIncomplete(leveldir_subdir);
9560 // if score tape not uploaded, ask for uploading missing tapes later
9561 if (!setup.has_remaining_tapes)
9562 setup.ask_for_remaining_tapes = TRUE;
9564 setup.provide_uploading_tapes = TRUE;
9565 setup.has_remaining_tapes = TRUE;
9567 SaveSetup_ServerSetup();
9570 void SaveServerScore(int nr, boolean tape_saved)
9572 if (!runtime.use_api_server)
9574 PrepareScoreTapesForUpload(leveldir_current->subdir);
9579 ApiAddScoreAsThread(nr, tape_saved, NULL);
9582 void SaveServerScoreFromFile(int nr, boolean tape_saved,
9583 char *score_tape_filename)
9585 if (!runtime.use_api_server)
9588 ApiAddScoreAsThread(nr, tape_saved, score_tape_filename);
9591 void LoadLocalAndServerScore(int nr, boolean download_score)
9593 int last_added_local = scores.last_added_local;
9594 boolean force_last_added = scores.force_last_added;
9596 // needed if only showing server scores
9597 setScoreInfoToDefaults();
9599 if (!strEqual(setup.scores_in_highscore_list, STR_SCORES_TYPE_SERVER_ONLY))
9602 // restore last added local score entry (before merging server scores)
9603 scores.last_added = scores.last_added_local = last_added_local;
9605 if (setup.use_api_server &&
9606 !strEqual(setup.scores_in_highscore_list, STR_SCORES_TYPE_LOCAL_ONLY))
9608 // load server scores from cache file and trigger update from server
9609 LoadServerScore(nr, download_score);
9611 // merge local scores with scores from server
9615 if (force_last_added)
9616 scores.force_last_added = force_last_added;
9620 // ============================================================================
9621 // setup file functions
9622 // ============================================================================
9624 #define TOKEN_STR_PLAYER_PREFIX "player_"
9627 static struct TokenInfo global_setup_tokens[] =
9631 &setup.player_name, "player_name"
9635 &setup.multiple_users, "multiple_users"
9639 &setup.sound, "sound"
9643 &setup.sound_loops, "repeating_sound_loops"
9647 &setup.sound_music, "background_music"
9651 &setup.sound_simple, "simple_sound_effects"
9655 &setup.toons, "toons"
9659 &setup.global_animations, "global_animations"
9663 &setup.scroll_delay, "scroll_delay"
9667 &setup.forced_scroll_delay, "forced_scroll_delay"
9671 &setup.scroll_delay_value, "scroll_delay_value"
9675 &setup.engine_snapshot_mode, "engine_snapshot_mode"
9679 &setup.engine_snapshot_memory, "engine_snapshot_memory"
9683 &setup.fade_screens, "fade_screens"
9687 &setup.autorecord, "automatic_tape_recording"
9691 &setup.autorecord_after_replay, "autorecord_after_replay"
9695 &setup.auto_pause_on_start, "auto_pause_on_start"
9699 &setup.show_titlescreen, "show_titlescreen"
9703 &setup.quick_doors, "quick_doors"
9707 &setup.team_mode, "team_mode"
9711 &setup.handicap, "handicap"
9715 &setup.skip_levels, "skip_levels"
9719 &setup.increment_levels, "increment_levels"
9723 &setup.auto_play_next_level, "auto_play_next_level"
9727 &setup.count_score_after_game, "count_score_after_game"
9731 &setup.show_scores_after_game, "show_scores_after_game"
9735 &setup.time_limit, "time_limit"
9739 &setup.fullscreen, "fullscreen"
9743 &setup.window_scaling_percent, "window_scaling_percent"
9747 &setup.window_scaling_quality, "window_scaling_quality"
9751 &setup.screen_rendering_mode, "screen_rendering_mode"
9755 &setup.vsync_mode, "vsync_mode"
9759 &setup.ask_on_escape, "ask_on_escape"
9763 &setup.ask_on_escape_editor, "ask_on_escape_editor"
9767 &setup.ask_on_game_over, "ask_on_game_over"
9771 &setup.ask_on_quit_game, "ask_on_quit_game"
9775 &setup.ask_on_quit_program, "ask_on_quit_program"
9779 &setup.quick_switch, "quick_player_switch"
9783 &setup.input_on_focus, "input_on_focus"
9787 &setup.prefer_aga_graphics, "prefer_aga_graphics"
9791 &setup.prefer_lowpass_sounds, "prefer_lowpass_sounds"
9795 &setup.prefer_extra_panel_items, "prefer_extra_panel_items"
9799 &setup.game_speed_extended, "game_speed_extended"
9803 &setup.game_frame_delay, "game_frame_delay"
9807 &setup.sp_show_border_elements, "sp_show_border_elements"
9811 &setup.small_game_graphics, "small_game_graphics"
9815 &setup.show_load_save_buttons, "show_load_save_buttons"
9819 &setup.show_undo_redo_buttons, "show_undo_redo_buttons"
9823 &setup.scores_in_highscore_list, "scores_in_highscore_list"
9827 &setup.graphics_set, "graphics_set"
9831 &setup.sounds_set, "sounds_set"
9835 &setup.music_set, "music_set"
9839 &setup.override_level_graphics, "override_level_graphics"
9843 &setup.override_level_sounds, "override_level_sounds"
9847 &setup.override_level_music, "override_level_music"
9851 &setup.volume_simple, "volume_simple"
9855 &setup.volume_loops, "volume_loops"
9859 &setup.volume_music, "volume_music"
9863 &setup.network_mode, "network_mode"
9867 &setup.network_player_nr, "network_player"
9871 &setup.network_server_hostname, "network_server_hostname"
9875 &setup.touch.control_type, "touch.control_type"
9879 &setup.touch.move_distance, "touch.move_distance"
9883 &setup.touch.drop_distance, "touch.drop_distance"
9887 &setup.touch.transparency, "touch.transparency"
9891 &setup.touch.draw_outlined, "touch.draw_outlined"
9895 &setup.touch.draw_pressed, "touch.draw_pressed"
9899 &setup.touch.grid_xsize[0], "touch.virtual_buttons.0.xsize"
9903 &setup.touch.grid_ysize[0], "touch.virtual_buttons.0.ysize"
9907 &setup.touch.grid_xsize[1], "touch.virtual_buttons.1.xsize"
9911 &setup.touch.grid_ysize[1], "touch.virtual_buttons.1.ysize"
9915 &setup.touch.overlay_buttons, "touch.overlay_buttons"
9919 static struct TokenInfo auto_setup_tokens[] =
9923 &setup.auto_setup.editor_zoom_tilesize, "editor.zoom_tilesize"
9927 static struct TokenInfo server_setup_tokens[] =
9931 &setup.player_uuid, "player_uuid"
9935 &setup.player_version, "player_version"
9939 &setup.use_api_server, TEST_PREFIX "use_api_server"
9943 &setup.api_server_hostname, TEST_PREFIX "api_server_hostname"
9947 &setup.api_server_password, TEST_PREFIX "api_server_password"
9951 &setup.ask_for_uploading_tapes, TEST_PREFIX "ask_for_uploading_tapes"
9955 &setup.ask_for_remaining_tapes, TEST_PREFIX "ask_for_remaining_tapes"
9959 &setup.provide_uploading_tapes, TEST_PREFIX "provide_uploading_tapes"
9963 &setup.ask_for_using_api_server,TEST_PREFIX "ask_for_using_api_server"
9967 &setup.has_remaining_tapes, TEST_PREFIX "has_remaining_tapes"
9971 static struct TokenInfo editor_setup_tokens[] =
9975 &setup.editor.el_classic, "editor.el_classic"
9979 &setup.editor.el_custom, "editor.el_custom"
9983 &setup.editor.el_user_defined, "editor.el_user_defined"
9987 &setup.editor.el_dynamic, "editor.el_dynamic"
9991 &setup.editor.el_headlines, "editor.el_headlines"
9995 &setup.editor.show_element_token, "editor.show_element_token"
9999 &setup.editor.show_read_only_warning, "editor.show_read_only_warning"
10003 static struct TokenInfo editor_cascade_setup_tokens[] =
10007 &setup.editor_cascade.el_bd, "editor.cascade.el_bd"
10011 &setup.editor_cascade.el_bd_native, "editor.cascade.el_bd_native"
10015 &setup.editor_cascade.el_em, "editor.cascade.el_em"
10019 &setup.editor_cascade.el_emc, "editor.cascade.el_emc"
10023 &setup.editor_cascade.el_rnd, "editor.cascade.el_rnd"
10027 &setup.editor_cascade.el_sb, "editor.cascade.el_sb"
10031 &setup.editor_cascade.el_sp, "editor.cascade.el_sp"
10035 &setup.editor_cascade.el_dc, "editor.cascade.el_dc"
10039 &setup.editor_cascade.el_dx, "editor.cascade.el_dx"
10043 &setup.editor_cascade.el_mm, "editor.cascade.el_mm"
10047 &setup.editor_cascade.el_df, "editor.cascade.el_df"
10051 &setup.editor_cascade.el_chars, "editor.cascade.el_chars"
10055 &setup.editor_cascade.el_steel_chars, "editor.cascade.el_steel_chars"
10059 &setup.editor_cascade.el_ce, "editor.cascade.el_ce"
10063 &setup.editor_cascade.el_ge, "editor.cascade.el_ge"
10067 &setup.editor_cascade.el_es, "editor.cascade.el_es"
10071 &setup.editor_cascade.el_ref, "editor.cascade.el_ref"
10075 &setup.editor_cascade.el_user, "editor.cascade.el_user"
10079 &setup.editor_cascade.el_dynamic, "editor.cascade.el_dynamic"
10083 static struct TokenInfo shortcut_setup_tokens[] =
10087 &setup.shortcut.save_game, "shortcut.save_game"
10091 &setup.shortcut.load_game, "shortcut.load_game"
10095 &setup.shortcut.restart_game, "shortcut.restart_game"
10099 &setup.shortcut.pause_before_end, "shortcut.pause_before_end"
10103 &setup.shortcut.toggle_pause, "shortcut.toggle_pause"
10107 &setup.shortcut.focus_player[0], "shortcut.focus_player_1"
10111 &setup.shortcut.focus_player[1], "shortcut.focus_player_2"
10115 &setup.shortcut.focus_player[2], "shortcut.focus_player_3"
10119 &setup.shortcut.focus_player[3], "shortcut.focus_player_4"
10123 &setup.shortcut.focus_player_all, "shortcut.focus_player_all"
10127 &setup.shortcut.tape_eject, "shortcut.tape_eject"
10131 &setup.shortcut.tape_extra, "shortcut.tape_extra"
10135 &setup.shortcut.tape_stop, "shortcut.tape_stop"
10139 &setup.shortcut.tape_pause, "shortcut.tape_pause"
10143 &setup.shortcut.tape_record, "shortcut.tape_record"
10147 &setup.shortcut.tape_play, "shortcut.tape_play"
10151 &setup.shortcut.sound_simple, "shortcut.sound_simple"
10155 &setup.shortcut.sound_loops, "shortcut.sound_loops"
10159 &setup.shortcut.sound_music, "shortcut.sound_music"
10163 &setup.shortcut.snap_left, "shortcut.snap_left"
10167 &setup.shortcut.snap_right, "shortcut.snap_right"
10171 &setup.shortcut.snap_up, "shortcut.snap_up"
10175 &setup.shortcut.snap_down, "shortcut.snap_down"
10179 static struct SetupInputInfo setup_input;
10180 static struct TokenInfo player_setup_tokens[] =
10184 &setup_input.use_joystick, ".use_joystick"
10188 &setup_input.joy.device_name, ".joy.device_name"
10192 &setup_input.joy.xleft, ".joy.xleft"
10196 &setup_input.joy.xmiddle, ".joy.xmiddle"
10200 &setup_input.joy.xright, ".joy.xright"
10204 &setup_input.joy.yupper, ".joy.yupper"
10208 &setup_input.joy.ymiddle, ".joy.ymiddle"
10212 &setup_input.joy.ylower, ".joy.ylower"
10216 &setup_input.joy.snap, ".joy.snap_field"
10220 &setup_input.joy.drop, ".joy.place_bomb"
10224 &setup_input.key.left, ".key.move_left"
10228 &setup_input.key.right, ".key.move_right"
10232 &setup_input.key.up, ".key.move_up"
10236 &setup_input.key.down, ".key.move_down"
10240 &setup_input.key.snap, ".key.snap_field"
10244 &setup_input.key.drop, ".key.place_bomb"
10248 static struct TokenInfo system_setup_tokens[] =
10252 &setup.system.sdl_renderdriver, "system.sdl_renderdriver"
10256 &setup.system.sdl_videodriver, "system.sdl_videodriver"
10260 &setup.system.sdl_audiodriver, "system.sdl_audiodriver"
10264 &setup.system.audio_fragment_size, "system.audio_fragment_size"
10268 static struct TokenInfo internal_setup_tokens[] =
10272 &setup.internal.program_title, "program_title"
10276 &setup.internal.program_version, "program_version"
10280 &setup.internal.program_author, "program_author"
10284 &setup.internal.program_email, "program_email"
10288 &setup.internal.program_website, "program_website"
10292 &setup.internal.program_copyright, "program_copyright"
10296 &setup.internal.program_company, "program_company"
10300 &setup.internal.program_icon_file, "program_icon_file"
10304 &setup.internal.default_graphics_set, "default_graphics_set"
10308 &setup.internal.default_sounds_set, "default_sounds_set"
10312 &setup.internal.default_music_set, "default_music_set"
10316 &setup.internal.fallback_graphics_file, "fallback_graphics_file"
10320 &setup.internal.fallback_sounds_file, "fallback_sounds_file"
10324 &setup.internal.fallback_music_file, "fallback_music_file"
10328 &setup.internal.default_level_series, "default_level_series"
10332 &setup.internal.default_window_width, "default_window_width"
10336 &setup.internal.default_window_height, "default_window_height"
10340 &setup.internal.choose_from_top_leveldir, "choose_from_top_leveldir"
10344 &setup.internal.show_scaling_in_title, "show_scaling_in_title"
10348 &setup.internal.create_user_levelset, "create_user_levelset"
10352 &setup.internal.info_screens_from_main, "info_screens_from_main"
10356 &setup.internal.menu_game, "menu_game"
10360 &setup.internal.menu_engines, "menu_engines"
10364 &setup.internal.menu_editor, "menu_editor"
10368 &setup.internal.menu_graphics, "menu_graphics"
10372 &setup.internal.menu_sound, "menu_sound"
10376 &setup.internal.menu_artwork, "menu_artwork"
10380 &setup.internal.menu_input, "menu_input"
10384 &setup.internal.menu_touch, "menu_touch"
10388 &setup.internal.menu_shortcuts, "menu_shortcuts"
10392 &setup.internal.menu_exit, "menu_exit"
10396 &setup.internal.menu_save_and_exit, "menu_save_and_exit"
10400 &setup.internal.menu_shortcuts_various, "menu_shortcuts_various"
10404 &setup.internal.menu_shortcuts_focus, "menu_shortcuts_focus"
10408 &setup.internal.menu_shortcuts_tape, "menu_shortcuts_tape"
10412 &setup.internal.menu_shortcuts_sound, "menu_shortcuts_sound"
10416 &setup.internal.menu_shortcuts_snap, "menu_shortcuts_snap"
10420 &setup.internal.info_title, "info_title"
10424 &setup.internal.info_elements, "info_elements"
10428 &setup.internal.info_music, "info_music"
10432 &setup.internal.info_credits, "info_credits"
10436 &setup.internal.info_program, "info_program"
10440 &setup.internal.info_version, "info_version"
10444 &setup.internal.info_levelset, "info_levelset"
10448 &setup.internal.info_exit, "info_exit"
10452 static struct TokenInfo debug_setup_tokens[] =
10456 &setup.debug.frame_delay[0], "debug.frame_delay_0"
10460 &setup.debug.frame_delay[1], "debug.frame_delay_1"
10464 &setup.debug.frame_delay[2], "debug.frame_delay_2"
10468 &setup.debug.frame_delay[3], "debug.frame_delay_3"
10472 &setup.debug.frame_delay[4], "debug.frame_delay_4"
10476 &setup.debug.frame_delay[5], "debug.frame_delay_5"
10480 &setup.debug.frame_delay[6], "debug.frame_delay_6"
10484 &setup.debug.frame_delay[7], "debug.frame_delay_7"
10488 &setup.debug.frame_delay[8], "debug.frame_delay_8"
10492 &setup.debug.frame_delay[9], "debug.frame_delay_9"
10496 &setup.debug.frame_delay_key[0], "debug.key.frame_delay_0"
10500 &setup.debug.frame_delay_key[1], "debug.key.frame_delay_1"
10504 &setup.debug.frame_delay_key[2], "debug.key.frame_delay_2"
10508 &setup.debug.frame_delay_key[3], "debug.key.frame_delay_3"
10512 &setup.debug.frame_delay_key[4], "debug.key.frame_delay_4"
10516 &setup.debug.frame_delay_key[5], "debug.key.frame_delay_5"
10520 &setup.debug.frame_delay_key[6], "debug.key.frame_delay_6"
10524 &setup.debug.frame_delay_key[7], "debug.key.frame_delay_7"
10528 &setup.debug.frame_delay_key[8], "debug.key.frame_delay_8"
10532 &setup.debug.frame_delay_key[9], "debug.key.frame_delay_9"
10536 &setup.debug.frame_delay_use_mod_key, "debug.frame_delay.use_mod_key"},
10539 &setup.debug.frame_delay_game_only, "debug.frame_delay.game_only"
10543 &setup.debug.show_frames_per_second, "debug.show_frames_per_second"
10547 &setup.debug.xsn_mode, "debug.xsn_mode"
10551 &setup.debug.xsn_percent, "debug.xsn_percent"
10555 static struct TokenInfo options_setup_tokens[] =
10559 &setup.options.verbose, "options.verbose"
10563 &setup.options.debug, "options.debug"
10567 &setup.options.debug_mode, "options.debug_mode"
10571 static void setSetupInfoToDefaults(struct SetupInfo *si)
10575 si->player_name = getStringCopy(getDefaultUserName(user.nr));
10577 si->multiple_users = TRUE;
10580 si->sound_loops = TRUE;
10581 si->sound_music = TRUE;
10582 si->sound_simple = TRUE;
10584 si->global_animations = TRUE;
10585 si->scroll_delay = TRUE;
10586 si->forced_scroll_delay = FALSE;
10587 si->scroll_delay_value = STD_SCROLL_DELAY;
10588 si->engine_snapshot_mode = getStringCopy(STR_SNAPSHOT_MODE_DEFAULT);
10589 si->engine_snapshot_memory = SNAPSHOT_MEMORY_DEFAULT;
10590 si->fade_screens = TRUE;
10591 si->autorecord = TRUE;
10592 si->autorecord_after_replay = TRUE;
10593 si->auto_pause_on_start = FALSE;
10594 si->show_titlescreen = TRUE;
10595 si->quick_doors = FALSE;
10596 si->team_mode = FALSE;
10597 si->handicap = TRUE;
10598 si->skip_levels = TRUE;
10599 si->increment_levels = TRUE;
10600 si->auto_play_next_level = TRUE;
10601 si->count_score_after_game = TRUE;
10602 si->show_scores_after_game = TRUE;
10603 si->time_limit = TRUE;
10604 si->fullscreen = FALSE;
10605 si->window_scaling_percent = STD_WINDOW_SCALING_PERCENT;
10606 si->window_scaling_quality = getStringCopy(SCALING_QUALITY_DEFAULT);
10607 si->screen_rendering_mode = getStringCopy(STR_SPECIAL_RENDERING_DEFAULT);
10608 si->vsync_mode = getStringCopy(STR_VSYNC_MODE_DEFAULT);
10609 si->ask_on_escape = TRUE;
10610 si->ask_on_escape_editor = TRUE;
10611 si->ask_on_game_over = TRUE;
10612 si->ask_on_quit_game = TRUE;
10613 si->ask_on_quit_program = TRUE;
10614 si->quick_switch = FALSE;
10615 si->input_on_focus = FALSE;
10616 si->prefer_aga_graphics = TRUE;
10617 si->prefer_lowpass_sounds = FALSE;
10618 si->prefer_extra_panel_items = TRUE;
10619 si->game_speed_extended = FALSE;
10620 si->game_frame_delay = GAME_FRAME_DELAY;
10621 si->sp_show_border_elements = FALSE;
10622 si->small_game_graphics = FALSE;
10623 si->show_load_save_buttons = FALSE;
10624 si->show_undo_redo_buttons = FALSE;
10625 si->scores_in_highscore_list = getStringCopy(STR_SCORES_TYPE_DEFAULT);
10627 si->graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
10628 si->sounds_set = getStringCopy(SND_CLASSIC_SUBDIR);
10629 si->music_set = getStringCopy(MUS_CLASSIC_SUBDIR);
10631 si->override_level_graphics = FALSE;
10632 si->override_level_sounds = FALSE;
10633 si->override_level_music = FALSE;
10635 si->volume_simple = 100; // percent
10636 si->volume_loops = 100; // percent
10637 si->volume_music = 100; // percent
10639 si->network_mode = FALSE;
10640 si->network_player_nr = 0; // first player
10641 si->network_server_hostname = getStringCopy(STR_NETWORK_AUTO_DETECT);
10643 si->touch.control_type = getStringCopy(TOUCH_CONTROL_DEFAULT);
10644 si->touch.move_distance = TOUCH_MOVE_DISTANCE_DEFAULT; // percent
10645 si->touch.drop_distance = TOUCH_DROP_DISTANCE_DEFAULT; // percent
10646 si->touch.transparency = TOUCH_TRANSPARENCY_DEFAULT; // percent
10647 si->touch.draw_outlined = TRUE;
10648 si->touch.draw_pressed = TRUE;
10650 for (i = 0; i < 2; i++)
10652 char *default_grid_button[6][2] =
10658 { "111222", " vv " },
10659 { "111222", " vv " }
10661 int grid_xsize = DEFAULT_GRID_XSIZE(i);
10662 int grid_ysize = DEFAULT_GRID_YSIZE(i);
10663 int min_xsize = MIN(6, grid_xsize);
10664 int min_ysize = MIN(6, grid_ysize);
10665 int startx = grid_xsize - min_xsize;
10666 int starty = grid_ysize - min_ysize;
10669 // virtual buttons grid can only be set to defaults if video is initialized
10670 // (this will be repeated if virtual buttons are not loaded from setup file)
10671 if (video.initialized)
10673 si->touch.grid_xsize[i] = grid_xsize;
10674 si->touch.grid_ysize[i] = grid_ysize;
10678 si->touch.grid_xsize[i] = -1;
10679 si->touch.grid_ysize[i] = -1;
10682 for (x = 0; x < MAX_GRID_XSIZE; x++)
10683 for (y = 0; y < MAX_GRID_YSIZE; y++)
10684 si->touch.grid_button[i][x][y] = CHAR_GRID_BUTTON_NONE;
10686 for (x = 0; x < min_xsize; x++)
10687 for (y = 0; y < min_ysize; y++)
10688 si->touch.grid_button[i][x][starty + y] =
10689 default_grid_button[y][0][x];
10691 for (x = 0; x < min_xsize; x++)
10692 for (y = 0; y < min_ysize; y++)
10693 si->touch.grid_button[i][startx + x][starty + y] =
10694 default_grid_button[y][1][x];
10697 si->touch.grid_initialized = video.initialized;
10699 si->touch.overlay_buttons = FALSE;
10701 si->editor.el_boulderdash = TRUE;
10702 si->editor.el_boulderdash_native = TRUE;
10703 si->editor.el_emerald_mine = TRUE;
10704 si->editor.el_emerald_mine_club = TRUE;
10705 si->editor.el_more = TRUE;
10706 si->editor.el_sokoban = TRUE;
10707 si->editor.el_supaplex = TRUE;
10708 si->editor.el_diamond_caves = TRUE;
10709 si->editor.el_dx_boulderdash = TRUE;
10711 si->editor.el_mirror_magic = TRUE;
10712 si->editor.el_deflektor = TRUE;
10714 si->editor.el_chars = TRUE;
10715 si->editor.el_steel_chars = TRUE;
10717 si->editor.el_classic = TRUE;
10718 si->editor.el_custom = TRUE;
10720 si->editor.el_user_defined = FALSE;
10721 si->editor.el_dynamic = TRUE;
10723 si->editor.el_headlines = TRUE;
10725 si->editor.show_element_token = FALSE;
10727 si->editor.show_read_only_warning = TRUE;
10729 si->editor.use_template_for_new_levels = TRUE;
10731 si->shortcut.save_game = DEFAULT_KEY_SAVE_GAME;
10732 si->shortcut.load_game = DEFAULT_KEY_LOAD_GAME;
10733 si->shortcut.restart_game = DEFAULT_KEY_RESTART_GAME;
10734 si->shortcut.pause_before_end = DEFAULT_KEY_PAUSE_BEFORE_END;
10735 si->shortcut.toggle_pause = DEFAULT_KEY_TOGGLE_PAUSE;
10737 si->shortcut.focus_player[0] = DEFAULT_KEY_FOCUS_PLAYER_1;
10738 si->shortcut.focus_player[1] = DEFAULT_KEY_FOCUS_PLAYER_2;
10739 si->shortcut.focus_player[2] = DEFAULT_KEY_FOCUS_PLAYER_3;
10740 si->shortcut.focus_player[3] = DEFAULT_KEY_FOCUS_PLAYER_4;
10741 si->shortcut.focus_player_all = DEFAULT_KEY_FOCUS_PLAYER_ALL;
10743 si->shortcut.tape_eject = DEFAULT_KEY_TAPE_EJECT;
10744 si->shortcut.tape_extra = DEFAULT_KEY_TAPE_EXTRA;
10745 si->shortcut.tape_stop = DEFAULT_KEY_TAPE_STOP;
10746 si->shortcut.tape_pause = DEFAULT_KEY_TAPE_PAUSE;
10747 si->shortcut.tape_record = DEFAULT_KEY_TAPE_RECORD;
10748 si->shortcut.tape_play = DEFAULT_KEY_TAPE_PLAY;
10750 si->shortcut.sound_simple = DEFAULT_KEY_SOUND_SIMPLE;
10751 si->shortcut.sound_loops = DEFAULT_KEY_SOUND_LOOPS;
10752 si->shortcut.sound_music = DEFAULT_KEY_SOUND_MUSIC;
10754 si->shortcut.snap_left = DEFAULT_KEY_SNAP_LEFT;
10755 si->shortcut.snap_right = DEFAULT_KEY_SNAP_RIGHT;
10756 si->shortcut.snap_up = DEFAULT_KEY_SNAP_UP;
10757 si->shortcut.snap_down = DEFAULT_KEY_SNAP_DOWN;
10759 for (i = 0; i < MAX_PLAYERS; i++)
10761 si->input[i].use_joystick = FALSE;
10762 si->input[i].joy.device_name = getStringCopy(getDeviceNameFromJoystickNr(i));
10763 si->input[i].joy.xleft = JOYSTICK_XLEFT;
10764 si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
10765 si->input[i].joy.xright = JOYSTICK_XRIGHT;
10766 si->input[i].joy.yupper = JOYSTICK_YUPPER;
10767 si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
10768 si->input[i].joy.ylower = JOYSTICK_YLOWER;
10769 si->input[i].joy.snap = (i == 0 ? JOY_BUTTON_1 : 0);
10770 si->input[i].joy.drop = (i == 0 ? JOY_BUTTON_2 : 0);
10771 si->input[i].key.left = (i == 0 ? DEFAULT_KEY_LEFT : KSYM_UNDEFINED);
10772 si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KSYM_UNDEFINED);
10773 si->input[i].key.up = (i == 0 ? DEFAULT_KEY_UP : KSYM_UNDEFINED);
10774 si->input[i].key.down = (i == 0 ? DEFAULT_KEY_DOWN : KSYM_UNDEFINED);
10775 si->input[i].key.snap = (i == 0 ? DEFAULT_KEY_SNAP : KSYM_UNDEFINED);
10776 si->input[i].key.drop = (i == 0 ? DEFAULT_KEY_DROP : KSYM_UNDEFINED);
10779 si->system.sdl_renderdriver = getStringCopy(ARG_DEFAULT);
10780 si->system.sdl_videodriver = getStringCopy(ARG_DEFAULT);
10781 si->system.sdl_audiodriver = getStringCopy(ARG_DEFAULT);
10782 si->system.audio_fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
10784 si->internal.program_title = getStringCopy(PROGRAM_TITLE_STRING);
10785 si->internal.program_version = getStringCopy(getProgramRealVersionString());
10786 si->internal.program_author = getStringCopy(PROGRAM_AUTHOR_STRING);
10787 si->internal.program_email = getStringCopy(PROGRAM_EMAIL_STRING);
10788 si->internal.program_website = getStringCopy(PROGRAM_WEBSITE_STRING);
10789 si->internal.program_copyright = getStringCopy(PROGRAM_COPYRIGHT_STRING);
10790 si->internal.program_company = getStringCopy(PROGRAM_COMPANY_STRING);
10792 si->internal.program_icon_file = getStringCopy(PROGRAM_ICON_FILENAME);
10794 si->internal.default_graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
10795 si->internal.default_sounds_set = getStringCopy(SND_CLASSIC_SUBDIR);
10796 si->internal.default_music_set = getStringCopy(MUS_CLASSIC_SUBDIR);
10798 si->internal.fallback_graphics_file = getStringCopy(UNDEFINED_FILENAME);
10799 si->internal.fallback_sounds_file = getStringCopy(UNDEFINED_FILENAME);
10800 si->internal.fallback_music_file = getStringCopy(UNDEFINED_FILENAME);
10802 si->internal.default_level_series = getStringCopy(UNDEFINED_LEVELSET);
10803 si->internal.choose_from_top_leveldir = FALSE;
10804 si->internal.show_scaling_in_title = TRUE;
10805 si->internal.create_user_levelset = TRUE;
10806 si->internal.info_screens_from_main = FALSE;
10808 si->internal.default_window_width = WIN_XSIZE_DEFAULT;
10809 si->internal.default_window_height = WIN_YSIZE_DEFAULT;
10811 si->debug.frame_delay[0] = DEFAULT_FRAME_DELAY_0;
10812 si->debug.frame_delay[1] = DEFAULT_FRAME_DELAY_1;
10813 si->debug.frame_delay[2] = DEFAULT_FRAME_DELAY_2;
10814 si->debug.frame_delay[3] = DEFAULT_FRAME_DELAY_3;
10815 si->debug.frame_delay[4] = DEFAULT_FRAME_DELAY_4;
10816 si->debug.frame_delay[5] = DEFAULT_FRAME_DELAY_5;
10817 si->debug.frame_delay[6] = DEFAULT_FRAME_DELAY_6;
10818 si->debug.frame_delay[7] = DEFAULT_FRAME_DELAY_7;
10819 si->debug.frame_delay[8] = DEFAULT_FRAME_DELAY_8;
10820 si->debug.frame_delay[9] = DEFAULT_FRAME_DELAY_9;
10822 si->debug.frame_delay_key[0] = DEFAULT_KEY_FRAME_DELAY_0;
10823 si->debug.frame_delay_key[1] = DEFAULT_KEY_FRAME_DELAY_1;
10824 si->debug.frame_delay_key[2] = DEFAULT_KEY_FRAME_DELAY_2;
10825 si->debug.frame_delay_key[3] = DEFAULT_KEY_FRAME_DELAY_3;
10826 si->debug.frame_delay_key[4] = DEFAULT_KEY_FRAME_DELAY_4;
10827 si->debug.frame_delay_key[5] = DEFAULT_KEY_FRAME_DELAY_5;
10828 si->debug.frame_delay_key[6] = DEFAULT_KEY_FRAME_DELAY_6;
10829 si->debug.frame_delay_key[7] = DEFAULT_KEY_FRAME_DELAY_7;
10830 si->debug.frame_delay_key[8] = DEFAULT_KEY_FRAME_DELAY_8;
10831 si->debug.frame_delay_key[9] = DEFAULT_KEY_FRAME_DELAY_9;
10833 si->debug.frame_delay_use_mod_key = DEFAULT_FRAME_DELAY_USE_MOD_KEY;
10834 si->debug.frame_delay_game_only = DEFAULT_FRAME_DELAY_GAME_ONLY;
10836 si->debug.show_frames_per_second = FALSE;
10838 si->debug.xsn_mode = AUTO;
10839 si->debug.xsn_percent = 0;
10841 si->options.verbose = FALSE;
10842 si->options.debug = FALSE;
10843 si->options.debug_mode = getStringCopy(ARG_UNDEFINED_STRING);
10845 #if defined(PLATFORM_ANDROID)
10846 si->fullscreen = TRUE;
10847 si->touch.overlay_buttons = TRUE;
10850 setHideSetupEntry(&setup.debug.xsn_mode);
10853 static void setSetupInfoToDefaults_AutoSetup(struct SetupInfo *si)
10855 si->auto_setup.editor_zoom_tilesize = MINI_TILESIZE;
10858 static void setSetupInfoToDefaults_ServerSetup(struct SetupInfo *si)
10860 si->player_uuid = NULL; // (will be set later)
10861 si->player_version = 1; // (will be set later)
10863 si->use_api_server = TRUE;
10864 si->api_server_hostname = getStringCopy(API_SERVER_HOSTNAME);
10865 si->api_server_password = getStringCopy(UNDEFINED_PASSWORD);
10866 si->ask_for_uploading_tapes = TRUE;
10867 si->ask_for_remaining_tapes = FALSE;
10868 si->provide_uploading_tapes = TRUE;
10869 si->ask_for_using_api_server = TRUE;
10870 si->has_remaining_tapes = FALSE;
10873 static void setSetupInfoToDefaults_EditorCascade(struct SetupInfo *si)
10875 si->editor_cascade.el_bd = TRUE;
10876 si->editor_cascade.el_bd_native = TRUE;
10877 si->editor_cascade.el_em = TRUE;
10878 si->editor_cascade.el_emc = TRUE;
10879 si->editor_cascade.el_rnd = TRUE;
10880 si->editor_cascade.el_sb = TRUE;
10881 si->editor_cascade.el_sp = TRUE;
10882 si->editor_cascade.el_dc = TRUE;
10883 si->editor_cascade.el_dx = TRUE;
10885 si->editor_cascade.el_mm = TRUE;
10886 si->editor_cascade.el_df = TRUE;
10888 si->editor_cascade.el_chars = FALSE;
10889 si->editor_cascade.el_steel_chars = FALSE;
10890 si->editor_cascade.el_ce = FALSE;
10891 si->editor_cascade.el_ge = FALSE;
10892 si->editor_cascade.el_es = FALSE;
10893 si->editor_cascade.el_ref = FALSE;
10894 si->editor_cascade.el_user = FALSE;
10895 si->editor_cascade.el_dynamic = FALSE;
10898 #define MAX_HIDE_SETUP_TOKEN_SIZE 20
10900 static char *getHideSetupToken(void *setup_value)
10902 static char hide_setup_token[MAX_HIDE_SETUP_TOKEN_SIZE];
10904 if (setup_value != NULL)
10905 snprintf(hide_setup_token, MAX_HIDE_SETUP_TOKEN_SIZE, "%p", setup_value);
10907 return hide_setup_token;
10910 void setHideSetupEntry(void *setup_value)
10912 char *hide_setup_token = getHideSetupToken(setup_value);
10914 if (hide_setup_hash == NULL)
10915 hide_setup_hash = newSetupFileHash();
10917 if (setup_value != NULL)
10918 setHashEntry(hide_setup_hash, hide_setup_token, "");
10921 void removeHideSetupEntry(void *setup_value)
10923 char *hide_setup_token = getHideSetupToken(setup_value);
10925 if (setup_value != NULL)
10926 removeHashEntry(hide_setup_hash, hide_setup_token);
10929 boolean hideSetupEntry(void *setup_value)
10931 char *hide_setup_token = getHideSetupToken(setup_value);
10933 return (setup_value != NULL &&
10934 getHashEntry(hide_setup_hash, hide_setup_token) != NULL);
10937 static void setSetupInfoFromTokenText(SetupFileHash *setup_file_hash,
10938 struct TokenInfo *token_info,
10939 int token_nr, char *token_text)
10941 char *token_hide_text = getStringCat2(token_text, ".hide");
10942 char *token_hide_value = getHashEntry(setup_file_hash, token_hide_text);
10944 // set the value of this setup option in the setup option structure
10945 setSetupInfo(token_info, token_nr, getHashEntry(setup_file_hash, token_text));
10947 // check if this setup option should be hidden in the setup menu
10948 if (token_hide_value != NULL && get_boolean_from_string(token_hide_value))
10949 setHideSetupEntry(token_info[token_nr].value);
10951 free(token_hide_text);
10954 static void setSetupInfoFromTokenInfo(SetupFileHash *setup_file_hash,
10955 struct TokenInfo *token_info,
10958 setSetupInfoFromTokenText(setup_file_hash, token_info, token_nr,
10959 token_info[token_nr].text);
10962 static void decodeSetupFileHash_Default(SetupFileHash *setup_file_hash)
10966 if (!setup_file_hash)
10969 for (i = 0; i < ARRAY_SIZE(global_setup_tokens); i++)
10970 setSetupInfoFromTokenInfo(setup_file_hash, global_setup_tokens, i);
10972 setup.touch.grid_initialized = TRUE;
10973 for (i = 0; i < 2; i++)
10975 int grid_xsize = setup.touch.grid_xsize[i];
10976 int grid_ysize = setup.touch.grid_ysize[i];
10979 // if virtual buttons are not loaded from setup file, repeat initializing
10980 // virtual buttons grid with default values later when video is initialized
10981 if (grid_xsize == -1 ||
10984 setup.touch.grid_initialized = FALSE;
10989 for (y = 0; y < grid_ysize; y++)
10991 char token_string[MAX_LINE_LEN];
10993 sprintf(token_string, "touch.virtual_buttons.%d.%02d", i, y);
10995 char *value_string = getHashEntry(setup_file_hash, token_string);
10997 if (value_string == NULL)
11000 for (x = 0; x < grid_xsize; x++)
11002 char c = value_string[x];
11004 setup.touch.grid_button[i][x][y] =
11005 (c == '.' ? CHAR_GRID_BUTTON_NONE : c);
11010 for (i = 0; i < ARRAY_SIZE(editor_setup_tokens); i++)
11011 setSetupInfoFromTokenInfo(setup_file_hash, editor_setup_tokens, i);
11013 for (i = 0; i < ARRAY_SIZE(shortcut_setup_tokens); i++)
11014 setSetupInfoFromTokenInfo(setup_file_hash, shortcut_setup_tokens, i);
11016 for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
11020 sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
11022 setup_input = setup.input[pnr];
11023 for (i = 0; i < ARRAY_SIZE(player_setup_tokens); i++)
11025 char full_token[100];
11027 sprintf(full_token, "%s%s", prefix, player_setup_tokens[i].text);
11028 setSetupInfoFromTokenText(setup_file_hash, player_setup_tokens, i,
11031 setup.input[pnr] = setup_input;
11034 for (i = 0; i < ARRAY_SIZE(system_setup_tokens); i++)
11035 setSetupInfoFromTokenInfo(setup_file_hash, system_setup_tokens, i);
11037 for (i = 0; i < ARRAY_SIZE(internal_setup_tokens); i++)
11038 setSetupInfoFromTokenInfo(setup_file_hash, internal_setup_tokens, i);
11040 for (i = 0; i < ARRAY_SIZE(debug_setup_tokens); i++)
11041 setSetupInfoFromTokenInfo(setup_file_hash, debug_setup_tokens, i);
11043 for (i = 0; i < ARRAY_SIZE(options_setup_tokens); i++)
11044 setSetupInfoFromTokenInfo(setup_file_hash, options_setup_tokens, i);
11046 setHideRelatedSetupEntries();
11049 static void decodeSetupFileHash_AutoSetup(SetupFileHash *setup_file_hash)
11053 if (!setup_file_hash)
11056 for (i = 0; i < ARRAY_SIZE(auto_setup_tokens); i++)
11057 setSetupInfo(auto_setup_tokens, i,
11058 getHashEntry(setup_file_hash,
11059 auto_setup_tokens[i].text));
11062 static void decodeSetupFileHash_ServerSetup(SetupFileHash *setup_file_hash)
11066 if (!setup_file_hash)
11069 for (i = 0; i < ARRAY_SIZE(server_setup_tokens); i++)
11070 setSetupInfo(server_setup_tokens, i,
11071 getHashEntry(setup_file_hash,
11072 server_setup_tokens[i].text));
11075 static void decodeSetupFileHash_EditorCascade(SetupFileHash *setup_file_hash)
11079 if (!setup_file_hash)
11082 for (i = 0; i < ARRAY_SIZE(editor_cascade_setup_tokens); i++)
11083 setSetupInfo(editor_cascade_setup_tokens, i,
11084 getHashEntry(setup_file_hash,
11085 editor_cascade_setup_tokens[i].text));
11088 void LoadUserNames(void)
11090 int last_user_nr = user.nr;
11093 if (global.user_names != NULL)
11095 for (i = 0; i < MAX_PLAYER_NAMES; i++)
11096 checked_free(global.user_names[i]);
11098 checked_free(global.user_names);
11101 global.user_names = checked_calloc(MAX_PLAYER_NAMES * sizeof(char *));
11103 for (i = 0; i < MAX_PLAYER_NAMES; i++)
11107 SetupFileHash *setup_file_hash = loadSetupFileHash(getSetupFilename());
11109 if (setup_file_hash)
11111 char *player_name = getHashEntry(setup_file_hash, "player_name");
11113 global.user_names[i] = getFixedUserName(player_name);
11115 freeSetupFileHash(setup_file_hash);
11118 if (global.user_names[i] == NULL)
11119 global.user_names[i] = getStringCopy(getDefaultUserName(i));
11122 user.nr = last_user_nr;
11125 void LoadSetupFromFilename(char *filename)
11127 SetupFileHash *setup_file_hash = loadSetupFileHash(filename);
11129 if (setup_file_hash)
11131 decodeSetupFileHash_Default(setup_file_hash);
11133 freeSetupFileHash(setup_file_hash);
11137 Debug("setup", "using default setup values");
11141 static void LoadSetup_SpecialPostProcessing(void)
11143 char *player_name_new;
11145 // needed to work around problems with fixed length strings
11146 player_name_new = getFixedUserName(setup.player_name);
11147 free(setup.player_name);
11148 setup.player_name = player_name_new;
11150 // "scroll_delay: on(3) / off(0)" was replaced by scroll delay value
11151 if (setup.scroll_delay == FALSE)
11153 setup.scroll_delay_value = MIN_SCROLL_DELAY;
11154 setup.scroll_delay = TRUE; // now always "on"
11157 // make sure that scroll delay value stays inside valid range
11158 setup.scroll_delay_value =
11159 MIN(MAX(MIN_SCROLL_DELAY, setup.scroll_delay_value), MAX_SCROLL_DELAY);
11162 void LoadSetup_Default(void)
11166 // always start with reliable default values
11167 setSetupInfoToDefaults(&setup);
11169 // try to load setup values from default setup file
11170 filename = getDefaultSetupFilename();
11172 if (fileExists(filename))
11173 LoadSetupFromFilename(filename);
11175 // try to load setup values from platform setup file
11176 filename = getPlatformSetupFilename();
11178 if (fileExists(filename))
11179 LoadSetupFromFilename(filename);
11181 // try to load setup values from user setup file
11182 filename = getSetupFilename();
11184 LoadSetupFromFilename(filename);
11186 LoadSetup_SpecialPostProcessing();
11189 void LoadSetup_AutoSetup(void)
11191 char *filename = getPath2(getSetupDir(), AUTOSETUP_FILENAME);
11192 SetupFileHash *setup_file_hash = NULL;
11194 // always start with reliable default values
11195 setSetupInfoToDefaults_AutoSetup(&setup);
11197 setup_file_hash = loadSetupFileHash(filename);
11199 if (setup_file_hash)
11201 decodeSetupFileHash_AutoSetup(setup_file_hash);
11203 freeSetupFileHash(setup_file_hash);
11209 void LoadSetup_ServerSetup(void)
11211 char *filename = getPath2(getSetupDir(), SERVERSETUP_FILENAME);
11212 SetupFileHash *setup_file_hash = NULL;
11214 // always start with reliable default values
11215 setSetupInfoToDefaults_ServerSetup(&setup);
11217 setup_file_hash = loadSetupFileHash(filename);
11219 if (setup_file_hash)
11221 decodeSetupFileHash_ServerSetup(setup_file_hash);
11223 freeSetupFileHash(setup_file_hash);
11228 if (setup.player_uuid == NULL)
11230 // player UUID does not yet exist in setup file
11231 setup.player_uuid = getStringCopy(getUUID());
11232 setup.player_version = 2;
11234 SaveSetup_ServerSetup();
11238 void LoadSetup_EditorCascade(void)
11240 char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
11241 SetupFileHash *setup_file_hash = NULL;
11243 // always start with reliable default values
11244 setSetupInfoToDefaults_EditorCascade(&setup);
11246 setup_file_hash = loadSetupFileHash(filename);
11248 if (setup_file_hash)
11250 decodeSetupFileHash_EditorCascade(setup_file_hash);
11252 freeSetupFileHash(setup_file_hash);
11258 void LoadSetup(void)
11260 LoadSetup_Default();
11261 LoadSetup_AutoSetup();
11262 LoadSetup_ServerSetup();
11263 LoadSetup_EditorCascade();
11266 static void addGameControllerMappingToHash(SetupFileHash *mappings_hash,
11267 char *mapping_line)
11269 char mapping_guid[MAX_LINE_LEN];
11270 char *mapping_start, *mapping_end;
11272 // get GUID from game controller mapping line: copy complete line
11273 strncpy(mapping_guid, mapping_line, MAX_LINE_LEN - 1);
11274 mapping_guid[MAX_LINE_LEN - 1] = '\0';
11276 // get GUID from game controller mapping line: cut after GUID part
11277 mapping_start = strchr(mapping_guid, ',');
11278 if (mapping_start != NULL)
11279 *mapping_start = '\0';
11281 // cut newline from game controller mapping line
11282 mapping_end = strchr(mapping_line, '\n');
11283 if (mapping_end != NULL)
11284 *mapping_end = '\0';
11286 // add mapping entry to game controller mappings hash
11287 setHashEntry(mappings_hash, mapping_guid, mapping_line);
11290 static void LoadSetup_ReadGameControllerMappings(SetupFileHash *mappings_hash,
11295 if (!(file = fopen(filename, MODE_READ)))
11297 Warn("cannot read game controller mappings file '%s'", filename);
11302 while (!feof(file))
11304 char line[MAX_LINE_LEN];
11306 if (!fgets(line, MAX_LINE_LEN, file))
11309 addGameControllerMappingToHash(mappings_hash, line);
11315 void SaveSetup_Default(void)
11317 char *filename = getSetupFilename();
11321 InitUserDataDirectory();
11323 if (!(file = fopen(filename, MODE_WRITE)))
11325 Warn("cannot write setup file '%s'", filename);
11330 fprintFileHeader(file, SETUP_FILENAME);
11332 for (i = 0; i < ARRAY_SIZE(global_setup_tokens); i++)
11334 // just to make things nicer :)
11335 if (global_setup_tokens[i].value == &setup.multiple_users ||
11336 global_setup_tokens[i].value == &setup.sound ||
11337 global_setup_tokens[i].value == &setup.graphics_set ||
11338 global_setup_tokens[i].value == &setup.volume_simple ||
11339 global_setup_tokens[i].value == &setup.network_mode ||
11340 global_setup_tokens[i].value == &setup.touch.control_type ||
11341 global_setup_tokens[i].value == &setup.touch.grid_xsize[0] ||
11342 global_setup_tokens[i].value == &setup.touch.grid_xsize[1])
11343 fprintf(file, "\n");
11345 fprintf(file, "%s\n", getSetupLine(global_setup_tokens, "", i));
11348 for (i = 0; i < 2; i++)
11350 int grid_xsize = setup.touch.grid_xsize[i];
11351 int grid_ysize = setup.touch.grid_ysize[i];
11354 fprintf(file, "\n");
11356 for (y = 0; y < grid_ysize; y++)
11358 char token_string[MAX_LINE_LEN];
11359 char value_string[MAX_LINE_LEN];
11361 sprintf(token_string, "touch.virtual_buttons.%d.%02d", i, y);
11363 for (x = 0; x < grid_xsize; x++)
11365 char c = setup.touch.grid_button[i][x][y];
11367 value_string[x] = (c == CHAR_GRID_BUTTON_NONE ? '.' : c);
11370 value_string[grid_xsize] = '\0';
11372 fprintf(file, "%s\n", getFormattedSetupEntry(token_string, value_string));
11376 fprintf(file, "\n");
11377 for (i = 0; i < ARRAY_SIZE(editor_setup_tokens); i++)
11378 fprintf(file, "%s\n", getSetupLine(editor_setup_tokens, "", i));
11380 fprintf(file, "\n");
11381 for (i = 0; i < ARRAY_SIZE(shortcut_setup_tokens); i++)
11382 fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
11384 for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
11388 sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
11389 fprintf(file, "\n");
11391 setup_input = setup.input[pnr];
11392 for (i = 0; i < ARRAY_SIZE(player_setup_tokens); i++)
11393 fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
11396 fprintf(file, "\n");
11397 for (i = 0; i < ARRAY_SIZE(system_setup_tokens); i++)
11398 fprintf(file, "%s\n", getSetupLine(system_setup_tokens, "", i));
11400 // (internal setup values not saved to user setup file)
11402 fprintf(file, "\n");
11403 for (i = 0; i < ARRAY_SIZE(debug_setup_tokens); i++)
11404 if (!strPrefix(debug_setup_tokens[i].text, "debug.xsn_") ||
11405 setup.debug.xsn_mode != AUTO)
11406 fprintf(file, "%s\n", getSetupLine(debug_setup_tokens, "", i));
11408 fprintf(file, "\n");
11409 for (i = 0; i < ARRAY_SIZE(options_setup_tokens); i++)
11410 fprintf(file, "%s\n", getSetupLine(options_setup_tokens, "", i));
11414 SetFilePermissions(filename, PERMS_PRIVATE);
11417 void SaveSetup_AutoSetup(void)
11419 char *filename = getPath2(getSetupDir(), AUTOSETUP_FILENAME);
11423 InitUserDataDirectory();
11425 if (!(file = fopen(filename, MODE_WRITE)))
11427 Warn("cannot write auto setup file '%s'", filename);
11434 fprintFileHeader(file, AUTOSETUP_FILENAME);
11436 for (i = 0; i < ARRAY_SIZE(auto_setup_tokens); i++)
11437 fprintf(file, "%s\n", getSetupLine(auto_setup_tokens, "", i));
11441 SetFilePermissions(filename, PERMS_PRIVATE);
11446 void SaveSetup_ServerSetup(void)
11448 char *filename = getPath2(getSetupDir(), SERVERSETUP_FILENAME);
11452 InitUserDataDirectory();
11454 if (!(file = fopen(filename, MODE_WRITE)))
11456 Warn("cannot write server setup file '%s'", filename);
11463 fprintFileHeader(file, SERVERSETUP_FILENAME);
11465 for (i = 0; i < ARRAY_SIZE(server_setup_tokens); i++)
11467 // just to make things nicer :)
11468 if (server_setup_tokens[i].value == &setup.use_api_server)
11469 fprintf(file, "\n");
11471 fprintf(file, "%s\n", getSetupLine(server_setup_tokens, "", i));
11476 SetFilePermissions(filename, PERMS_PRIVATE);
11481 void SaveSetup_EditorCascade(void)
11483 char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
11487 InitUserDataDirectory();
11489 if (!(file = fopen(filename, MODE_WRITE)))
11491 Warn("cannot write editor cascade state file '%s'", filename);
11498 fprintFileHeader(file, EDITORCASCADE_FILENAME);
11500 for (i = 0; i < ARRAY_SIZE(editor_cascade_setup_tokens); i++)
11501 fprintf(file, "%s\n", getSetupLine(editor_cascade_setup_tokens, "", i));
11505 SetFilePermissions(filename, PERMS_PRIVATE);
11510 void SaveSetup(void)
11512 SaveSetup_Default();
11513 SaveSetup_AutoSetup();
11514 SaveSetup_ServerSetup();
11515 SaveSetup_EditorCascade();
11518 static void SaveSetup_WriteGameControllerMappings(SetupFileHash *mappings_hash,
11523 if (!(file = fopen(filename, MODE_WRITE)))
11525 Warn("cannot write game controller mappings file '%s'", filename);
11530 BEGIN_HASH_ITERATION(mappings_hash, itr)
11532 fprintf(file, "%s\n", HASH_ITERATION_VALUE(itr));
11534 END_HASH_ITERATION(mappings_hash, itr)
11539 void SaveSetup_AddGameControllerMapping(char *mapping)
11541 char *filename = getPath2(getSetupDir(), GAMECONTROLLER_BASENAME);
11542 SetupFileHash *mappings_hash = newSetupFileHash();
11544 InitUserDataDirectory();
11546 // load existing personal game controller mappings
11547 LoadSetup_ReadGameControllerMappings(mappings_hash, filename);
11549 // add new mapping to personal game controller mappings
11550 addGameControllerMappingToHash(mappings_hash, mapping);
11552 // save updated personal game controller mappings
11553 SaveSetup_WriteGameControllerMappings(mappings_hash, filename);
11555 freeSetupFileHash(mappings_hash);
11559 void LoadCustomElementDescriptions(void)
11561 char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
11562 SetupFileHash *setup_file_hash;
11565 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
11567 if (element_info[i].custom_description != NULL)
11569 free(element_info[i].custom_description);
11570 element_info[i].custom_description = NULL;
11574 if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
11577 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
11579 char *token = getStringCat2(element_info[i].token_name, ".name");
11580 char *value = getHashEntry(setup_file_hash, token);
11583 element_info[i].custom_description = getStringCopy(value);
11588 freeSetupFileHash(setup_file_hash);
11591 static int getElementFromToken(char *token)
11593 char *value = getHashEntry(element_token_hash, token);
11596 return atoi(value);
11598 Warn("unknown element token '%s'", token);
11600 return EL_UNDEFINED;
11603 void FreeGlobalAnimEventInfo(void)
11605 struct GlobalAnimEventInfo *gaei = &global_anim_event_info;
11607 if (gaei->event_list == NULL)
11612 for (i = 0; i < gaei->num_event_lists; i++)
11614 checked_free(gaei->event_list[i]->event_value);
11615 checked_free(gaei->event_list[i]);
11618 checked_free(gaei->event_list);
11620 gaei->event_list = NULL;
11621 gaei->num_event_lists = 0;
11624 static int AddGlobalAnimEventList(void)
11626 struct GlobalAnimEventInfo *gaei = &global_anim_event_info;
11627 int list_pos = gaei->num_event_lists++;
11629 gaei->event_list = checked_realloc(gaei->event_list, gaei->num_event_lists *
11630 sizeof(struct GlobalAnimEventListInfo *));
11632 gaei->event_list[list_pos] =
11633 checked_calloc(sizeof(struct GlobalAnimEventListInfo));
11635 struct GlobalAnimEventListInfo *gaeli = gaei->event_list[list_pos];
11637 gaeli->event_value = NULL;
11638 gaeli->num_event_values = 0;
11643 static int AddGlobalAnimEventValue(int list_pos, int event_value)
11645 // do not add empty global animation events
11646 if (event_value == ANIM_EVENT_NONE)
11649 // if list position is undefined, create new list
11650 if (list_pos == ANIM_EVENT_UNDEFINED)
11651 list_pos = AddGlobalAnimEventList();
11653 struct GlobalAnimEventInfo *gaei = &global_anim_event_info;
11654 struct GlobalAnimEventListInfo *gaeli = gaei->event_list[list_pos];
11655 int value_pos = gaeli->num_event_values++;
11657 gaeli->event_value = checked_realloc(gaeli->event_value,
11658 gaeli->num_event_values * sizeof(int *));
11660 gaeli->event_value[value_pos] = event_value;
11665 int GetGlobalAnimEventValue(int list_pos, int value_pos)
11667 if (list_pos == ANIM_EVENT_UNDEFINED)
11668 return ANIM_EVENT_NONE;
11670 struct GlobalAnimEventInfo *gaei = &global_anim_event_info;
11671 struct GlobalAnimEventListInfo *gaeli = gaei->event_list[list_pos];
11673 return gaeli->event_value[value_pos];
11676 int GetGlobalAnimEventValueCount(int list_pos)
11678 if (list_pos == ANIM_EVENT_UNDEFINED)
11681 struct GlobalAnimEventInfo *gaei = &global_anim_event_info;
11682 struct GlobalAnimEventListInfo *gaeli = gaei->event_list[list_pos];
11684 return gaeli->num_event_values;
11687 // This function checks if a string <s> of the format "string1, string2, ..."
11688 // exactly contains a string <s_contained>.
11690 static boolean string_has_parameter(char *s, char *s_contained)
11694 if (s == NULL || s_contained == NULL)
11697 if (strlen(s_contained) > strlen(s))
11700 if (strncmp(s, s_contained, strlen(s_contained)) == 0)
11702 char next_char = s[strlen(s_contained)];
11704 // check if next character is delimiter or whitespace
11705 if (next_char == ',' || next_char == '\0' ||
11706 next_char == ' ' || next_char == '\t')
11710 // check if string contains another parameter string after a comma
11711 substring = strchr(s, ',');
11712 if (substring == NULL) // string does not contain a comma
11715 // advance string pointer to next character after the comma
11718 // skip potential whitespaces after the comma
11719 while (*substring == ' ' || *substring == '\t')
11722 return string_has_parameter(substring, s_contained);
11725 static int get_anim_parameter_value_ce(char *s)
11728 char *pattern_1 = "ce_change:custom_";
11729 char *pattern_2 = ".page_";
11730 int pattern_1_len = strlen(pattern_1);
11731 char *matching_char = strstr(s_ptr, pattern_1);
11732 int result = ANIM_EVENT_NONE;
11734 if (matching_char == NULL)
11735 return ANIM_EVENT_NONE;
11737 result = ANIM_EVENT_CE_CHANGE;
11739 s_ptr = matching_char + pattern_1_len;
11741 // check for custom element number ("custom_X", "custom_XX" or "custom_XXX")
11742 if (*s_ptr >= '0' && *s_ptr <= '9')
11744 int gic_ce_nr = (*s_ptr++ - '0');
11746 if (*s_ptr >= '0' && *s_ptr <= '9')
11748 gic_ce_nr = 10 * gic_ce_nr + (*s_ptr++ - '0');
11750 if (*s_ptr >= '0' && *s_ptr <= '9')
11751 gic_ce_nr = 10 * gic_ce_nr + (*s_ptr++ - '0');
11754 if (gic_ce_nr < 1 || gic_ce_nr > NUM_CUSTOM_ELEMENTS)
11755 return ANIM_EVENT_NONE;
11757 // custom element stored as 0 to 255
11760 result |= gic_ce_nr << ANIM_EVENT_CE_BIT;
11764 // invalid custom element number specified
11766 return ANIM_EVENT_NONE;
11769 // check for change page number ("page_X" or "page_XX") (optional)
11770 if (strPrefix(s_ptr, pattern_2))
11772 s_ptr += strlen(pattern_2);
11774 if (*s_ptr >= '0' && *s_ptr <= '9')
11776 int gic_page_nr = (*s_ptr++ - '0');
11778 if (*s_ptr >= '0' && *s_ptr <= '9')
11779 gic_page_nr = 10 * gic_page_nr + (*s_ptr++ - '0');
11781 if (gic_page_nr < 1 || gic_page_nr > MAX_CHANGE_PAGES)
11782 return ANIM_EVENT_NONE;
11784 // change page stored as 1 to 32 (0 means "all change pages")
11786 result |= gic_page_nr << ANIM_EVENT_PAGE_BIT;
11790 // invalid animation part number specified
11792 return ANIM_EVENT_NONE;
11796 // discard result if next character is neither delimiter nor whitespace
11797 if (!(*s_ptr == ',' || *s_ptr == '\0' ||
11798 *s_ptr == ' ' || *s_ptr == '\t'))
11799 return ANIM_EVENT_NONE;
11804 static int get_anim_parameter_value(char *s)
11806 int event_value[] =
11814 char *pattern_1[] =
11822 char *pattern_2 = ".part_";
11823 char *matching_char = NULL;
11825 int pattern_1_len = 0;
11826 int result = ANIM_EVENT_NONE;
11829 result = get_anim_parameter_value_ce(s);
11831 if (result != ANIM_EVENT_NONE)
11834 for (i = 0; i < ARRAY_SIZE(event_value); i++)
11836 matching_char = strstr(s_ptr, pattern_1[i]);
11837 pattern_1_len = strlen(pattern_1[i]);
11838 result = event_value[i];
11840 if (matching_char != NULL)
11844 if (matching_char == NULL)
11845 return ANIM_EVENT_NONE;
11847 s_ptr = matching_char + pattern_1_len;
11849 // check for main animation number ("anim_X" or "anim_XX")
11850 if (*s_ptr >= '0' && *s_ptr <= '9')
11852 int gic_anim_nr = (*s_ptr++ - '0');
11854 if (*s_ptr >= '0' && *s_ptr <= '9')
11855 gic_anim_nr = 10 * gic_anim_nr + (*s_ptr++ - '0');
11857 if (gic_anim_nr < 1 || gic_anim_nr > MAX_GLOBAL_ANIMS)
11858 return ANIM_EVENT_NONE;
11860 result |= gic_anim_nr << ANIM_EVENT_ANIM_BIT;
11864 // invalid main animation number specified
11866 return ANIM_EVENT_NONE;
11869 // check for animation part number ("part_X" or "part_XX") (optional)
11870 if (strPrefix(s_ptr, pattern_2))
11872 s_ptr += strlen(pattern_2);
11874 if (*s_ptr >= '0' && *s_ptr <= '9')
11876 int gic_part_nr = (*s_ptr++ - '0');
11878 if (*s_ptr >= '0' && *s_ptr <= '9')
11879 gic_part_nr = 10 * gic_part_nr + (*s_ptr++ - '0');
11881 if (gic_part_nr < 1 || gic_part_nr > MAX_GLOBAL_ANIM_PARTS)
11882 return ANIM_EVENT_NONE;
11884 result |= gic_part_nr << ANIM_EVENT_PART_BIT;
11888 // invalid animation part number specified
11890 return ANIM_EVENT_NONE;
11894 // discard result if next character is neither delimiter nor whitespace
11895 if (!(*s_ptr == ',' || *s_ptr == '\0' ||
11896 *s_ptr == ' ' || *s_ptr == '\t'))
11897 return ANIM_EVENT_NONE;
11902 static int get_anim_parameter_values(char *s)
11904 int list_pos = ANIM_EVENT_UNDEFINED;
11905 int event_value = ANIM_EVENT_DEFAULT;
11907 if (string_has_parameter(s, "any"))
11908 event_value |= ANIM_EVENT_ANY;
11910 if (string_has_parameter(s, "click:self") ||
11911 string_has_parameter(s, "click") ||
11912 string_has_parameter(s, "self"))
11913 event_value |= ANIM_EVENT_SELF;
11915 if (string_has_parameter(s, "unclick:any"))
11916 event_value |= ANIM_EVENT_UNCLICK_ANY;
11918 // if animation event found, add it to global animation event list
11919 if (event_value != ANIM_EVENT_NONE)
11920 list_pos = AddGlobalAnimEventValue(list_pos, event_value);
11924 // add optional "click:anim_X" or "click:anim_X.part_X" parameter
11925 event_value = get_anim_parameter_value(s);
11927 // if animation event found, add it to global animation event list
11928 if (event_value != ANIM_EVENT_NONE)
11929 list_pos = AddGlobalAnimEventValue(list_pos, event_value);
11931 // continue with next part of the string, starting with next comma
11932 s = strchr(s + 1, ',');
11938 static int get_anim_action_parameter_value(char *token)
11940 // check most common default case first to massively speed things up
11941 if (strEqual(token, ARG_UNDEFINED))
11942 return ANIM_EVENT_ACTION_NONE;
11944 int result = getImageIDFromToken(token);
11948 char *gfx_token = getStringCat2("gfx.", token);
11950 result = getImageIDFromToken(gfx_token);
11952 checked_free(gfx_token);
11957 Key key = getKeyFromX11KeyName(token);
11959 if (key != KSYM_UNDEFINED)
11960 result = -(int)key;
11967 result = get_hash_from_key(token); // unsigned int => int
11968 result = ABS(result); // may be negative now
11969 result += (result < MAX_IMAGE_FILES ? MAX_IMAGE_FILES : 0);
11971 setHashEntry(anim_url_hash, int2str(result, 0), token);
11976 result = ANIM_EVENT_ACTION_NONE;
11981 int get_parameter_value(char *value_raw, char *suffix, int type)
11983 char *value = getStringToLower(value_raw);
11984 int result = 0; // probably a save default value
11986 if (strEqual(suffix, ".direction"))
11988 result = (strEqual(value, "left") ? MV_LEFT :
11989 strEqual(value, "right") ? MV_RIGHT :
11990 strEqual(value, "up") ? MV_UP :
11991 strEqual(value, "down") ? MV_DOWN : MV_NONE);
11993 else if (strEqual(suffix, ".position"))
11995 result = (strEqual(value, "left") ? POS_LEFT :
11996 strEqual(value, "right") ? POS_RIGHT :
11997 strEqual(value, "top") ? POS_TOP :
11998 strEqual(value, "upper") ? POS_UPPER :
11999 strEqual(value, "middle") ? POS_MIDDLE :
12000 strEqual(value, "lower") ? POS_LOWER :
12001 strEqual(value, "bottom") ? POS_BOTTOM :
12002 strEqual(value, "any") ? POS_ANY :
12003 strEqual(value, "ce") ? POS_CE :
12004 strEqual(value, "ce_trigger") ? POS_CE_TRIGGER :
12005 strEqual(value, "last") ? POS_LAST : POS_UNDEFINED);
12007 else if (strEqual(suffix, ".align"))
12009 result = (strEqual(value, "left") ? ALIGN_LEFT :
12010 strEqual(value, "right") ? ALIGN_RIGHT :
12011 strEqual(value, "center") ? ALIGN_CENTER :
12012 strEqual(value, "middle") ? ALIGN_CENTER : ALIGN_DEFAULT);
12014 else if (strEqual(suffix, ".valign"))
12016 result = (strEqual(value, "top") ? VALIGN_TOP :
12017 strEqual(value, "bottom") ? VALIGN_BOTTOM :
12018 strEqual(value, "middle") ? VALIGN_MIDDLE :
12019 strEqual(value, "center") ? VALIGN_MIDDLE : VALIGN_DEFAULT);
12021 else if (strEqual(suffix, ".anim_mode"))
12023 result = (string_has_parameter(value, "none") ? ANIM_NONE :
12024 string_has_parameter(value, "loop") ? ANIM_LOOP :
12025 string_has_parameter(value, "linear") ? ANIM_LINEAR :
12026 string_has_parameter(value, "pingpong") ? ANIM_PINGPONG :
12027 string_has_parameter(value, "pingpong2") ? ANIM_PINGPONG2 :
12028 string_has_parameter(value, "random") ? ANIM_RANDOM :
12029 string_has_parameter(value, "random_static") ? ANIM_RANDOM_STATIC :
12030 string_has_parameter(value, "ce_value") ? ANIM_CE_VALUE :
12031 string_has_parameter(value, "ce_score") ? ANIM_CE_SCORE :
12032 string_has_parameter(value, "ce_delay") ? ANIM_CE_DELAY :
12033 string_has_parameter(value, "horizontal") ? ANIM_HORIZONTAL :
12034 string_has_parameter(value, "vertical") ? ANIM_VERTICAL :
12035 string_has_parameter(value, "centered") ? ANIM_CENTERED :
12036 string_has_parameter(value, "all") ? ANIM_ALL :
12037 string_has_parameter(value, "tiled") ? ANIM_TILED :
12038 string_has_parameter(value, "level_nr") ? ANIM_LEVEL_NR :
12041 if (string_has_parameter(value, "once"))
12042 result |= ANIM_ONCE;
12044 if (string_has_parameter(value, "reverse"))
12045 result |= ANIM_REVERSE;
12047 if (string_has_parameter(value, "opaque_player"))
12048 result |= ANIM_OPAQUE_PLAYER;
12050 if (string_has_parameter(value, "static_panel"))
12051 result |= ANIM_STATIC_PANEL;
12053 else if (strEqual(suffix, ".init_event") ||
12054 strEqual(suffix, ".anim_event"))
12056 result = get_anim_parameter_values(value);
12058 else if (strEqual(suffix, ".init_delay_action") ||
12059 strEqual(suffix, ".anim_delay_action") ||
12060 strEqual(suffix, ".post_delay_action") ||
12061 strEqual(suffix, ".init_event_action") ||
12062 strEqual(suffix, ".anim_event_action"))
12064 result = get_anim_action_parameter_value(value_raw);
12066 else if (strEqual(suffix, ".class"))
12068 result = (strEqual(value, ARG_UNDEFINED) ? ARG_UNDEFINED_VALUE :
12069 get_hash_from_key(value));
12071 else if (strEqual(suffix, ".style"))
12073 result = STYLE_DEFAULT;
12075 if (string_has_parameter(value, "accurate_borders"))
12076 result |= STYLE_ACCURATE_BORDERS;
12078 if (string_has_parameter(value, "inner_corners"))
12079 result |= STYLE_INNER_CORNERS;
12081 if (string_has_parameter(value, "reverse"))
12082 result |= STYLE_REVERSE;
12084 if (string_has_parameter(value, "leftmost_position"))
12085 result |= STYLE_LEFTMOST_POSITION;
12087 if (string_has_parameter(value, "block_clicks"))
12088 result |= STYLE_BLOCK;
12090 if (string_has_parameter(value, "passthrough_clicks"))
12091 result |= STYLE_PASSTHROUGH;
12093 if (string_has_parameter(value, "multiple_actions"))
12094 result |= STYLE_MULTIPLE_ACTIONS;
12096 if (string_has_parameter(value, "consume_ce_event"))
12097 result |= STYLE_CONSUME_CE_EVENT;
12099 else if (strEqual(suffix, ".fade_mode"))
12101 result = (string_has_parameter(value, "none") ? FADE_MODE_NONE :
12102 string_has_parameter(value, "fade") ? FADE_MODE_FADE :
12103 string_has_parameter(value, "fade_in") ? FADE_MODE_FADE_IN :
12104 string_has_parameter(value, "fade_out") ? FADE_MODE_FADE_OUT :
12105 string_has_parameter(value, "crossfade") ? FADE_MODE_CROSSFADE :
12106 string_has_parameter(value, "melt") ? FADE_MODE_MELT :
12107 string_has_parameter(value, "curtain") ? FADE_MODE_CURTAIN :
12108 FADE_MODE_DEFAULT);
12110 else if (strEqual(suffix, ".auto_delay_unit"))
12112 result = (string_has_parameter(value, "ms") ? AUTO_DELAY_UNIT_MS :
12113 string_has_parameter(value, "frames") ? AUTO_DELAY_UNIT_FRAMES :
12114 AUTO_DELAY_UNIT_DEFAULT);
12116 else if (strPrefix(suffix, ".font")) // (may also be ".font_xyz")
12118 result = gfx.get_font_from_token_function(value);
12120 else // generic parameter of type integer or boolean
12122 result = (strEqual(value, ARG_UNDEFINED) ? ARG_UNDEFINED_VALUE :
12123 type == TYPE_INTEGER ? get_integer_from_string(value) :
12124 type == TYPE_BOOLEAN ? get_boolean_from_string(value) :
12125 ARG_UNDEFINED_VALUE);
12133 static int get_token_parameter_value(char *token, char *value_raw)
12137 if (token == NULL || value_raw == NULL)
12138 return ARG_UNDEFINED_VALUE;
12140 suffix = strrchr(token, '.');
12141 if (suffix == NULL)
12144 if (strEqual(suffix, ".element"))
12145 return getElementFromToken(value_raw);
12147 // !!! USE CORRECT VALUE TYPE (currently works also for TYPE_BOOLEAN) !!!
12148 return get_parameter_value(value_raw, suffix, TYPE_INTEGER);
12151 void InitMenuDesignSettings_FromHash(SetupFileHash *setup_file_hash,
12152 boolean ignore_defaults)
12156 for (i = 0; image_config_vars[i].token != NULL; i++)
12158 char *value = getHashEntry(setup_file_hash, image_config_vars[i].token);
12160 // (ignore definitions set to "[DEFAULT]" which are already initialized)
12161 if (ignore_defaults && strEqual(value, ARG_DEFAULT))
12165 *image_config_vars[i].value =
12166 get_token_parameter_value(image_config_vars[i].token, value);
12170 void InitMenuDesignSettings_Static(void)
12172 // always start with reliable default values from static default config
12173 InitMenuDesignSettings_FromHash(image_config_hash, FALSE);
12176 static void InitMenuDesignSettings_SpecialPreProcessing(void)
12180 // the following initializes hierarchical values from static configuration
12182 // special case: initialize "ARG_DEFAULT" values in static default config
12183 // (e.g., initialize "[titlemessage].fade_mode" from "[title].fade_mode")
12184 titlescreen_initial_first_default.fade_mode =
12185 title_initial_first_default.fade_mode;
12186 titlescreen_initial_first_default.fade_delay =
12187 title_initial_first_default.fade_delay;
12188 titlescreen_initial_first_default.post_delay =
12189 title_initial_first_default.post_delay;
12190 titlescreen_initial_first_default.auto_delay =
12191 title_initial_first_default.auto_delay;
12192 titlescreen_initial_first_default.auto_delay_unit =
12193 title_initial_first_default.auto_delay_unit;
12194 titlescreen_first_default.fade_mode = title_first_default.fade_mode;
12195 titlescreen_first_default.fade_delay = title_first_default.fade_delay;
12196 titlescreen_first_default.post_delay = title_first_default.post_delay;
12197 titlescreen_first_default.auto_delay = title_first_default.auto_delay;
12198 titlescreen_first_default.auto_delay_unit =
12199 title_first_default.auto_delay_unit;
12200 titlemessage_initial_first_default.fade_mode =
12201 title_initial_first_default.fade_mode;
12202 titlemessage_initial_first_default.fade_delay =
12203 title_initial_first_default.fade_delay;
12204 titlemessage_initial_first_default.post_delay =
12205 title_initial_first_default.post_delay;
12206 titlemessage_initial_first_default.auto_delay =
12207 title_initial_first_default.auto_delay;
12208 titlemessage_initial_first_default.auto_delay_unit =
12209 title_initial_first_default.auto_delay_unit;
12210 titlemessage_first_default.fade_mode = title_first_default.fade_mode;
12211 titlemessage_first_default.fade_delay = title_first_default.fade_delay;
12212 titlemessage_first_default.post_delay = title_first_default.post_delay;
12213 titlemessage_first_default.auto_delay = title_first_default.auto_delay;
12214 titlemessage_first_default.auto_delay_unit =
12215 title_first_default.auto_delay_unit;
12217 titlescreen_initial_default.fade_mode = title_initial_default.fade_mode;
12218 titlescreen_initial_default.fade_delay = title_initial_default.fade_delay;
12219 titlescreen_initial_default.post_delay = title_initial_default.post_delay;
12220 titlescreen_initial_default.auto_delay = title_initial_default.auto_delay;
12221 titlescreen_initial_default.auto_delay_unit =
12222 title_initial_default.auto_delay_unit;
12223 titlescreen_default.fade_mode = title_default.fade_mode;
12224 titlescreen_default.fade_delay = title_default.fade_delay;
12225 titlescreen_default.post_delay = title_default.post_delay;
12226 titlescreen_default.auto_delay = title_default.auto_delay;
12227 titlescreen_default.auto_delay_unit = title_default.auto_delay_unit;
12228 titlemessage_initial_default.fade_mode = title_initial_default.fade_mode;
12229 titlemessage_initial_default.fade_delay = title_initial_default.fade_delay;
12230 titlemessage_initial_default.post_delay = title_initial_default.post_delay;
12231 titlemessage_initial_default.auto_delay_unit =
12232 title_initial_default.auto_delay_unit;
12233 titlemessage_default.fade_mode = title_default.fade_mode;
12234 titlemessage_default.fade_delay = title_default.fade_delay;
12235 titlemessage_default.post_delay = title_default.post_delay;
12236 titlemessage_default.auto_delay = title_default.auto_delay;
12237 titlemessage_default.auto_delay_unit = title_default.auto_delay_unit;
12239 // special case: initialize "ARG_DEFAULT" values in static default config
12240 // (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode")
12241 for (i = 0; i < MAX_NUM_TITLE_MESSAGES; i++)
12243 titlescreen_initial_first[i] = titlescreen_initial_first_default;
12244 titlescreen_first[i] = titlescreen_first_default;
12245 titlemessage_initial_first[i] = titlemessage_initial_first_default;
12246 titlemessage_first[i] = titlemessage_first_default;
12248 titlescreen_initial[i] = titlescreen_initial_default;
12249 titlescreen[i] = titlescreen_default;
12250 titlemessage_initial[i] = titlemessage_initial_default;
12251 titlemessage[i] = titlemessage_default;
12254 // special case: initialize "ARG_DEFAULT" values in static default config
12255 // (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz")
12256 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12258 if (i == GFX_SPECIAL_ARG_TITLE) // title values already initialized
12261 menu.enter_screen[i] = menu.enter_screen[GFX_SPECIAL_ARG_DEFAULT];
12262 menu.leave_screen[i] = menu.leave_screen[GFX_SPECIAL_ARG_DEFAULT];
12263 menu.next_screen[i] = menu.next_screen[GFX_SPECIAL_ARG_DEFAULT];
12266 // special case: initialize "ARG_DEFAULT" values in static default config
12267 // (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz")
12268 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12270 viewport.window[i] = viewport.window[GFX_SPECIAL_ARG_DEFAULT];
12271 viewport.playfield[i] = viewport.playfield[GFX_SPECIAL_ARG_DEFAULT];
12272 viewport.door_1[i] = viewport.door_1[GFX_SPECIAL_ARG_DEFAULT];
12274 if (i == GFX_SPECIAL_ARG_EDITOR) // editor values already initialized
12277 viewport.door_2[i] = viewport.door_2[GFX_SPECIAL_ARG_DEFAULT];
12281 static void InitMenuDesignSettings_SpecialPostProcessing(void)
12285 struct XY *dst, *src;
12287 game_buttons_xy[] =
12289 { &game.button.save, &game.button.stop },
12290 { &game.button.pause2, &game.button.pause },
12291 { &game.button.load, &game.button.play },
12292 { &game.button.undo, &game.button.stop },
12293 { &game.button.redo, &game.button.play },
12299 // special case: initialize later added SETUP list size from LEVELS value
12300 if (menu.list_size[GAME_MODE_SETUP] == -1)
12301 menu.list_size[GAME_MODE_SETUP] = menu.list_size[GAME_MODE_LEVELS];
12303 // set default position for snapshot buttons to stop/pause/play buttons
12304 for (i = 0; game_buttons_xy[i].dst != NULL; i++)
12305 if ((*game_buttons_xy[i].dst).x == -1 &&
12306 (*game_buttons_xy[i].dst).y == -1)
12307 *game_buttons_xy[i].dst = *game_buttons_xy[i].src;
12309 // --------------------------------------------------------------------------
12310 // dynamic viewports (including playfield margins, borders and alignments)
12311 // --------------------------------------------------------------------------
12313 // dynamic viewports currently only supported for landscape mode
12314 int display_width = MAX(video.display_width, video.display_height);
12315 int display_height = MIN(video.display_width, video.display_height);
12317 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12319 struct RectWithBorder *vp_window = &viewport.window[i];
12320 struct RectWithBorder *vp_playfield = &viewport.playfield[i];
12321 struct RectWithBorder *vp_door_1 = &viewport.door_1[i];
12322 struct RectWithBorder *vp_door_2 = &viewport.door_2[i];
12323 boolean dynamic_window_width = (vp_window->min_width != -1);
12324 boolean dynamic_window_height = (vp_window->min_height != -1);
12325 boolean dynamic_playfield_width = (vp_playfield->min_width != -1);
12326 boolean dynamic_playfield_height = (vp_playfield->min_height != -1);
12328 // adjust window size if min/max width/height is specified
12330 if (vp_window->min_width != -1)
12332 int window_width = display_width;
12334 // when using static window height, use aspect ratio of display
12335 if (vp_window->min_height == -1)
12336 window_width = vp_window->height * display_width / display_height;
12338 vp_window->width = MAX(vp_window->min_width, window_width);
12341 if (vp_window->min_height != -1)
12343 int window_height = display_height;
12345 // when using static window width, use aspect ratio of display
12346 if (vp_window->min_width == -1)
12347 window_height = vp_window->width * display_height / display_width;
12349 vp_window->height = MAX(vp_window->min_height, window_height);
12352 if (vp_window->max_width != -1)
12353 vp_window->width = MIN(vp_window->width, vp_window->max_width);
12355 if (vp_window->max_height != -1)
12356 vp_window->height = MIN(vp_window->height, vp_window->max_height);
12358 int playfield_width = vp_window->width;
12359 int playfield_height = vp_window->height;
12361 // adjust playfield size and position according to specified margins
12363 playfield_width -= vp_playfield->margin_left;
12364 playfield_width -= vp_playfield->margin_right;
12366 playfield_height -= vp_playfield->margin_top;
12367 playfield_height -= vp_playfield->margin_bottom;
12369 // adjust playfield size if min/max width/height is specified
12371 if (vp_playfield->min_width != -1)
12372 vp_playfield->width = MAX(vp_playfield->min_width, playfield_width);
12374 if (vp_playfield->min_height != -1)
12375 vp_playfield->height = MAX(vp_playfield->min_height, playfield_height);
12377 if (vp_playfield->max_width != -1)
12378 vp_playfield->width = MIN(vp_playfield->width, vp_playfield->max_width);
12380 if (vp_playfield->max_height != -1)
12381 vp_playfield->height = MIN(vp_playfield->height, vp_playfield->max_height);
12383 // adjust playfield position according to specified alignment
12385 if (vp_playfield->align == ALIGN_LEFT || vp_playfield->x > 0)
12386 vp_playfield->x = ALIGNED_VP_XPOS(vp_playfield);
12387 else if (vp_playfield->align == ALIGN_CENTER)
12388 vp_playfield->x = playfield_width / 2 - vp_playfield->width / 2;
12389 else if (vp_playfield->align == ALIGN_RIGHT)
12390 vp_playfield->x += playfield_width - vp_playfield->width;
12392 if (vp_playfield->valign == VALIGN_TOP || vp_playfield->y > 0)
12393 vp_playfield->y = ALIGNED_VP_YPOS(vp_playfield);
12394 else if (vp_playfield->valign == VALIGN_MIDDLE)
12395 vp_playfield->y = playfield_height / 2 - vp_playfield->height / 2;
12396 else if (vp_playfield->valign == VALIGN_BOTTOM)
12397 vp_playfield->y += playfield_height - vp_playfield->height;
12399 vp_playfield->x += vp_playfield->margin_left;
12400 vp_playfield->y += vp_playfield->margin_top;
12402 // adjust individual playfield borders if only default border is specified
12404 if (vp_playfield->border_left == -1)
12405 vp_playfield->border_left = vp_playfield->border_size;
12406 if (vp_playfield->border_right == -1)
12407 vp_playfield->border_right = vp_playfield->border_size;
12408 if (vp_playfield->border_top == -1)
12409 vp_playfield->border_top = vp_playfield->border_size;
12410 if (vp_playfield->border_bottom == -1)
12411 vp_playfield->border_bottom = vp_playfield->border_size;
12413 // set dynamic playfield borders if borders are specified as undefined
12414 // (but only if window size was dynamic and playfield size was static)
12416 if (dynamic_window_width && !dynamic_playfield_width)
12418 if (vp_playfield->border_left == -1)
12420 vp_playfield->border_left = (vp_playfield->x -
12421 vp_playfield->margin_left);
12422 vp_playfield->x -= vp_playfield->border_left;
12423 vp_playfield->width += vp_playfield->border_left;
12426 if (vp_playfield->border_right == -1)
12428 vp_playfield->border_right = (vp_window->width -
12430 vp_playfield->width -
12431 vp_playfield->margin_right);
12432 vp_playfield->width += vp_playfield->border_right;
12436 if (dynamic_window_height && !dynamic_playfield_height)
12438 if (vp_playfield->border_top == -1)
12440 vp_playfield->border_top = (vp_playfield->y -
12441 vp_playfield->margin_top);
12442 vp_playfield->y -= vp_playfield->border_top;
12443 vp_playfield->height += vp_playfield->border_top;
12446 if (vp_playfield->border_bottom == -1)
12448 vp_playfield->border_bottom = (vp_window->height -
12450 vp_playfield->height -
12451 vp_playfield->margin_bottom);
12452 vp_playfield->height += vp_playfield->border_bottom;
12456 // adjust playfield size to be a multiple of a defined alignment tile size
12458 int align_size = vp_playfield->align_size;
12459 int playfield_xtiles = vp_playfield->width / align_size;
12460 int playfield_ytiles = vp_playfield->height / align_size;
12461 int playfield_width_corrected = playfield_xtiles * align_size;
12462 int playfield_height_corrected = playfield_ytiles * align_size;
12463 boolean is_playfield_mode = (i == GFX_SPECIAL_ARG_PLAYING ||
12464 i == GFX_SPECIAL_ARG_EDITOR);
12466 if (is_playfield_mode &&
12467 dynamic_playfield_width &&
12468 vp_playfield->width != playfield_width_corrected)
12470 int playfield_xdiff = vp_playfield->width - playfield_width_corrected;
12472 vp_playfield->width = playfield_width_corrected;
12474 if (vp_playfield->align == ALIGN_LEFT)
12476 vp_playfield->border_left += playfield_xdiff;
12478 else if (vp_playfield->align == ALIGN_RIGHT)
12480 vp_playfield->border_right += playfield_xdiff;
12482 else if (vp_playfield->align == ALIGN_CENTER)
12484 int border_left_diff = playfield_xdiff / 2;
12485 int border_right_diff = playfield_xdiff - border_left_diff;
12487 vp_playfield->border_left += border_left_diff;
12488 vp_playfield->border_right += border_right_diff;
12492 if (is_playfield_mode &&
12493 dynamic_playfield_height &&
12494 vp_playfield->height != playfield_height_corrected)
12496 int playfield_ydiff = vp_playfield->height - playfield_height_corrected;
12498 vp_playfield->height = playfield_height_corrected;
12500 if (vp_playfield->valign == VALIGN_TOP)
12502 vp_playfield->border_top += playfield_ydiff;
12504 else if (vp_playfield->align == VALIGN_BOTTOM)
12506 vp_playfield->border_right += playfield_ydiff;
12508 else if (vp_playfield->align == VALIGN_MIDDLE)
12510 int border_top_diff = playfield_ydiff / 2;
12511 int border_bottom_diff = playfield_ydiff - border_top_diff;
12513 vp_playfield->border_top += border_top_diff;
12514 vp_playfield->border_bottom += border_bottom_diff;
12518 // adjust door positions according to specified alignment
12520 for (j = 0; j < 2; j++)
12522 struct RectWithBorder *vp_door = (j == 0 ? vp_door_1 : vp_door_2);
12524 if (vp_door->align == ALIGN_LEFT || vp_door->x > 0)
12525 vp_door->x = ALIGNED_VP_XPOS(vp_door);
12526 else if (vp_door->align == ALIGN_CENTER)
12527 vp_door->x = vp_window->width / 2 - vp_door->width / 2;
12528 else if (vp_door->align == ALIGN_RIGHT)
12529 vp_door->x += vp_window->width - vp_door->width;
12531 if (vp_door->valign == VALIGN_TOP || vp_door->y > 0)
12532 vp_door->y = ALIGNED_VP_YPOS(vp_door);
12533 else if (vp_door->valign == VALIGN_MIDDLE)
12534 vp_door->y = vp_window->height / 2 - vp_door->height / 2;
12535 else if (vp_door->valign == VALIGN_BOTTOM)
12536 vp_door->y += vp_window->height - vp_door->height;
12541 static void InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics(void)
12545 struct XYTileSize *dst, *src;
12548 editor_buttons_xy[] =
12551 &editor.button.element_left, &editor.palette.element_left,
12552 IMG_GFX_EDITOR_BUTTON_ELEMENT_LEFT
12555 &editor.button.element_middle, &editor.palette.element_middle,
12556 IMG_GFX_EDITOR_BUTTON_ELEMENT_MIDDLE
12559 &editor.button.element_right, &editor.palette.element_right,
12560 IMG_GFX_EDITOR_BUTTON_ELEMENT_RIGHT
12567 // set default position for element buttons to element graphics
12568 for (i = 0; editor_buttons_xy[i].dst != NULL; i++)
12570 if ((*editor_buttons_xy[i].dst).x == -1 &&
12571 (*editor_buttons_xy[i].dst).y == -1)
12573 struct GraphicInfo *gd = &graphic_info[editor_buttons_xy[i].graphic];
12575 gd->width = gd->height = editor_buttons_xy[i].src->tile_size;
12577 *editor_buttons_xy[i].dst = *editor_buttons_xy[i].src;
12581 // adjust editor palette rows and columns if specified to be dynamic
12583 if (editor.palette.cols == -1)
12585 int vp_width = viewport.playfield[GFX_SPECIAL_ARG_EDITOR].width;
12586 int bt_width = graphic_info[IMG_EDITOR_PALETTE_BUTTON].width;
12587 int sc_width = graphic_info[IMG_EDITOR_PALETTE_SCROLLBAR].width;
12589 editor.palette.cols = (vp_width - sc_width) / bt_width;
12591 if (editor.palette.x == -1)
12593 int palette_width = editor.palette.cols * bt_width + sc_width;
12595 editor.palette.x = (vp_width - palette_width) / 2;
12599 if (editor.palette.rows == -1)
12601 int vp_height = viewport.playfield[GFX_SPECIAL_ARG_EDITOR].height;
12602 int bt_height = graphic_info[IMG_EDITOR_PALETTE_BUTTON].height;
12603 int tx_height = getFontHeight(FONT_TEXT_2);
12605 editor.palette.rows = (vp_height - tx_height) / bt_height;
12607 if (editor.palette.y == -1)
12609 int palette_height = editor.palette.rows * bt_height + tx_height;
12611 editor.palette.y = (vp_height - palette_height) / 2;
12616 static void InitMenuDesignSettings_PreviewPlayers_Ext(SetupFileHash *hash,
12617 boolean initialize)
12619 // special case: check if network and preview player positions are redefined,
12620 // to compare this later against the main menu level preview being redefined
12621 struct TokenIntPtrInfo menu_config_players[] =
12623 { "main.network_players.x", &menu.main.network_players.redefined },
12624 { "main.network_players.y", &menu.main.network_players.redefined },
12625 { "main.preview_players.x", &menu.main.preview_players.redefined },
12626 { "main.preview_players.y", &menu.main.preview_players.redefined },
12627 { "preview.x", &preview.redefined },
12628 { "preview.y", &preview.redefined }
12634 for (i = 0; i < ARRAY_SIZE(menu_config_players); i++)
12635 *menu_config_players[i].value = FALSE;
12639 for (i = 0; i < ARRAY_SIZE(menu_config_players); i++)
12640 if (getHashEntry(hash, menu_config_players[i].token) != NULL)
12641 *menu_config_players[i].value = TRUE;
12645 static void InitMenuDesignSettings_PreviewPlayers(void)
12647 InitMenuDesignSettings_PreviewPlayers_Ext(NULL, TRUE);
12650 static void InitMenuDesignSettings_PreviewPlayers_FromHash(SetupFileHash *hash)
12652 InitMenuDesignSettings_PreviewPlayers_Ext(hash, FALSE);
12655 static void LoadMenuDesignSettingsFromFilename(char *filename)
12657 static struct TitleFadingInfo tfi;
12658 static struct TitleMessageInfo tmi;
12659 static struct TokenInfo title_tokens[] =
12661 { TYPE_INTEGER, &tfi.fade_mode, ".fade_mode" },
12662 { TYPE_INTEGER, &tfi.fade_delay, ".fade_delay" },
12663 { TYPE_INTEGER, &tfi.post_delay, ".post_delay" },
12664 { TYPE_INTEGER, &tfi.auto_delay, ".auto_delay" },
12665 { TYPE_INTEGER, &tfi.auto_delay_unit, ".auto_delay_unit" },
12669 static struct TokenInfo titlemessage_tokens[] =
12671 { TYPE_INTEGER, &tmi.x, ".x" },
12672 { TYPE_INTEGER, &tmi.y, ".y" },
12673 { TYPE_INTEGER, &tmi.width, ".width" },
12674 { TYPE_INTEGER, &tmi.height, ".height" },
12675 { TYPE_INTEGER, &tmi.chars, ".chars" },
12676 { TYPE_INTEGER, &tmi.lines, ".lines" },
12677 { TYPE_INTEGER, &tmi.align, ".align" },
12678 { TYPE_INTEGER, &tmi.valign, ".valign" },
12679 { TYPE_INTEGER, &tmi.font, ".font" },
12680 { TYPE_BOOLEAN, &tmi.autowrap, ".autowrap" },
12681 { TYPE_BOOLEAN, &tmi.centered, ".centered" },
12682 { TYPE_BOOLEAN, &tmi.parse_comments, ".parse_comments" },
12683 { TYPE_INTEGER, &tmi.sort_priority, ".sort_priority" },
12684 { TYPE_INTEGER, &tmi.fade_mode, ".fade_mode" },
12685 { TYPE_INTEGER, &tmi.fade_delay, ".fade_delay" },
12686 { TYPE_INTEGER, &tmi.post_delay, ".post_delay" },
12687 { TYPE_INTEGER, &tmi.auto_delay, ".auto_delay" },
12688 { TYPE_INTEGER, &tmi.auto_delay_unit, ".auto_delay_unit" },
12694 struct TitleFadingInfo *info;
12699 // initialize first titles from "enter screen" definitions, if defined
12700 { &title_initial_first_default, "menu.enter_screen.TITLE" },
12701 { &title_first_default, "menu.enter_screen.TITLE" },
12703 // initialize title screens from "next screen" definitions, if defined
12704 { &title_initial_default, "menu.next_screen.TITLE" },
12705 { &title_default, "menu.next_screen.TITLE" },
12711 struct TitleMessageInfo *array;
12714 titlemessage_arrays[] =
12716 // initialize first titles from "enter screen" definitions, if defined
12717 { titlescreen_initial_first, "menu.enter_screen.TITLE" },
12718 { titlescreen_first, "menu.enter_screen.TITLE" },
12719 { titlemessage_initial_first, "menu.enter_screen.TITLE" },
12720 { titlemessage_first, "menu.enter_screen.TITLE" },
12722 // initialize titles from "next screen" definitions, if defined
12723 { titlescreen_initial, "menu.next_screen.TITLE" },
12724 { titlescreen, "menu.next_screen.TITLE" },
12725 { titlemessage_initial, "menu.next_screen.TITLE" },
12726 { titlemessage, "menu.next_screen.TITLE" },
12728 // overwrite titles with title definitions, if defined
12729 { titlescreen_initial_first, "[title_initial]" },
12730 { titlescreen_first, "[title]" },
12731 { titlemessage_initial_first, "[title_initial]" },
12732 { titlemessage_first, "[title]" },
12734 { titlescreen_initial, "[title_initial]" },
12735 { titlescreen, "[title]" },
12736 { titlemessage_initial, "[title_initial]" },
12737 { titlemessage, "[title]" },
12739 // overwrite titles with title screen/message definitions, if defined
12740 { titlescreen_initial_first, "[titlescreen_initial]" },
12741 { titlescreen_first, "[titlescreen]" },
12742 { titlemessage_initial_first, "[titlemessage_initial]" },
12743 { titlemessage_first, "[titlemessage]" },
12745 { titlescreen_initial, "[titlescreen_initial]" },
12746 { titlescreen, "[titlescreen]" },
12747 { titlemessage_initial, "[titlemessage_initial]" },
12748 { titlemessage, "[titlemessage]" },
12752 SetupFileHash *setup_file_hash;
12755 if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
12758 // the following initializes hierarchical values from dynamic configuration
12760 // special case: initialize with default values that may be overwritten
12761 // (e.g., init "menu.draw_xoffset.INFO" from "menu.draw_xoffset")
12762 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12764 struct TokenIntPtrInfo menu_config[] =
12766 { "menu.draw_xoffset", &menu.draw_xoffset[i] },
12767 { "menu.draw_yoffset", &menu.draw_yoffset[i] },
12768 { "menu.list_size", &menu.list_size[i] }
12771 for (j = 0; j < ARRAY_SIZE(menu_config); j++)
12773 char *token = menu_config[j].token;
12774 char *value = getHashEntry(setup_file_hash, token);
12777 *menu_config[j].value = get_integer_from_string(value);
12781 // special case: initialize with default values that may be overwritten
12782 // (eg, init "menu.draw_xoffset.INFO[XXX]" from "menu.draw_xoffset.INFO")
12783 for (i = 0; i < NUM_SPECIAL_GFX_INFO_ARGS; i++)
12785 struct TokenIntPtrInfo menu_config[] =
12787 { "menu.draw_xoffset.INFO", &menu.draw_xoffset_info[i] },
12788 { "menu.draw_yoffset.INFO", &menu.draw_yoffset_info[i] },
12789 { "menu.list_size.INFO", &menu.list_size_info[i] },
12790 { "menu.list_entry_size.INFO", &menu.list_entry_size_info[i] },
12791 { "menu.tile_size.INFO", &menu.tile_size_info[i] }
12794 for (j = 0; j < ARRAY_SIZE(menu_config); j++)
12796 char *token = menu_config[j].token;
12797 char *value = getHashEntry(setup_file_hash, token);
12800 *menu_config[j].value = get_integer_from_string(value);
12804 // special case: initialize with default values that may be overwritten
12805 // (eg, init "menu.draw_xoffset.SETUP[XXX]" from "menu.draw_xoffset.SETUP")
12806 for (i = 0; i < NUM_SPECIAL_GFX_SETUP_ARGS; i++)
12808 struct TokenIntPtrInfo menu_config[] =
12810 { "menu.draw_xoffset.SETUP", &menu.draw_xoffset_setup[i] },
12811 { "menu.draw_yoffset.SETUP", &menu.draw_yoffset_setup[i] }
12814 for (j = 0; j < ARRAY_SIZE(menu_config); j++)
12816 char *token = menu_config[j].token;
12817 char *value = getHashEntry(setup_file_hash, token);
12820 *menu_config[j].value = get_integer_from_string(value);
12824 // special case: initialize with default values that may be overwritten
12825 // (eg, init "menu.line_spacing.INFO[XXX]" from "menu.line_spacing.INFO")
12826 for (i = 0; i < NUM_SPECIAL_GFX_INFO_ARGS; i++)
12828 struct TokenIntPtrInfo menu_config[] =
12830 { "menu.left_spacing.INFO", &menu.left_spacing_info[i] },
12831 { "menu.middle_spacing.INFO", &menu.middle_spacing_info[i] },
12832 { "menu.right_spacing.INFO", &menu.right_spacing_info[i] },
12833 { "menu.top_spacing.INFO", &menu.top_spacing_info[i] },
12834 { "menu.bottom_spacing.INFO", &menu.bottom_spacing_info[i] },
12835 { "menu.paragraph_spacing.INFO", &menu.paragraph_spacing_info[i] },
12836 { "menu.headline1_spacing.INFO", &menu.headline1_spacing_info[i] },
12837 { "menu.headline2_spacing.INFO", &menu.headline2_spacing_info[i] },
12838 { "menu.line_spacing.INFO", &menu.line_spacing_info[i] },
12839 { "menu.extra_spacing.INFO", &menu.extra_spacing_info[i] },
12842 for (j = 0; j < ARRAY_SIZE(menu_config); j++)
12844 char *token = menu_config[j].token;
12845 char *value = getHashEntry(setup_file_hash, token);
12848 *menu_config[j].value = get_integer_from_string(value);
12852 // special case: initialize with default values that may be overwritten
12853 // (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz")
12854 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12856 struct TokenIntPtrInfo menu_config[] =
12858 { "menu.enter_screen.fade_mode", &menu.enter_screen[i].fade_mode },
12859 { "menu.enter_screen.fade_delay", &menu.enter_screen[i].fade_delay },
12860 { "menu.enter_screen.post_delay", &menu.enter_screen[i].post_delay },
12861 { "menu.leave_screen.fade_mode", &menu.leave_screen[i].fade_mode },
12862 { "menu.leave_screen.fade_delay", &menu.leave_screen[i].fade_delay },
12863 { "menu.leave_screen.post_delay", &menu.leave_screen[i].post_delay },
12864 { "menu.next_screen.fade_mode", &menu.next_screen[i].fade_mode },
12865 { "menu.next_screen.fade_delay", &menu.next_screen[i].fade_delay },
12866 { "menu.next_screen.post_delay", &menu.next_screen[i].post_delay }
12869 for (j = 0; j < ARRAY_SIZE(menu_config); j++)
12871 char *token = menu_config[j].token;
12872 char *value = getHashEntry(setup_file_hash, token);
12875 *menu_config[j].value = get_token_parameter_value(token, value);
12879 // special case: initialize with default values that may be overwritten
12880 // (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz")
12881 for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
12885 char *token_prefix;
12886 struct RectWithBorder *struct_ptr;
12890 { "viewport.window", &viewport.window[i] },
12891 { "viewport.playfield", &viewport.playfield[i] },
12892 { "viewport.door_1", &viewport.door_1[i] },
12893 { "viewport.door_2", &viewport.door_2[i] }
12896 for (j = 0; j < ARRAY_SIZE(vp_struct); j++)
12898 struct TokenIntPtrInfo vp_config[] =
12900 { ".x", &vp_struct[j].struct_ptr->x },
12901 { ".y", &vp_struct[j].struct_ptr->y },
12902 { ".width", &vp_struct[j].struct_ptr->width },
12903 { ".height", &vp_struct[j].struct_ptr->height },
12904 { ".min_width", &vp_struct[j].struct_ptr->min_width },
12905 { ".min_height", &vp_struct[j].struct_ptr->min_height },
12906 { ".max_width", &vp_struct[j].struct_ptr->max_width },
12907 { ".max_height", &vp_struct[j].struct_ptr->max_height },
12908 { ".margin_left", &vp_struct[j].struct_ptr->margin_left },
12909 { ".margin_right", &vp_struct[j].struct_ptr->margin_right },
12910 { ".margin_top", &vp_struct[j].struct_ptr->margin_top },
12911 { ".margin_bottom", &vp_struct[j].struct_ptr->margin_bottom },
12912 { ".border_left", &vp_struct[j].struct_ptr->border_left },
12913 { ".border_right", &vp_struct[j].struct_ptr->border_right },
12914 { ".border_top", &vp_struct[j].struct_ptr->border_top },
12915 { ".border_bottom", &vp_struct[j].struct_ptr->border_bottom },
12916 { ".border_size", &vp_struct[j].struct_ptr->border_size },
12917 { ".align_size", &vp_struct[j].struct_ptr->align_size },
12918 { ".align", &vp_struct[j].struct_ptr->align },
12919 { ".valign", &vp_struct[j].struct_ptr->valign }
12922 for (k = 0; k < ARRAY_SIZE(vp_config); k++)
12924 char *token = getStringCat2(vp_struct[j].token_prefix,
12925 vp_config[k].token);
12926 char *value = getHashEntry(setup_file_hash, token);
12929 *vp_config[k].value = get_token_parameter_value(token, value);
12936 // special case: initialize with default values that may be overwritten
12937 // (e.g., init "[title].fade_mode" from "menu.next_screen.TITLE.fade_mode")
12938 for (i = 0; title_info[i].info != NULL; i++)
12940 struct TitleFadingInfo *info = title_info[i].info;
12941 char *base_token = title_info[i].text;
12943 for (j = 0; title_tokens[j].type != -1; j++)
12945 char *token = getStringCat2(base_token, title_tokens[j].text);
12946 char *value = getHashEntry(setup_file_hash, token);
12950 int parameter_value = get_token_parameter_value(token, value);
12954 *(int *)title_tokens[j].value = (int)parameter_value;
12963 // special case: initialize with default values that may be overwritten
12964 // (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode")
12965 for (i = 0; titlemessage_arrays[i].array != NULL; i++)
12967 struct TitleMessageInfo *array = titlemessage_arrays[i].array;
12968 char *base_token = titlemessage_arrays[i].text;
12970 for (j = 0; titlemessage_tokens[j].type != -1; j++)
12972 char *token = getStringCat2(base_token, titlemessage_tokens[j].text);
12973 char *value = getHashEntry(setup_file_hash, token);
12977 int parameter_value = get_token_parameter_value(token, value);
12979 for (k = 0; k < MAX_NUM_TITLE_MESSAGES; k++)
12983 if (titlemessage_tokens[j].type == TYPE_INTEGER)
12984 *(int *)titlemessage_tokens[j].value = (int)parameter_value;
12986 *(boolean *)titlemessage_tokens[j].value = (boolean)parameter_value;
12996 // read (and overwrite with) values that may be specified in config file
12997 InitMenuDesignSettings_FromHash(setup_file_hash, TRUE);
12999 // special case: check if network and preview player positions are redefined
13000 InitMenuDesignSettings_PreviewPlayers_FromHash(setup_file_hash);
13002 freeSetupFileHash(setup_file_hash);
13005 void LoadMenuDesignSettings(void)
13007 char *filename_base = UNDEFINED_FILENAME, *filename_local;
13009 InitMenuDesignSettings_Static();
13010 InitMenuDesignSettings_SpecialPreProcessing();
13011 InitMenuDesignSettings_PreviewPlayers();
13013 if (!GFX_OVERRIDE_ARTWORK(ARTWORK_TYPE_GRAPHICS))
13015 // first look for special settings configured in level series config
13016 filename_base = getCustomArtworkLevelConfigFilename(ARTWORK_TYPE_GRAPHICS);
13018 if (fileExists(filename_base))
13019 LoadMenuDesignSettingsFromFilename(filename_base);
13022 filename_local = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
13024 if (filename_local != NULL && !strEqual(filename_base, filename_local))
13025 LoadMenuDesignSettingsFromFilename(filename_local);
13027 InitMenuDesignSettings_SpecialPostProcessing();
13030 void LoadMenuDesignSettings_AfterGraphics(void)
13032 InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics();
13035 void InitSoundSettings_FromHash(SetupFileHash *setup_file_hash,
13036 boolean ignore_defaults)
13040 for (i = 0; sound_config_vars[i].token != NULL; i++)
13042 char *value = getHashEntry(setup_file_hash, sound_config_vars[i].token);
13044 // (ignore definitions set to "[DEFAULT]" which are already initialized)
13045 if (ignore_defaults && strEqual(value, ARG_DEFAULT))
13049 *sound_config_vars[i].value =
13050 get_token_parameter_value(sound_config_vars[i].token, value);
13054 void InitSoundSettings_Static(void)
13056 // always start with reliable default values from static default config
13057 InitSoundSettings_FromHash(sound_config_hash, FALSE);
13060 static void LoadSoundSettingsFromFilename(char *filename)
13062 SetupFileHash *setup_file_hash;
13064 if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
13067 // read (and overwrite with) values that may be specified in config file
13068 InitSoundSettings_FromHash(setup_file_hash, TRUE);
13070 freeSetupFileHash(setup_file_hash);
13073 void LoadSoundSettings(void)
13075 char *filename_base = UNDEFINED_FILENAME, *filename_local;
13077 InitSoundSettings_Static();
13079 if (!GFX_OVERRIDE_ARTWORK(ARTWORK_TYPE_SOUNDS))
13081 // first look for special settings configured in level series config
13082 filename_base = getCustomArtworkLevelConfigFilename(ARTWORK_TYPE_SOUNDS);
13084 if (fileExists(filename_base))
13085 LoadSoundSettingsFromFilename(filename_base);
13088 filename_local = getCustomArtworkConfigFilename(ARTWORK_TYPE_SOUNDS);
13090 if (filename_local != NULL && !strEqual(filename_base, filename_local))
13091 LoadSoundSettingsFromFilename(filename_local);
13094 void LoadUserDefinedEditorElementList(int **elements, int *num_elements)
13096 char *filename = getEditorSetupFilename();
13097 SetupFileList *setup_file_list, *list;
13098 SetupFileHash *element_hash;
13099 int num_unknown_tokens = 0;
13102 if ((setup_file_list = loadSetupFileList(filename)) == NULL)
13105 element_hash = newSetupFileHash();
13107 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
13108 setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
13110 // determined size may be larger than needed (due to unknown elements)
13112 for (list = setup_file_list; list != NULL; list = list->next)
13115 // add space for up to 3 more elements for padding that may be needed
13116 *num_elements += 3;
13118 // free memory for old list of elements, if needed
13119 checked_free(*elements);
13121 // allocate memory for new list of elements
13122 *elements = checked_malloc(*num_elements * sizeof(int));
13125 for (list = setup_file_list; list != NULL; list = list->next)
13127 char *value = getHashEntry(element_hash, list->token);
13129 if (value == NULL) // try to find obsolete token mapping
13131 char *mapped_token = get_mapped_token(list->token);
13133 if (mapped_token != NULL)
13135 value = getHashEntry(element_hash, mapped_token);
13137 free(mapped_token);
13143 (*elements)[(*num_elements)++] = atoi(value);
13147 if (num_unknown_tokens == 0)
13150 Warn("unknown token(s) found in config file:");
13151 Warn("- config file: '%s'", filename);
13153 num_unknown_tokens++;
13156 Warn("- token: '%s'", list->token);
13160 if (num_unknown_tokens > 0)
13163 while (*num_elements % 4) // pad with empty elements, if needed
13164 (*elements)[(*num_elements)++] = EL_EMPTY;
13166 freeSetupFileList(setup_file_list);
13167 freeSetupFileHash(element_hash);
13170 for (i = 0; i < *num_elements; i++)
13171 Debug("editor", "element '%s' [%d]\n",
13172 element_info[(*elements)[i]].token_name, (*elements)[i]);
13176 static struct MusicFileInfo *get_music_file_info_ext(char *basename, int music,
13179 SetupFileHash *setup_file_hash = NULL;
13180 struct MusicFileInfo tmp_music_file_info, *new_music_file_info;
13181 char *filename_music, *filename_prefix, *filename_info;
13187 token_to_value_ptr[] =
13189 { "title_header", &tmp_music_file_info.title_header },
13190 { "artist_header", &tmp_music_file_info.artist_header },
13191 { "album_header", &tmp_music_file_info.album_header },
13192 { "year_header", &tmp_music_file_info.year_header },
13193 { "played_header", &tmp_music_file_info.played_header },
13195 { "title", &tmp_music_file_info.title },
13196 { "artist", &tmp_music_file_info.artist },
13197 { "album", &tmp_music_file_info.album },
13198 { "year", &tmp_music_file_info.year },
13199 { "played", &tmp_music_file_info.played },
13205 filename_music = (is_sound ? getCustomSoundFilename(basename) :
13206 getCustomMusicFilename(basename));
13208 if (filename_music == NULL)
13211 // ---------- try to replace file extension ----------
13213 filename_prefix = getStringCopy(filename_music);
13214 if (strrchr(filename_prefix, '.') != NULL)
13215 *strrchr(filename_prefix, '.') = '\0';
13216 filename_info = getStringCat2(filename_prefix, ".txt");
13218 if (fileExists(filename_info))
13219 setup_file_hash = loadSetupFileHash(filename_info);
13221 free(filename_prefix);
13222 free(filename_info);
13224 if (setup_file_hash == NULL)
13226 // ---------- try to add file extension ----------
13228 filename_prefix = getStringCopy(filename_music);
13229 filename_info = getStringCat2(filename_prefix, ".txt");
13231 if (fileExists(filename_info))
13232 setup_file_hash = loadSetupFileHash(filename_info);
13234 free(filename_prefix);
13235 free(filename_info);
13238 if (setup_file_hash == NULL)
13241 // ---------- music file info found ----------
13243 clear_mem(&tmp_music_file_info, sizeof(struct MusicFileInfo));
13245 for (i = 0; token_to_value_ptr[i].token != NULL; i++)
13247 char *value = getHashEntry(setup_file_hash, token_to_value_ptr[i].token);
13249 *token_to_value_ptr[i].value_ptr =
13250 getStringCopy(value != NULL && *value != '\0' ? value : UNKNOWN_NAME);
13253 tmp_music_file_info.basename = getStringCopy(basename);
13254 tmp_music_file_info.music = music;
13255 tmp_music_file_info.is_sound = is_sound;
13257 new_music_file_info = checked_malloc(sizeof(struct MusicFileInfo));
13258 *new_music_file_info = tmp_music_file_info;
13260 return new_music_file_info;
13263 static struct MusicFileInfo *get_music_file_info(char *basename, int music)
13265 return get_music_file_info_ext(basename, music, FALSE);
13268 static struct MusicFileInfo *get_sound_file_info(char *basename, int sound)
13270 return get_music_file_info_ext(basename, sound, TRUE);
13273 static boolean music_info_listed_ext(struct MusicFileInfo *list,
13274 char *basename, boolean is_sound)
13276 for (; list != NULL; list = list->next)
13277 if (list->is_sound == is_sound && strEqual(list->basename, basename))
13283 static boolean music_info_listed(struct MusicFileInfo *list, char *basename)
13285 return music_info_listed_ext(list, basename, FALSE);
13288 static boolean sound_info_listed(struct MusicFileInfo *list, char *basename)
13290 return music_info_listed_ext(list, basename, TRUE);
13293 void LoadMusicInfo(void)
13295 int num_music_noconf = getMusicListSize_NoConf();
13296 int num_music = getMusicListSize();
13297 int num_sounds = getSoundListSize();
13298 struct FileInfo *music, *sound;
13299 struct MusicFileInfo *next, **new;
13303 while (music_file_info != NULL)
13305 next = music_file_info->next;
13307 checked_free(music_file_info->basename);
13309 checked_free(music_file_info->title_header);
13310 checked_free(music_file_info->artist_header);
13311 checked_free(music_file_info->album_header);
13312 checked_free(music_file_info->year_header);
13313 checked_free(music_file_info->played_header);
13315 checked_free(music_file_info->title);
13316 checked_free(music_file_info->artist);
13317 checked_free(music_file_info->album);
13318 checked_free(music_file_info->year);
13319 checked_free(music_file_info->played);
13321 free(music_file_info);
13323 music_file_info = next;
13326 new = &music_file_info;
13328 // get (configured or unconfigured) music file info for all levels
13329 for (i = leveldir_current->first_level;
13330 i <= leveldir_current->last_level; i++)
13334 if (levelset.music[i] != MUS_UNDEFINED)
13336 // get music file info for configured level music
13337 music_nr = levelset.music[i];
13339 else if (num_music_noconf > 0)
13341 // get music file info for unconfigured level music
13342 int level_pos = i - leveldir_current->first_level;
13344 music_nr = MAP_NOCONF_MUSIC(level_pos % num_music_noconf);
13351 char *basename = getMusicInfoEntryFilename(music_nr);
13353 if (basename == NULL)
13356 if (!music_info_listed(music_file_info, basename))
13358 *new = get_music_file_info(basename, music_nr);
13361 new = &(*new)->next;
13365 // get music file info for all remaining configured music files
13366 for (i = 0; i < num_music; i++)
13368 music = getMusicListEntry(i);
13370 if (music->filename == NULL)
13373 if (strEqual(music->filename, UNDEFINED_FILENAME))
13376 // a configured file may be not recognized as music
13377 if (!FileIsMusic(music->filename))
13380 if (!music_info_listed(music_file_info, music->filename))
13382 *new = get_music_file_info(music->filename, i);
13385 new = &(*new)->next;
13389 // get sound file info for all configured sound files
13390 for (i = 0; i < num_sounds; i++)
13392 sound = getSoundListEntry(i);
13394 if (sound->filename == NULL)
13397 if (strEqual(sound->filename, UNDEFINED_FILENAME))
13400 // a configured file may be not recognized as sound
13401 if (!FileIsSound(sound->filename))
13404 if (!sound_info_listed(music_file_info, sound->filename))
13406 *new = get_sound_file_info(sound->filename, i);
13408 new = &(*new)->next;
13412 // add pointers to previous list nodes
13414 struct MusicFileInfo *node = music_file_info;
13416 while (node != NULL)
13419 node->next->prev = node;
13425 static void add_helpanim_entry(int element, int action, int direction,
13426 int delay, int *num_list_entries)
13428 struct HelpAnimInfo *new_list_entry;
13429 (*num_list_entries)++;
13432 checked_realloc(helpanim_info,
13433 *num_list_entries * sizeof(struct HelpAnimInfo));
13434 new_list_entry = &helpanim_info[*num_list_entries - 1];
13436 new_list_entry->element = element;
13437 new_list_entry->action = action;
13438 new_list_entry->direction = direction;
13439 new_list_entry->delay = delay;
13442 static void print_unknown_token(char *filename, char *token, int token_nr)
13447 Warn("unknown token(s) found in config file:");
13448 Warn("- config file: '%s'", filename);
13451 Warn("- token: '%s'", token);
13454 static void print_unknown_token_end(int token_nr)
13460 void LoadHelpAnimInfo(void)
13462 char *filename = getHelpAnimFilename();
13463 SetupFileList *setup_file_list = NULL, *list;
13464 SetupFileHash *element_hash, *action_hash, *direction_hash;
13465 int num_list_entries = 0;
13466 int num_unknown_tokens = 0;
13469 if (fileExists(filename))
13470 setup_file_list = loadSetupFileList(filename);
13472 if (setup_file_list == NULL)
13474 // use reliable default values from static configuration
13475 SetupFileList *insert_ptr;
13477 insert_ptr = setup_file_list =
13478 newSetupFileList(helpanim_config[0].token,
13479 helpanim_config[0].value);
13481 for (i = 1; helpanim_config[i].token; i++)
13482 insert_ptr = addListEntry(insert_ptr,
13483 helpanim_config[i].token,
13484 helpanim_config[i].value);
13487 element_hash = newSetupFileHash();
13488 action_hash = newSetupFileHash();
13489 direction_hash = newSetupFileHash();
13491 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
13492 setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
13494 for (i = 0; i < NUM_ACTIONS; i++)
13495 setHashEntry(action_hash, element_action_info[i].suffix,
13496 i_to_a(element_action_info[i].value));
13498 // do not store direction index (bit) here, but direction value!
13499 for (i = 0; i < NUM_DIRECTIONS_FULL; i++)
13500 setHashEntry(direction_hash, element_direction_info[i].suffix,
13501 i_to_a(1 << element_direction_info[i].value));
13503 for (list = setup_file_list; list != NULL; list = list->next)
13505 char *element_token, *action_token, *direction_token;
13506 char *element_value, *action_value, *direction_value;
13507 int delay = atoi(list->value);
13509 if (strEqual(list->token, "end"))
13511 add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
13516 /* first try to break element into element/action/direction parts;
13517 if this does not work, also accept combined "element[.act][.dir]"
13518 elements (like "dynamite.active"), which are unique elements */
13520 if (strchr(list->token, '.') == NULL) // token contains no '.'
13522 element_value = getHashEntry(element_hash, list->token);
13523 if (element_value != NULL) // element found
13524 add_helpanim_entry(atoi(element_value), -1, -1, delay,
13525 &num_list_entries);
13528 // no further suffixes found -- this is not an element
13529 print_unknown_token(filename, list->token, num_unknown_tokens++);
13535 // token has format "<prefix>.<something>"
13537 action_token = strchr(list->token, '.'); // suffix may be action ...
13538 direction_token = action_token; // ... or direction
13540 element_token = getStringCopy(list->token);
13541 *strchr(element_token, '.') = '\0';
13543 element_value = getHashEntry(element_hash, element_token);
13545 if (element_value == NULL) // this is no element
13547 element_value = getHashEntry(element_hash, list->token);
13548 if (element_value != NULL) // combined element found
13549 add_helpanim_entry(atoi(element_value), -1, -1, delay,
13550 &num_list_entries);
13552 print_unknown_token(filename, list->token, num_unknown_tokens++);
13554 free(element_token);
13559 action_value = getHashEntry(action_hash, action_token);
13561 if (action_value != NULL) // action found
13563 add_helpanim_entry(atoi(element_value), atoi(action_value), -1, delay,
13564 &num_list_entries);
13566 free(element_token);
13571 direction_value = getHashEntry(direction_hash, direction_token);
13573 if (direction_value != NULL) // direction found
13575 add_helpanim_entry(atoi(element_value), -1, atoi(direction_value), delay,
13576 &num_list_entries);
13578 free(element_token);
13583 if (strchr(action_token + 1, '.') == NULL)
13585 // no further suffixes found -- this is not an action nor direction
13587 element_value = getHashEntry(element_hash, list->token);
13588 if (element_value != NULL) // combined element found
13589 add_helpanim_entry(atoi(element_value), -1, -1, delay,
13590 &num_list_entries);
13592 print_unknown_token(filename, list->token, num_unknown_tokens++);
13594 free(element_token);
13599 // token has format "<prefix>.<suffix>.<something>"
13601 direction_token = strchr(action_token + 1, '.');
13603 action_token = getStringCopy(action_token);
13604 *strchr(action_token + 1, '.') = '\0';
13606 action_value = getHashEntry(action_hash, action_token);
13608 if (action_value == NULL) // this is no action
13610 element_value = getHashEntry(element_hash, list->token);
13611 if (element_value != NULL) // combined element found
13612 add_helpanim_entry(atoi(element_value), -1, -1, delay,
13613 &num_list_entries);
13615 print_unknown_token(filename, list->token, num_unknown_tokens++);
13617 free(element_token);
13618 free(action_token);
13623 direction_value = getHashEntry(direction_hash, direction_token);
13625 if (direction_value != NULL) // direction found
13627 add_helpanim_entry(atoi(element_value), atoi(action_value),
13628 atoi(direction_value), delay, &num_list_entries);
13630 free(element_token);
13631 free(action_token);
13636 // this is no direction
13638 element_value = getHashEntry(element_hash, list->token);
13639 if (element_value != NULL) // combined element found
13640 add_helpanim_entry(atoi(element_value), -1, -1, delay,
13641 &num_list_entries);
13643 print_unknown_token(filename, list->token, num_unknown_tokens++);
13645 free(element_token);
13646 free(action_token);
13649 print_unknown_token_end(num_unknown_tokens);
13651 add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
13652 add_helpanim_entry(HELPANIM_LIST_END, -1, -1, -1, &num_list_entries);
13654 freeSetupFileList(setup_file_list);
13655 freeSetupFileHash(element_hash);
13656 freeSetupFileHash(action_hash);
13657 freeSetupFileHash(direction_hash);
13660 for (i = 0; i < num_list_entries; i++)
13661 Debug("files:LoadHelpAnimInfo", "'%s': %d, %d, %d => %d",
13662 EL_NAME(helpanim_info[i].element),
13663 helpanim_info[i].element,
13664 helpanim_info[i].action,
13665 helpanim_info[i].direction,
13666 helpanim_info[i].delay);
13670 void LoadHelpTextInfo(void)
13672 char *filename = getHelpTextFilename();
13675 if (helptext_info != NULL)
13677 freeSetupFileHash(helptext_info);
13678 helptext_info = NULL;
13681 if (fileExists(filename))
13682 helptext_info = loadSetupFileHash(filename);
13684 if (helptext_info == NULL)
13686 // use reliable default values from static configuration
13687 helptext_info = newSetupFileHash();
13689 for (i = 0; helptext_config[i].token; i++)
13690 setHashEntry(helptext_info,
13691 helptext_config[i].token,
13692 helptext_config[i].value);
13696 BEGIN_HASH_ITERATION(helptext_info, itr)
13698 Debug("files:LoadHelpTextInfo", "'%s' => '%s'",
13699 HASH_ITERATION_TOKEN(itr), HASH_ITERATION_VALUE(itr));
13701 END_HASH_ITERATION(hash, itr)
13706 // ----------------------------------------------------------------------------
13708 // ----------------------------------------------------------------------------
13710 #define MAX_NUM_CONVERT_LEVELS 1000
13712 void ConvertLevels(void)
13714 static LevelDirTree *convert_leveldir = NULL;
13715 static int convert_level_nr = -1;
13716 static int num_levels_handled = 0;
13717 static int num_levels_converted = 0;
13718 static boolean levels_failed[MAX_NUM_CONVERT_LEVELS];
13721 convert_leveldir = getTreeInfoFromIdentifier(leveldir_first,
13722 global.convert_leveldir);
13724 if (convert_leveldir == NULL)
13725 Fail("no such level identifier: '%s'", global.convert_leveldir);
13727 leveldir_current = convert_leveldir;
13729 if (global.convert_level_nr != -1)
13731 convert_leveldir->first_level = global.convert_level_nr;
13732 convert_leveldir->last_level = global.convert_level_nr;
13735 convert_level_nr = convert_leveldir->first_level;
13737 PrintLine("=", 79);
13738 Print("Converting levels\n");
13739 PrintLine("-", 79);
13740 Print("Level series identifier: '%s'\n", convert_leveldir->identifier);
13741 Print("Level series name: '%s'\n", convert_leveldir->name);
13742 Print("Level series author: '%s'\n", convert_leveldir->author);
13743 Print("Number of levels: %d\n", convert_leveldir->levels);
13744 PrintLine("=", 79);
13747 for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
13748 levels_failed[i] = FALSE;
13750 while (convert_level_nr <= convert_leveldir->last_level)
13752 char *level_filename;
13755 level_nr = convert_level_nr++;
13757 Print("Level %03d: ", level_nr);
13759 LoadLevel(level_nr);
13760 if (level.no_level_file || level.no_valid_file)
13762 Print("(no level)\n");
13766 Print("converting level ... ");
13769 // special case: conversion of some EMC levels as requested by ACME
13770 level.game_engine_type = GAME_ENGINE_TYPE_RND;
13773 level_filename = getDefaultLevelFilename(level_nr);
13774 new_level = !fileExists(level_filename);
13778 SaveLevel(level_nr);
13780 num_levels_converted++;
13782 Print("converted.\n");
13786 if (level_nr >= 0 && level_nr < MAX_NUM_CONVERT_LEVELS)
13787 levels_failed[level_nr] = TRUE;
13789 Print("NOT CONVERTED -- LEVEL ALREADY EXISTS.\n");
13792 num_levels_handled++;
13796 PrintLine("=", 79);
13797 Print("Number of levels handled: %d\n", num_levels_handled);
13798 Print("Number of levels converted: %d (%d%%)\n", num_levels_converted,
13799 (num_levels_handled ?
13800 num_levels_converted * 100 / num_levels_handled : 0));
13801 PrintLine("-", 79);
13802 Print("Summary (for automatic parsing by scripts):\n");
13803 Print("LEVELDIR '%s', CONVERTED %d/%d (%d%%)",
13804 convert_leveldir->identifier, num_levels_converted,
13805 num_levels_handled,
13806 (num_levels_handled ?
13807 num_levels_converted * 100 / num_levels_handled : 0));
13809 if (num_levels_handled != num_levels_converted)
13811 Print(", FAILED:");
13812 for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
13813 if (levels_failed[i])
13818 PrintLine("=", 79);
13820 CloseAllAndExit(0);
13824 // ----------------------------------------------------------------------------
13825 // create and save images for use in level sketches (raw BMP format)
13826 // ----------------------------------------------------------------------------
13828 void CreateLevelSketchImages(void)
13834 InitElementPropertiesGfxElement();
13836 bitmap1 = CreateBitmap(TILEX, TILEY, DEFAULT_DEPTH);
13837 bitmap2 = CreateBitmap(MINI_TILEX, MINI_TILEY, DEFAULT_DEPTH);
13839 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
13841 int element = getMappedElement(i);
13842 char basename1[16];
13843 char basename2[16];
13847 sprintf(basename1, "%04d.bmp", i);
13848 sprintf(basename2, "%04ds.bmp", i);
13850 filename1 = getPath2(global.create_sketch_images_dir, basename1);
13851 filename2 = getPath2(global.create_sketch_images_dir, basename2);
13853 DrawSizedElement(0, 0, element, TILESIZE);
13854 BlitBitmap(drawto, bitmap1, SX, SY, TILEX, TILEY, 0, 0);
13856 if (SDL_SaveBMP(bitmap1->surface, filename1) != 0)
13857 Fail("cannot save level sketch image file '%s'", filename1);
13859 DrawSizedElement(0, 0, element, MINI_TILESIZE);
13860 BlitBitmap(drawto, bitmap2, SX, SY, MINI_TILEX, MINI_TILEY, 0, 0);
13862 if (SDL_SaveBMP(bitmap2->surface, filename2) != 0)
13863 Fail("cannot save level sketch image file '%s'", filename2);
13868 // create corresponding SQL statements (for normal and small images)
13871 printf("insert into phpbb_words values (NULL, '`%03d', '<IMG class=\"levelsketch\" src=\"/I/%04d.png\"/>');\n", i, i);
13872 printf("insert into phpbb_words values (NULL, '¸%03d', '<IMG class=\"levelsketch\" src=\"/I/%04ds.png\"/>');\n", i, i);
13875 printf("insert into phpbb_words values (NULL, '`%04d', '<IMG class=\"levelsketch\" src=\"/I/%04d.png\"/>');\n", i, i);
13876 printf("insert into phpbb_words values (NULL, '¸%04d', '<IMG class=\"levelsketch\" src=\"/I/%04ds.png\"/>');\n", i, i);
13878 // optional: create content for forum level sketch demonstration post
13880 fprintf(stderr, "%03d `%03d%c", i, i, (i % 10 < 9 ? ' ' : '\n'));
13883 FreeBitmap(bitmap1);
13884 FreeBitmap(bitmap2);
13887 fprintf(stderr, "\n");
13889 Info("%d normal and small images created", NUM_FILE_ELEMENTS);
13891 CloseAllAndExit(0);
13895 // ----------------------------------------------------------------------------
13896 // create and save images for element collecting animations (raw BMP format)
13897 // ----------------------------------------------------------------------------
13899 static boolean createCollectImage(int element)
13901 return (IS_COLLECTIBLE(element) && !IS_SP_ELEMENT(element));
13904 void CreateCollectElementImages(void)
13908 int anim_frames = num_steps - 1;
13909 int tile_size = TILESIZE;
13910 int anim_width = tile_size * anim_frames;
13911 int anim_height = tile_size;
13912 int num_collect_images = 0;
13913 int pos_collect_images = 0;
13915 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
13916 if (createCollectImage(i))
13917 num_collect_images++;
13919 Info("Creating %d element collecting animation images ...",
13920 num_collect_images);
13922 int dst_width = anim_width * 2;
13923 int dst_height = anim_height * num_collect_images / 2;
13924 Bitmap *dst_bitmap = CreateBitmap(dst_width, dst_height, DEFAULT_DEPTH);
13925 char *basename_bmp = "RocksCollect.bmp";
13926 char *basename_png = "RocksCollect.png";
13927 char *filename_bmp = getPath2(global.create_collect_images_dir, basename_bmp);
13928 char *filename_png = getPath2(global.create_collect_images_dir, basename_png);
13929 int len_filename_bmp = strlen(filename_bmp);
13930 int len_filename_png = strlen(filename_png);
13931 int max_command_len = MAX_FILENAME_LEN + len_filename_bmp + len_filename_png;
13932 char cmd_convert[max_command_len];
13934 snprintf(cmd_convert, max_command_len, "convert \"%s\" \"%s\"",
13938 // force using RGBA surface for destination bitmap
13939 SDL_SetColorKey(dst_bitmap->surface, SET_TRANSPARENT_PIXEL,
13940 SDL_MapRGB(dst_bitmap->surface->format, 0x00, 0x00, 0x00));
13942 dst_bitmap->surface =
13943 SDL_ConvertSurfaceFormat(dst_bitmap->surface, SDL_PIXELFORMAT_ARGB8888, 0);
13945 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
13947 if (!createCollectImage(i))
13950 int dst_x = (pos_collect_images / (num_collect_images / 2)) * anim_width;
13951 int dst_y = (pos_collect_images % (num_collect_images / 2)) * anim_height;
13952 int graphic = el2img(i);
13953 char *token_name = element_info[i].token_name;
13954 Bitmap *tmp_bitmap = CreateBitmap(tile_size, tile_size, DEFAULT_DEPTH);
13955 Bitmap *src_bitmap;
13958 Info("- creating collecting image for '%s' ...", token_name);
13960 getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
13962 BlitBitmap(src_bitmap, tmp_bitmap, src_x, src_y,
13963 tile_size, tile_size, 0, 0);
13965 // force using RGBA surface for temporary bitmap (using transparent black)
13966 SDL_SetColorKey(tmp_bitmap->surface, SET_TRANSPARENT_PIXEL,
13967 SDL_MapRGB(tmp_bitmap->surface->format, 0x00, 0x00, 0x00));
13969 tmp_bitmap->surface =
13970 SDL_ConvertSurfaceFormat(tmp_bitmap->surface, SDL_PIXELFORMAT_ARGB8888, 0);
13972 tmp_bitmap->surface_masked = tmp_bitmap->surface;
13974 for (j = 0; j < anim_frames; j++)
13976 int frame_size_final = tile_size * (anim_frames - j) / num_steps;
13977 int frame_size = frame_size_final * num_steps;
13978 int offset = (tile_size - frame_size_final) / 2;
13979 Bitmap *frame_bitmap = ZoomBitmap(tmp_bitmap, frame_size, frame_size);
13981 while (frame_size > frame_size_final)
13985 Bitmap *half_bitmap = ZoomBitmap(frame_bitmap, frame_size, frame_size);
13987 FreeBitmap(frame_bitmap);
13989 frame_bitmap = half_bitmap;
13992 BlitBitmapMasked(frame_bitmap, dst_bitmap, 0, 0,
13993 frame_size_final, frame_size_final,
13994 dst_x + j * tile_size + offset, dst_y + offset);
13996 FreeBitmap(frame_bitmap);
13999 tmp_bitmap->surface_masked = NULL;
14001 FreeBitmap(tmp_bitmap);
14003 pos_collect_images++;
14006 if (SDL_SaveBMP(dst_bitmap->surface, filename_bmp) != 0)
14007 Fail("cannot save element collecting image file '%s'", filename_bmp);
14009 FreeBitmap(dst_bitmap);
14011 Info("Converting image file from BMP to PNG ...");
14013 if (system(cmd_convert) != 0)
14014 Fail("converting image file failed");
14016 unlink(filename_bmp);
14020 CloseAllAndExit(0);
14024 // ----------------------------------------------------------------------------
14025 // create and save images for custom and group elements (raw BMP format)
14026 // ----------------------------------------------------------------------------
14028 void CreateCustomElementImages(char *directory)
14030 char *src_basename = "RocksCE-template.ilbm";
14031 char *dst_basename = "RocksCE.bmp";
14032 char *src_filename = getPath2(directory, src_basename);
14033 char *dst_filename = getPath2(directory, dst_basename);
14034 Bitmap *src_bitmap;
14036 int yoffset_ce = 0;
14037 int yoffset_ge = (TILEY * NUM_CUSTOM_ELEMENTS / 16);
14040 InitVideoDefaults();
14042 ReCreateBitmap(&backbuffer, video.width, video.height);
14044 src_bitmap = LoadImage(src_filename);
14046 bitmap = CreateBitmap(TILEX * 16 * 2,
14047 TILEY * (NUM_CUSTOM_ELEMENTS + NUM_GROUP_ELEMENTS) / 16,
14050 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
14057 BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
14058 TILEX * x, TILEY * y + yoffset_ce);
14060 BlitBitmap(src_bitmap, bitmap, 0, TILEY,
14062 TILEX * x + TILEX * 16,
14063 TILEY * y + yoffset_ce);
14065 for (j = 2; j >= 0; j--)
14069 BlitBitmap(src_bitmap, bitmap,
14070 TILEX + c * 7, 0, 6, 10,
14071 TILEX * x + 6 + j * 7,
14072 TILEY * y + 11 + yoffset_ce);
14074 BlitBitmap(src_bitmap, bitmap,
14075 TILEX + c * 8, TILEY, 6, 10,
14076 TILEX * 16 + TILEX * x + 6 + j * 8,
14077 TILEY * y + 10 + yoffset_ce);
14083 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
14090 BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
14091 TILEX * x, TILEY * y + yoffset_ge);
14093 BlitBitmap(src_bitmap, bitmap, 0, TILEY,
14095 TILEX * x + TILEX * 16,
14096 TILEY * y + yoffset_ge);
14098 for (j = 1; j >= 0; j--)
14102 BlitBitmap(src_bitmap, bitmap, TILEX + c * 10, 11, 10, 10,
14103 TILEX * x + 6 + j * 10,
14104 TILEY * y + 11 + yoffset_ge);
14106 BlitBitmap(src_bitmap, bitmap,
14107 TILEX + c * 8, TILEY + 12, 6, 10,
14108 TILEX * 16 + TILEX * x + 10 + j * 8,
14109 TILEY * y + 10 + yoffset_ge);
14115 if (SDL_SaveBMP(bitmap->surface, dst_filename) != 0)
14116 Fail("cannot save CE graphics file '%s'", dst_filename);
14118 FreeBitmap(bitmap);
14120 CloseAllAndExit(0);