X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_em%2Freademc.c;h=40b0a609dd92d20b077d75d68eaaeff266bf9cc8;hb=47ed33d197cbd8d560197cb364b759a2239dff98;hp=3bb920ab2286dec72514f3f0356ad88d1fa2a1b3;hpb=061f84155f331a4a605e59f985b7ea5313bb9b8b;p=rocksndiamonds.git diff --git a/src/game_em/reademc.c b/src/game_em/reademc.c index 3bb920ab..40b0a609 100644 --- a/src/game_em/reademc.c +++ b/src/game_em/reademc.c @@ -40,6 +40,8 @@ * behaviour. */ +#define GET_BE16(x) ((&x)[0] << 8 | (&x)[1]) + static const short map_emc[256] = { Xstone, Xstone, Xdiamond, Xdiamond, @@ -95,7 +97,7 @@ static const short map_emc[256] = Xfake_grass, Xlenses, Xmagnify, Xfake_blank, Xfake_grass, Xswitch, Xswitch, Xblank, Xdecor_8, Xdecor_9, Xdecor_10, Xdecor_5, - Xalpha_comma, Xalpha_quote, Xalpha_minus, Xdynamite, + Xalpha_comma, Xalpha_apost, Xalpha_minus, Xdynamite, Xsteel_3, Xdecor_6, Xdecor_7, Xsteel_2, Xroundwall_2, Xdecor_2, Xdecor_4, Xdecor_3, @@ -123,320 +125,340 @@ static const short map_emc[256] = Xblank, Xblank, Xalpha_copyr, Xfake_acid_1 }; -static int get_em_element(unsigned short em_element_raw, int file_version) +static void init_android_clone_table(short android_clone_bits) { - int em_element = map_emc[em_element_raw]; - - if (file_version < FILE_VERSION_EM_V5) - { - /* versions below V5 had no grass, but only sand/dirt */ - if (em_element == Xgrass) - em_element = Xdirt; - } + boolean android_emerald = (android_clone_bits & 1) != 0; + boolean android_diamond = (android_clone_bits & 2) != 0; + boolean android_stone = (android_clone_bits & 4) != 0; + boolean android_bomb = (android_clone_bits & 8) != 0; + boolean android_nut = (android_clone_bits & 16) != 0; + boolean android_tank = (android_clone_bits & 32) != 0; + boolean android_eater = (android_clone_bits & 64) != 0; + boolean android_bug = (android_clone_bits & 128) != 0; + boolean android_alien = (android_clone_bits & 256) != 0; + boolean android_spring = (android_clone_bits & 512) != 0; + boolean android_balloon = (android_clone_bits & 1024) != 0; + boolean android_amoeba = (android_clone_bits & 2048) != 0; + boolean android_dynamite = (android_clone_bits & 4096) != 0; + int i; - return em_element; -} + for (i = 0; i < TILE_MAX; i++) + cav.android_array[i] = Xblank; -void convert_em_level(unsigned char *src, int file_version) -{ - static int eater_offset[8] = + if (android_eater) { - 0x800, 0x809, 0x812, 0x81B, 0x840, 0x849, 0x852, 0x85B - }; - int i, x, y, temp; + cav.android_array[Xeater_n] = Xeater_n; + cav.android_array[Yeater_nB] = Xeater_n; - lev.time_seconds = src[0x83E] << 8 | src[0x83F]; - if (lev.time_seconds > 9999) - lev.time_seconds = 9999; + cav.android_array[Xeater_e] = Xeater_e; + cav.android_array[Yeater_eB] = Xeater_e; - lev.required_initial = src[0x82F]; + cav.android_array[Xeater_s] = Xeater_s; + cav.android_array[Yeater_sB] = Xeater_s; - for (i = 0; i < 2; i++) - { - temp = src[0x830 + i * 2] << 8 | src[0x831 + i * 2]; - ply[i].x_initial = (temp & 63); - ply[i].y_initial = (temp >> 6 & 31); + cav.android_array[Xeater_w] = Xeater_w; + cav.android_array[Yeater_wB] = Xeater_w; } - temp = (src[0x834] << 8 | src[0x835]) * 28; - if (temp > 9999) - temp = 9999; - lev.amoeba_time = temp; - - lev.android_move_time = src[0x874] << 8 | src[0x875]; - lev.android_clone_time = src[0x876] << 8 | src[0x877]; - - lev.ball_random = src[0x872] & 1 ? 1 : 0; - lev.ball_state_initial = src[0x872] & 128 ? 1 : 0; - lev.ball_time = src[0x870] << 8 | src[0x871]; - - lev.emerald_score = src[0x824]; - lev.diamond_score = src[0x825]; - lev.alien_score = src[0x826]; - lev.tank_score = src[0x827]; - lev.bug_score = src[0x828]; - lev.eater_score = src[0x829]; - lev.nut_score = src[0x82A]; - lev.dynamite_score = src[0x82B]; - lev.key_score = src[0x82C]; - lev.exit_score = src[0x82D] * 8 / 5; - lev.lenses_score = src[0x867]; - lev.magnify_score = src[0x868]; - lev.slurp_score = src[0x869]; - - lev.lenses_time = src[0x86A] << 8 | src[0x86B]; - lev.magnify_time = src[0x86C] << 8 | src[0x86D]; - lev.wheel_time = src[0x838] << 8 | src[0x839]; - - lev.wind_cnt_initial = src[0x865] & 15 ? lev.wind_time : 0; - temp = src[0x865]; - lev.wind_direction_initial = (temp & 8 ? 0 : - temp & 1 ? 1 : - temp & 2 ? 2 : - temp & 4 ? 3 : 0); - - lev.wonderwall_time_initial = src[0x836] << 8 | src[0x837]; - - for (i = 0; i < 8; i++) - for (x = 0; x < 9; x++) - lev.eater_array[i][x] = - get_em_element(src[eater_offset[i] + x], file_version); - - temp = get_em_element(src[0x86F], file_version); - for (y = 0; y < 8; y++) + if (android_alien) { - if (src[0x872] & 1) - { - for (x = 0; x < 8; x++) - lev.ball_array[y][x] = temp; - } - else - { - lev.ball_array[y][1] = (src[0x873] & 1) ? temp : Xblank; /* north */ - lev.ball_array[y][6] = (src[0x873] & 2) ? temp : Xblank; /* south */ - lev.ball_array[y][3] = (src[0x873] & 4) ? temp : Xblank; /* west */ - lev.ball_array[y][4] = (src[0x873] & 8) ? temp : Xblank; /* east */ - lev.ball_array[y][7] = (src[0x873] & 16) ? temp : Xblank; /* southeast */ - lev.ball_array[y][5] = (src[0x873] & 32) ? temp : Xblank; /* southwest */ - lev.ball_array[y][2] = (src[0x873] & 64) ? temp : Xblank; /* northeast */ - lev.ball_array[y][0] = (src[0x873] & 128)? temp : Xblank; /* northwest */ - } + cav.android_array[Xalien] = Xalien; + cav.android_array[Xalien_pause] = Xalien; + cav.android_array[Yalien_nB] = Xalien; + cav.android_array[Yalien_eB] = Xalien; + cav.android_array[Yalien_sB] = Xalien; + cav.android_array[Yalien_wB] = Xalien; } - temp = src[0x878] << 8 | src[0x879]; - - if (temp & 1) + if (android_bug) { - lev.android_array[Xemerald] = Xemerald; - lev.android_array[Xemerald_pause] = Xemerald; - lev.android_array[Xemerald_fall] = Xemerald; - lev.android_array[Yemerald_sB] = Xemerald; - lev.android_array[Yemerald_eB] = Xemerald; - lev.android_array[Yemerald_wB] = Xemerald; + cav.android_array[Xbug_1_n] = Xbug_2_n; + cav.android_array[Xbug_2_n] = Xbug_2_n; + cav.android_array[Ybug_nB] = Xbug_2_n; + cav.android_array[Ybug_n_e] = Xbug_2_n; + cav.android_array[Ybug_n_w] = Xbug_2_n; + + cav.android_array[Xbug_1_e] = Xbug_2_e; + cav.android_array[Xbug_2_e] = Xbug_2_e; + cav.android_array[Ybug_eB] = Xbug_2_e; + cav.android_array[Ybug_e_s] = Xbug_2_e; + cav.android_array[Ybug_e_n] = Xbug_2_e; + + cav.android_array[Xbug_1_s] = Xbug_2_s; + cav.android_array[Xbug_2_s] = Xbug_2_s; + cav.android_array[Ybug_sB] = Xbug_2_s; + cav.android_array[Ybug_s_w] = Xbug_2_s; + cav.android_array[Ybug_s_e] = Xbug_2_s; + + cav.android_array[Xbug_1_w] = Xbug_2_w; + cav.android_array[Xbug_2_w] = Xbug_2_w; + cav.android_array[Ybug_wB] = Xbug_2_w; + cav.android_array[Ybug_w_n] = Xbug_2_w; + cav.android_array[Ybug_w_s] = Xbug_2_w; } - if (temp & 2) + if (android_tank) { - lev.android_array[Xdiamond] = Xdiamond; - lev.android_array[Xdiamond_pause] = Xdiamond; - lev.android_array[Xdiamond_fall] = Xdiamond; - lev.android_array[Ydiamond_sB] = Xdiamond; - lev.android_array[Ydiamond_eB] = Xdiamond; - lev.android_array[Ydiamond_wB] = Xdiamond; + cav.android_array[Xtank_1_n] = Xtank_1_n; + cav.android_array[Xtank_2_n] = Xtank_1_n; + cav.android_array[Ytank_nB] = Xtank_1_n; + cav.android_array[Ytank_n_e] = Xtank_1_n; + cav.android_array[Ytank_n_w] = Xtank_1_n; + + cav.android_array[Xtank_1_e] = Xtank_1_e; + cav.android_array[Xtank_2_e] = Xtank_1_e; + cav.android_array[Ytank_eB] = Xtank_1_e; + cav.android_array[Ytank_e_s] = Xtank_1_e; + cav.android_array[Ytank_e_n] = Xtank_1_e; + + cav.android_array[Xtank_1_s] = Xtank_1_s; + cav.android_array[Xtank_2_s] = Xtank_1_s; + cav.android_array[Ytank_sB] = Xtank_1_s; + cav.android_array[Ytank_s_w] = Xtank_1_s; + cav.android_array[Ytank_s_e] = Xtank_1_s; + + cav.android_array[Xtank_1_w] = Xtank_1_w; + cav.android_array[Xtank_2_w] = Xtank_1_w; + cav.android_array[Ytank_wB] = Xtank_1_w; + cav.android_array[Ytank_w_n] = Xtank_1_w; + cav.android_array[Ytank_w_s] = Xtank_1_w; } - if (temp & 4) + if (android_emerald) { - lev.android_array[Xstone] = Xstone; - lev.android_array[Xstone_pause] = Xstone; - lev.android_array[Xstone_fall] = Xstone; - lev.android_array[Ystone_sB] = Xstone; - lev.android_array[Ystone_eB] = Xstone; - lev.android_array[Ystone_wB] = Xstone; + cav.android_array[Xemerald] = Xemerald; + cav.android_array[Xemerald_pause] = Xemerald; + cav.android_array[Xemerald_fall] = Xemerald; + cav.android_array[Yemerald_sB] = Xemerald; + cav.android_array[Yemerald_eB] = Xemerald; + cav.android_array[Yemerald_wB] = Xemerald; } - if (temp & 8) + if (android_diamond) { - lev.android_array[Xbomb] = Xbomb; - lev.android_array[Xbomb_pause] = Xbomb; - lev.android_array[Xbomb_fall] = Xbomb; - lev.android_array[Ybomb_sB] = Xbomb; - lev.android_array[Ybomb_eB] = Xbomb; - lev.android_array[Ybomb_wB] = Xbomb; + cav.android_array[Xdiamond] = Xdiamond; + cav.android_array[Xdiamond_pause] = Xdiamond; + cav.android_array[Xdiamond_fall] = Xdiamond; + cav.android_array[Ydiamond_sB] = Xdiamond; + cav.android_array[Ydiamond_eB] = Xdiamond; + cav.android_array[Ydiamond_wB] = Xdiamond; } - if (temp & 16) + if (android_stone) { - lev.android_array[Xnut] = Xnut; - lev.android_array[Xnut_pause] = Xnut; - lev.android_array[Xnut_fall] = Xnut; - lev.android_array[Ynut_sB] = Xnut; - lev.android_array[Ynut_eB] = Xnut; - lev.android_array[Ynut_wB] = Xnut; + cav.android_array[Xstone] = Xstone; + cav.android_array[Xstone_pause] = Xstone; + cav.android_array[Xstone_fall] = Xstone; + cav.android_array[Ystone_sB] = Xstone; + cav.android_array[Ystone_eB] = Xstone; + cav.android_array[Ystone_wB] = Xstone; } - if (temp & 32) + if (android_bomb) { - lev.android_array[Xtank_1_n] = Xtank_1_n; - lev.android_array[Xtank_2_n] = Xtank_1_n; - lev.android_array[Ytank_nB] = Xtank_1_n; - lev.android_array[Ytank_n_e] = Xtank_1_n; - lev.android_array[Ytank_n_w] = Xtank_1_n; - - lev.android_array[Xtank_1_e] = Xtank_1_e; - lev.android_array[Xtank_2_e] = Xtank_1_e; - lev.android_array[Ytank_eB] = Xtank_1_e; - lev.android_array[Ytank_e_s] = Xtank_1_e; - lev.android_array[Ytank_e_n] = Xtank_1_e; - - lev.android_array[Xtank_1_s] = Xtank_1_s; - lev.android_array[Xtank_2_s] = Xtank_1_s; - lev.android_array[Ytank_sB] = Xtank_1_s; - lev.android_array[Ytank_s_w] = Xtank_1_s; - lev.android_array[Ytank_s_e] = Xtank_1_s; - - lev.android_array[Xtank_1_w] = Xtank_1_w; - lev.android_array[Xtank_2_w] = Xtank_1_w; - lev.android_array[Ytank_wB] = Xtank_1_w; - lev.android_array[Ytank_w_n] = Xtank_1_w; - lev.android_array[Ytank_w_s] = Xtank_1_w; + cav.android_array[Xbomb] = Xbomb; + cav.android_array[Xbomb_pause] = Xbomb; + cav.android_array[Xbomb_fall] = Xbomb; + cav.android_array[Ybomb_sB] = Xbomb; + cav.android_array[Ybomb_eB] = Xbomb; + cav.android_array[Ybomb_wB] = Xbomb; } - if (temp & 64) + if (android_nut) { - lev.android_array[Xeater_n] = Xeater_n; - lev.android_array[Yeater_nB] = Xeater_n; - - lev.android_array[Xeater_e] = Xeater_e; - lev.android_array[Yeater_eB] = Xeater_e; - - lev.android_array[Xeater_s] = Xeater_s; - lev.android_array[Yeater_sB] = Xeater_s; - - lev.android_array[Xeater_w] = Xeater_w; - lev.android_array[Yeater_wB] = Xeater_w; + cav.android_array[Xnut] = Xnut; + cav.android_array[Xnut_pause] = Xnut; + cav.android_array[Xnut_fall] = Xnut; + cav.android_array[Ynut_sB] = Xnut; + cav.android_array[Ynut_eB] = Xnut; + cav.android_array[Ynut_wB] = Xnut; } - if (temp & 128) + if (android_spring) { - lev.android_array[Xbug_1_n] = Xbug_2_n; - lev.android_array[Xbug_2_n] = Xbug_2_n; - lev.android_array[Ybug_nB] = Xbug_2_n; - lev.android_array[Ybug_n_e] = Xbug_2_n; - lev.android_array[Ybug_n_w] = Xbug_2_n; - - lev.android_array[Xbug_1_e] = Xbug_2_e; - lev.android_array[Xbug_2_e] = Xbug_2_e; - lev.android_array[Ybug_eB] = Xbug_2_e; - lev.android_array[Ybug_e_s] = Xbug_2_e; - lev.android_array[Ybug_e_n] = Xbug_2_e; - - lev.android_array[Xbug_1_s] = Xbug_2_s; - lev.android_array[Xbug_2_s] = Xbug_2_s; - lev.android_array[Ybug_sB] = Xbug_2_s; - lev.android_array[Ybug_s_w] = Xbug_2_s; - lev.android_array[Ybug_s_e] = Xbug_2_s; - - lev.android_array[Xbug_1_w] = Xbug_2_w; - lev.android_array[Xbug_2_w] = Xbug_2_w; - lev.android_array[Ybug_wB] = Xbug_2_w; - lev.android_array[Ybug_w_n] = Xbug_2_w; - lev.android_array[Ybug_w_s] = Xbug_2_w; + cav.android_array[Xspring] = Xspring; + cav.android_array[Xspring_pause] = Xspring; + cav.android_array[Xspring_fall] = Xspring; + cav.android_array[Xspring_e] = Xspring; + cav.android_array[Xspring_w] = Xspring; + cav.android_array[Yspring_sB] = Xspring; + cav.android_array[Yspring_eB] = Xspring; + cav.android_array[Yspring_wB] = Xspring; + cav.android_array[Yspring_alien_eB] = Xspring; + cav.android_array[Yspring_alien_wB] = Xspring; } - if (temp & 256) + if (android_dynamite) { - lev.android_array[Xalien] = Xalien; - lev.android_array[Xalien_pause] = Xalien; - lev.android_array[Yalien_nB] = Xalien; - lev.android_array[Yalien_eB] = Xalien; - lev.android_array[Yalien_sB] = Xalien; - lev.android_array[Yalien_wB] = Xalien; + cav.android_array[Xdynamite] = Xdynamite; } - if (temp & 512) + if (android_balloon) { - lev.android_array[Xspring] = Xspring; - lev.android_array[Xspring_pause] = Xspring; - lev.android_array[Xspring_e] = Xspring; - lev.android_array[Yspring_eB] = Xspring; - lev.android_array[Yspring_alien_eB] = Xspring; - lev.android_array[Xspring_w] = Xspring; - lev.android_array[Yspring_wB] = Xspring; - lev.android_array[Yspring_alien_wB] = Xspring; - lev.android_array[Xspring_fall] = Xspring; - lev.android_array[Yspring_sB] = Xspring; + cav.android_array[Xballoon] = Xballoon; + cav.android_array[Yballoon_nB] = Xballoon; + cav.android_array[Yballoon_eB] = Xballoon; + cav.android_array[Yballoon_sB] = Xballoon; + cav.android_array[Yballoon_wB] = Xballoon; } - if (temp & 1024) + if (android_amoeba) { - lev.android_array[Yballoon_nB] = Xballoon; - lev.android_array[Yballoon_eB] = Xballoon; - lev.android_array[Yballoon_sB] = Xballoon; - lev.android_array[Yballoon_wB] = Xballoon; - lev.android_array[Xballoon] = Xballoon; + cav.android_array[Xfake_amoeba] = Xdrip; + cav.android_array[Yfake_amoeba] = Xdrip; + cav.android_array[Xamoeba_1] = Xdrip; + cav.android_array[Xamoeba_2] = Xdrip; + cav.android_array[Xamoeba_3] = Xdrip; + cav.android_array[Xamoeba_4] = Xdrip; + cav.android_array[Xamoeba_5] = Xdrip; + cav.android_array[Xamoeba_6] = Xdrip; + cav.android_array[Xamoeba_7] = Xdrip; + cav.android_array[Xamoeba_8] = Xdrip; } +} - if (temp & 2048) +void convert_em_level(unsigned char *src, int file_version) +{ + static int eater_offset[8] = { - lev.android_array[Xfake_amoeba] = Xdrip; - lev.android_array[Yfake_amoeba] = Xdrip; - lev.android_array[Xamoeba_1] = Xdrip; - lev.android_array[Xamoeba_2] = Xdrip; - lev.android_array[Xamoeba_3] = Xdrip; - lev.android_array[Xamoeba_4] = Xdrip; - lev.android_array[Xamoeba_5] = Xdrip; - lev.android_array[Xamoeba_6] = Xdrip; - lev.android_array[Xamoeba_7] = Xdrip; - lev.android_array[Xamoeba_8] = Xdrip; - } + 2048, 2057, 2066, 2075, + 2112, 2121, 2130, 2139 + }; + int i, x, y, temp; - if (temp & 4096) - { - lev.android_array[Xdynamite] = Xdynamite; - } + /* common to all emc caves */ + + cav.time_seconds = MIN(GET_BE16(src[2110]), 9999); + cav.gems_needed = src[2095]; + + /* scores */ + + cav.emerald_score = src[2084]; + cav.diamond_score = src[2085]; + cav.alien_score = src[2086]; + cav.tank_score = src[2087]; + cav.bug_score = src[2088]; + cav.eater_score = src[2089]; + cav.nut_score = src[2090]; + cav.dynamite_score = src[2091]; + cav.key_score = src[2092]; + cav.exit_score = src[2093] * 8 / 5; + + cav.lenses_score = src[2151]; + cav.magnify_score = src[2152]; + cav.slurp_score = src[2153]; + + /* times */ + + cav.android_move_time = MIN(GET_BE16(src[2164]), 9999); + cav.android_clone_time = MIN(GET_BE16(src[2166]), 9999); + cav.ball_time = MIN(GET_BE16(src[2160]), 9999); + + cav.lenses_time = MIN(GET_BE16(src[2154]), 9999); + cav.magnify_time = MIN(GET_BE16(src[2156]), 9999); + cav.wheel_time = MIN(GET_BE16(src[2104]), 9999); + + cav.amoeba_time = MIN(GET_BE16(src[2100]) * 28, 9999); + cav.wonderwall_time = MIN(GET_BE16(src[2102]), 9999); + + cav.wind_cnt = src[2149] & 15 ? cav.wind_time : 0; + temp = src[2149]; + cav.wind_direction = (temp & 8 ? 0 : + temp & 1 ? 1 : + temp & 2 ? 2 : + temp & 4 ? 3 : 0); + + /* global flags */ + + cav.ball_random = src[2162] & 1 ? 1 : 0; + cav.ball_state = src[2162] & 128 ? 1 : 0; for (temp = 1; temp < 2047; temp++) { switch (src[temp]) { - case 0x24: /* wonderwall */ - lev.wonderwall_state_initial = 1; - lev.wonderwall_time_initial = 9999; + case 36: /* wonderwall */ + cav.wonderwall_state = 1; + cav.wonderwall_time = 9999; break; - case 0x28: /* wheel */ - lev.wheel_x_initial = temp & 63; - lev.wheel_y_initial = temp >> 6; - lev.wheel_cnt_initial = lev.wheel_time; + case 40: /* wheel */ + cav.wheel_x = temp & 63; + cav.wheel_y = temp >> 6; + cav.wheel_cnt = cav.wheel_time; break; - case 0xA3: /* fake blank */ - lev.lenses_cnt_initial = 9999; + case 163: /* fake blank */ + cav.lenses_cnt = 9999; break; - case 0xA4: /* fake grass */ - lev.magnify_cnt_initial = 9999; + case 164: /* fake grass */ + cav.magnify_cnt = 9999; break; } } + /* android */ + + init_android_clone_table(GET_BE16(src[2168])); + + /* eaters */ + + for (i = 0; i < 8; i++) + for (x = 0; x < 9; x++) + cav.eater_array[i][x] = map_emc[src[eater_offset[i] + x]]; + + /* ball */ + + temp = map_emc[src[2159]]; + + for (y = 0; y < 8; y++) + { + if (src[2162] & 1) + { + for (x = 0; x < 8; x++) + cav.ball_array[y][x] = temp; + } + else + { + cav.ball_array[y][1] = (src[2163] & 1) ? temp : Xblank; /* north */ + cav.ball_array[y][6] = (src[2163] & 2) ? temp : Xblank; /* south */ + cav.ball_array[y][3] = (src[2163] & 4) ? temp : Xblank; /* west */ + cav.ball_array[y][4] = (src[2163] & 8) ? temp : Xblank; /* east */ + cav.ball_array[y][7] = (src[2163] & 16) ? temp : Xblank; /* southeast */ + cav.ball_array[y][5] = (src[2163] & 32) ? temp : Xblank; /* southwest */ + cav.ball_array[y][2] = (src[2163] & 64) ? temp : Xblank; /* northeast */ + cav.ball_array[y][0] = (src[2163] & 128)? temp : Xblank; /* northwest */ + } + } + + /* players */ + + for (i = 0; i < 2; i++) + { + temp = GET_BE16(src[2096 + i * 2]); + + cav.player_x[i] = (temp & 63); + cav.player_y[i] = (temp >> 6 & 31); + } + + /* cave */ + /* first fill the complete playfield with the default border element */ for (y = 0; y < CAVE_HEIGHT; y++) for (x = 0; x < CAVE_WIDTH; x++) - native_em_level.cave[x][y] = Zborder; + cav.cave[x][y] = Zborder; /* then copy the real level contents from level file into the playfield */ temp = 0; - for (y = 0; y < lev.height; y++) - for (x = 0; x < lev.width; x++) - native_em_level.cave[x][y] = - get_em_element(src[temp++], file_version); + for (y = 0; y < cav.height; y++) + for (x = 0; x < cav.width; x++) + cav.cave[x][y] = map_emc[src[temp++]]; /* at last, set the two players at their positions in the playfield */ /* (native EM[C] levels always have exactly two players in a level) */ for (i = 0; i < 2; i++) - native_em_level.cave[ply[i].x_initial][ply[i].y_initial] = Zplayer; + cav.cave[cav.player_x[i]][cav.player_y[i]] = Zplayer; native_em_level.file_version = file_version; } @@ -464,6 +486,14 @@ void convert_em_level(unsigned char *src, int file_version) * wrong bug(24 instead of 20) and tank(12 instead of 8). */ +/* changes for game engine integration in Rocks'n'Diamonds: + * + * cave versions below V5 had no grass, but only sand/dirt + * - object code 130 (V6 grass) is changed to 189 (V6 dirt) + * - object codes are changed in both cave and eater arrays + * - only graphical change, as both objects behave the same + */ + static const unsigned char map_v6[256] = { /* filter for v6 */ @@ -528,7 +558,7 @@ static const unsigned char map_v4[256] = 153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153, 153,118,114,115, 131,118,118,119, 120,121,122,118, 118,118,118,118, - 128,129,130,131, 132,133,134,135, 136,137,138,139, 140,141,142,143, + 128,129,189,131, 132,133,134,135, 136,137,138,139, 140,141,142,143, 144,145,146,147, 148,149,150,151, 152,68,154,155, 156,157,158,160, 160,160,160,160, 160,160,160,160, 160,160,160,160, 160,160,160,175, 153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,68,153, @@ -543,7 +573,7 @@ static const unsigned char map_v4_eater[32] = { /* filter for v4 eater */ - 128,18,2,0, 4,8,16,20, 28,37,41,45, 130,129,131,132, + 128,18,2,0, 4,8,16,20, 28,37,41,45, 189,129,131,132, 133,134,135,136, 146,147,175,65, 66,64,2,18, 128,128,128,128 }; @@ -779,32 +809,11 @@ int cleanup_em_level(unsigned char *src, int length, char *filename) /* player 1 pos */ src[2096] &= 7; - src[src[2096] << 8 | src[2097]] = 128; + src[GET_BE16(src[2096])] = 128; /* player 2 pos */ src[2098] &= 7; - src[src[2098] << 8 | src[2099]] = 128; - - /* amoeba speed */ - if ((src[2100] << 8 | src[2101]) > 9999) - { - src[2100] = 39; - src[2101] = 15; - } - - /* time wonderwall */ - if ((src[2102] << 8 | src[2103]) > 9999) - { - src[2102] = 39; - src[2103] = 15; - } - - /* time */ - if ((src[2110] << 8 | src[2111]) > 9999) - { - src[2110] = 39; - src[2111] = 15; - } + src[GET_BE16(src[2098])] = 128; /* wind direction */ i = src[2149]; @@ -812,50 +821,15 @@ int cleanup_em_level(unsigned char *src, int length, char *filename) i &= -i; src[2149] = i; - /* time lenses */ - if ((src[2154] << 8 | src[2155]) > 9999) - { - src[2154] = 39; - src[2155] = 15; - } - - /* time magnify */ - if ((src[2156] << 8 | src[2157]) > 9999) - { - src[2156] = 39; - src[2157] = 15; - } - /* ball object */ src[2158] = 0; src[2159] = map_v6[src[2159]]; - /* ball pause */ - if ((src[2160] << 8 | src[2161]) > 9999) - { - src[2160] = 39; - src[2161] = 15; - } - /* ball data */ src[2162] &= 129; if (src[2162] & 1) src[2163] = 0; - /* android move pause */ - if ((src[2164] << 8 | src[2165]) > 9999) - { - src[2164] = 39; - src[2165] = 15; - } - - /* android clone pause */ - if ((src[2166] << 8 | src[2167]) > 9999) - { - src[2166] = 39; - src[2167] = 15; - } - /* android data */ src[2168] &= 31;