1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2024 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
15 struct GameInfo_BD game_bd;
16 struct LevelInfo_BD native_bd_level;
17 struct EngineSnapshotInfo_BD engine_snapshot_bd;
20 // ============================================================================
21 // initialization functions
22 // ============================================================================
24 void InitGfxBuffers_BD(void)
26 ReCreateBitmap(&gd_screen_bitmap, SXSIZE, SYSIZE);
28 set_cell_size(TILESIZE_VAR);
29 set_play_area(SXSIZE, SYSIZE);
32 void bd_open_all(void)
39 gd_c64_import_init_tables();
48 void bd_close_all(void)
53 // ============================================================================
54 // level file functions
55 // ============================================================================
57 void setLevelInfoToDefaults_BD_Ext(int width, int height)
59 GdCave *cave = native_bd_level.cave;
64 // get empty cave, using default values
67 // set cave size, if defined
68 if (width > 0 && height > 0)
75 cave->x2 = cave->w - 1;
76 cave->y2 = cave->h - 1;
79 gd_flatten_cave(cave, 0);
81 cave->selectable = TRUE;
82 cave->intermission = FALSE;
84 native_bd_level.cave = cave;
85 native_bd_level.replay = NULL;
87 native_bd_level.cave_nr = 0;
88 native_bd_level.level_nr = 0;
90 native_bd_level.loaded_from_caveset = FALSE;
93 void setLevelInfoToDefaults_BD(void)
95 setLevelInfoToDefaults_BD_Ext(0, 0);
98 static List *getNativeLevelReplay_BD_Ext(List *item, boolean only_successful_replays)
100 // look for replay that was recorded for the current difficulty level
101 while (item != NULL &&
102 (item->data == NULL ||
103 (((GdReplay *)item->data)->success == FALSE && only_successful_replays) ||
104 ((GdReplay *)item->data)->level != native_bd_level.level_nr))
110 static List *getNativeLevelReplay_BD(List *replays)
112 // 1st try: look for successful replay
113 List *item = getNativeLevelReplay_BD_Ext(replays, TRUE);
118 // 2nd try: look for any replay
119 return getNativeLevelReplay_BD_Ext(replays, FALSE);
122 boolean LoadNativeLevel_BD(char *filename, int level_pos, boolean level_info_only)
124 static char *filename_loaded = NULL;
126 if (filename_loaded == NULL || !strEqual(filename, filename_loaded))
128 if (!gd_caveset_load_from_file(filename))
130 if (!level_info_only)
131 Warn("cannot load BD cave set from file '%s'", filename);
136 setString(&filename_loaded, filename);
139 if (level_pos < 0 || level_pos >= 5 * gd_caveset_count())
141 Warn("invalid level position %d in BD cave set", level_pos);
146 native_bd_level.cave_nr = level_pos % gd_caveset_count();
147 native_bd_level.level_nr = level_pos / gd_caveset_count();
149 if (native_bd_level.cave != NULL)
150 gd_cave_free(native_bd_level.cave);
152 // get selected cave, prepared for playing
153 native_bd_level.cave = gd_get_prepared_cave_from_caveset(native_bd_level.cave_nr,
154 native_bd_level.level_nr);
156 // set better initial cave speed (to set better native replay tape length)
157 set_initial_cave_speed(native_bd_level.cave);
159 native_bd_level.loaded_from_caveset = TRUE;
161 // check if this cave has any replays
162 if (native_bd_level.cave->replays != NULL)
164 List *item = getNativeLevelReplay_BD(native_bd_level.cave->replays);
166 // check if any matching replay was found
168 native_bd_level.replay = (GdReplay *)item->data;
174 boolean SaveNativeLevel_BD(char *filename)
176 GdCave *cave = gd_cave_new_from_cave(native_bd_level.cave);
179 gd_caveset = list_append(gd_caveset, cave);
181 return gd_caveset_save_to_file(filename);
184 void DumpLevelset_BD(void)
186 int num_levels_per_cave = (gd_caveset_has_levels() ? 5 : 1);
188 Print("Number of levels: %d\n", num_levels_per_cave * gd_caveset_count());
189 Print("First level number: %d\n", 1);
193 // ============================================================================
194 // game engine functions
195 // ============================================================================
197 int map_action_RND_to_BD(int action)
199 GdDirection player_move = gd_direction_from_keypress(action & JOY_UP,
203 boolean player_fire = (action & (JOY_BUTTON_1 | JOY_BUTTON_2));
205 return (player_move | (player_fire ? GD_REPLAY_FIRE_MASK : 0));
208 int map_action_BD_to_RND(int action)
210 GdDirection player_move = action & GD_REPLAY_MOVE_MASK;
211 boolean player_fire = action & GD_REPLAY_FIRE_MASK;
213 int action_move = (player_move == GD_MV_UP ? JOY_UP :
214 player_move == GD_MV_UP_RIGHT ? JOY_UP | JOY_RIGHT :
215 player_move == GD_MV_RIGHT ? JOY_RIGHT :
216 player_move == GD_MV_DOWN_RIGHT ? JOY_DOWN | JOY_RIGHT :
217 player_move == GD_MV_DOWN ? JOY_DOWN :
218 player_move == GD_MV_DOWN_LEFT ? JOY_DOWN | JOY_LEFT :
219 player_move == GD_MV_LEFT ? JOY_LEFT :
220 player_move == GD_MV_UP_LEFT ? JOY_UP | JOY_LEFT : JOY_NO_ACTION);
221 int action_fire = (player_fire ? JOY_BUTTON_1 : JOY_NO_ACTION);
223 return (action_move | action_fire);
226 boolean checkGameRunning_BD(void)
228 return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CAVE_RUNNING);
231 boolean checkGamePlaying_BD(void)
233 return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CAVE_RUNNING &&
234 game_bd.game->cave != NULL && game_bd.game->cave->hatched);
237 boolean checkBonusTime_BD(void)
239 return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CHECK_BONUS_TIME);
242 int getFramesPerSecond_BD(void)
244 if (game_bd.game != NULL && game_bd.game->cave != NULL && game_bd.game->cave->pal_timing)
245 return FRAMES_PER_SECOND_NTSC;
247 return FRAMES_PER_SECOND_PAL;
250 int getTimeLeft_BD(void)
252 if (game_bd.game != NULL && game_bd.game->cave != NULL)
253 return gd_cave_time_show(game_bd.game->cave, game_bd.game->cave->time);
258 void SetTimeFrames_BD(int frames_played)
260 // needed to store final time after solving game (before counting down remaining time)
261 if (game_bd.game->state_counter == GAME_INT_CAVE_RUNNING)
262 game_bd.frames_played = frames_played;
266 static void UpdateGameDoorValues_BD(void)
268 GdCave *cave = game_bd.game->cave;
269 int time_left = gd_cave_time_show(cave, cave->time);
270 int gems_still_needed = MAX(0, (cave->diamonds_needed - cave->diamonds_collected));
272 game_bd.time_left = time_left;
273 game_bd.gems_still_needed = gems_still_needed;
274 game_bd.score = game_bd.game->player_score;
276 if (game.LevelSolved)
278 // update time and score in panel while counting bonus time
279 game.LevelSolved_CountingTime = game_bd.time_left;
280 game.LevelSolved_CountingScore = game_bd.score;
284 static void PrepareGameTileBitmap_BD(void)
286 struct GraphicInfo_BD *g_template = &graphic_info_bd_color_template;
287 struct GraphicInfo_BD *g_default = &graphic_info_bd_object[O_STONE][0];
289 // prepare bitmap using cave ready for playing (may have changed colors)
290 gd_prepare_tile_bitmap(game_bd.game->cave, g_template->bitmap, 1);
292 // set reference bitmap which should be replaced with prepared bitmap
293 gd_set_tile_bitmap_reference(g_default->bitmap);
296 void PreparePreviewTileBitmap_BD(Bitmap *bitmap, int scale_down_factor)
298 // prepare bitmap using cave from file (with originally defined colors)
299 gd_prepare_tile_bitmap(native_bd_level.cave, bitmap, scale_down_factor);
302 void SetPreviewTileBitmapReference_BD(Bitmap *bitmap)
304 gd_set_tile_bitmap_reference(bitmap);
307 Bitmap *GetPreviewTileBitmap_BD(Bitmap *bitmap)
309 return gd_get_tile_bitmap(bitmap);
312 unsigned int InitEngineRandom_BD(int seed)
314 if (seed == NEW_RANDOMIZE)
316 // get randomly selected seed to render the cave
317 seed = gd_random_int_range(0, GD_CAVE_SEED_MAX);
320 game_bd.random_seed = seed;
322 return (unsigned int)seed;
325 void InitGameEngine_BD(void)
327 game_bd.level_solved = FALSE;
328 game_bd.game_over = FALSE;
329 game_bd.cover_screen = FALSE;
331 gd_caveset_last_selected = native_bd_level.cave_nr;
332 gd_caveset_last_selected_level = native_bd_level.level_nr;
334 if (game_bd.game != NULL)
335 gd_game_free(game_bd.game);
337 game_bd.game = gd_game_new(native_bd_level.cave_nr, native_bd_level.level_nr);
339 game_bd.game->itercycle = 0;
340 game_bd.game->itermax = 8; // default; dynamically changed at runtime
341 game_bd.game->itermax_last = game_bd.game->itermax;
343 // default: start with completely covered playfield
344 int next_state = GAME_INT_START_UNCOVER + 1;
346 // when skipping uncovering, start with uncovered playfield
347 if (setup.bd_skip_uncovering)
348 next_state = GAME_INT_LOAD_CAVE + 1;
350 // first iteration loads and prepares the cave (may change colors)
351 play_game_func(game_bd.game, 0);
353 // prepare tile bitmap with level-specific colors, if available
354 PrepareGameTileBitmap_BD();
356 // fast-forward game engine to selected state (covered or uncovered)
357 while (game_bd.game->state_counter < next_state)
358 play_game_func(game_bd.game, 0);
360 // when skipping uncovering, continue with uncovered playfield
361 if (setup.bd_skip_uncovering)
362 game_bd.game->state_counter = GAME_INT_UNCOVER_ALL + 1;
363 else if (isLevelEditorTestGame())
364 game_bd.game->state_counter = GAME_INT_UNCOVER_ALL - 8;
366 if (setup.bd_skip_uncovering || isLevelEditorTestGame())
367 gd_scroll(game_bd.game, TRUE, TRUE);
369 ClearRectangle(gd_screen_bitmap, 0, 0, SXSIZE, SYSIZE);
371 RedrawPlayfield_BD(TRUE);
373 UpdateGameDoorValues_BD();
376 void GameActions_BD(byte action[MAX_PLAYERS])
378 GdCave *cave = game_bd.game->cave;
379 boolean player_found = FALSE;
386 for (y = 0; y < cave->h && !player_found; y++)
388 for (x = 0; x < cave->w && !player_found; x++)
390 int element = *cave->getp(cave, x, y);
392 if (element == O_PLAYER ||
393 element == O_PLAYER_BOMB ||
394 element == O_PLAYER_STIRRING ||
395 element == O_PLAYER_PNEUMATIC_LEFT ||
396 element == O_PLAYER_PNEUMATIC_RIGHT)
407 UpdateEngineValues(get_scroll_x(),
412 if (setup.bd_skip_hatching && !game_bd.game->cave->hatched &&
413 game_bd.game->state_counter == GAME_INT_CAVE_RUNNING)
415 // fast-forward game engine until player hatched
416 while (!game_bd.game->cave->hatched)
418 play_game_func(game_bd.game, 0);
420 // also record or replay tape action during fast-forward
421 action = TapeCorrectAction_BD(action);
425 play_game_func(game_bd.game, action[0]);
427 // scroll without iterating engine if player out of sight (mainly due to wrap-around)
428 // (this is needed to prevent broken tapes in case of viewport or tile size changes)
429 while (game_bd.game->out_of_window)
431 RedrawPlayfield_BD(TRUE);
433 BlitScreenToBitmap_BD(backbuffer);
437 play_game_func(game_bd.game, action[0]);
440 RedrawPlayfield_BD(FALSE);
442 UpdateGameDoorValues_BD();
446 // ============================================================================
447 // graphics functions
448 // ============================================================================
450 // check if native BD graphics engine requested in custom graphics configuration
451 boolean use_native_bd_graphics_engine(void)
453 return game.use_native_bd_graphics_engine;
456 // check if smooth game element movements selected in setup menu
457 boolean use_bd_smooth_movements(void)
459 return ((setup.bd_smooth_movements == STATE_TRUE) ||
460 (setup.bd_smooth_movements == STATE_AUTO && !use_native_bd_graphics_engine()));
463 // check if player pushing graphics selected in setup menu
464 boolean use_bd_pushing_graphics(void)
466 return ((setup.bd_pushing_graphics == STATE_TRUE) ||
467 (setup.bd_pushing_graphics == STATE_AUTO && !use_native_bd_graphics_engine()));
470 // check if player up/down graphics selected in setup menu
471 boolean use_bd_up_down_graphics(void)
473 return ((setup.bd_up_down_graphics == STATE_TRUE) ||
474 (setup.bd_up_down_graphics == STATE_AUTO && !use_native_bd_graphics_engine()));
477 // check if skipping falling sounds selected in setup menu
478 boolean skip_bd_falling_sounds(void)
480 return ((setup.bd_skip_falling_sounds == STATE_TRUE) ||
481 (setup.bd_skip_falling_sounds == STATE_AUTO && !game.use_native_bd_sound_engine));
484 Bitmap **GetTitleScreenBitmaps_BD(void)
486 Bitmap **title_screen_bitmaps = gd_get_title_screen_bitmaps();
488 if (title_screen_bitmaps == NULL || title_screen_bitmaps[0] == NULL)
491 return title_screen_bitmaps;
494 void CoverScreen_BD(void)
496 game_bd.cover_screen = FALSE;
498 if (setup.bd_skip_uncovering)
501 game_bd.game->state_counter = GAME_INT_COVER_START;
503 // play game engine (with normal speed) until cave covered
504 while (game_bd.game->state_counter < GAME_INT_COVER_ALL + 1)
506 play_game_func(game_bd.game, 0);
508 RedrawPlayfield_BD(TRUE);
510 BlitScreenToBitmap_BD(backbuffer);
515 // stop uncovering loop sound when not using native sound engine
519 void BlitScreenToBitmap_BD(Bitmap *target_bitmap)
521 GdCave *cave = native_bd_level.cave;
524 int full_xsize = (cave->x2 - cave->x1 + 1) * TILESIZE_VAR;
525 int full_ysize = (cave->y2 - cave->y1 + 1) * TILESIZE_VAR;
526 int sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
527 int sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
528 int sxsize = (full_xsize < xsize ? full_xsize : xsize);
529 int sysize = (full_ysize < ysize ? full_ysize : ysize);
531 BlitBitmap(gd_screen_bitmap, target_bitmap, 0, 0, sxsize, sysize, sx, sy);
534 void RedrawPlayfield_BD(boolean force_redraw)
536 gd_drawcave(gd_screen_bitmap, game_bd.game, force_redraw);