added option for BD1 magic wall / amoeba bug for native BD engine
[rocksndiamonds.git] / src / game_bd / main_bd.c
1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2024 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // main_bd.c
10 // ============================================================================
11
12 #include "main_bd.h"
13
14
15 struct GameInfo_BD game_bd;
16 struct LevelInfo_BD native_bd_level;
17 struct EngineSnapshotInfo_BD engine_snapshot_bd;
18
19
20 // ============================================================================
21 // initialization functions
22 // ============================================================================
23
24 void InitGfxBuffers_BD(void)
25 {
26   ReCreateBitmap(&gd_screen_bitmap, SXSIZE, SYSIZE);
27
28   set_cell_size(TILESIZE_VAR);
29   set_play_area(SXSIZE, SYSIZE);
30 }
31
32 void bd_open_all(void)
33 {
34   InitGraphicInfo_BD();
35
36   gd_cave_init();
37   gd_cave_db_init();
38
39   gd_c64_import_init_tables();
40
41   gd_caveset_clear();
42
43   gd_init_keystate();
44
45   gd_sound_init();
46 }
47
48 void bd_close_all(void)
49 {
50 }
51
52
53 // ============================================================================
54 // level file functions
55 // ============================================================================
56
57 void setLevelInfoToDefaults_BD_Ext(int width, int height)
58 {
59   GdCave *cave = native_bd_level.cave;
60
61   if (cave != NULL)
62     gd_cave_free(cave);
63
64   // get empty cave, using default values
65   cave = gd_cave_new();
66
67   // set cave size, if defined
68   if (width > 0 && height > 0)
69   {
70     cave->w = width;
71     cave->h = height;
72
73     cave->x1 = 0;
74     cave->y1 = 0;
75     cave->x2 = cave->w - 1;
76     cave->y2 = cave->h - 1;
77   }
78
79   gd_flatten_cave(cave, 0);
80
81   cave->selectable = TRUE;
82   cave->intermission = FALSE;
83
84   native_bd_level.cave = cave;
85   native_bd_level.replay = NULL;
86
87   native_bd_level.cave_nr = 0;
88   native_bd_level.level_nr = 0;
89
90   native_bd_level.loaded_from_caveset = FALSE;
91 }
92
93 void setLevelInfoToDefaults_BD(void)
94 {
95   setLevelInfoToDefaults_BD_Ext(0, 0);
96 }
97
98 static List *getNativeLevelReplay_BD_Ext(List *item, boolean only_successful_replays)
99 {
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))
105     item = item->next;
106
107   return item;
108 }
109
110 static List *getNativeLevelReplay_BD(List *replays)
111 {
112   // 1st try: look for successful replay
113   List *item = getNativeLevelReplay_BD_Ext(replays, TRUE);
114
115   if (item != NULL)
116     return item;
117
118   // 2nd try: look for any replay
119   return getNativeLevelReplay_BD_Ext(replays, FALSE);
120 }
121
122 boolean LoadNativeLevel_BD(char *filename, int level_pos, boolean level_info_only)
123 {
124   static char *filename_loaded = NULL;
125
126   if (filename_loaded == NULL || !strEqual(filename, filename_loaded))
127   {
128     if (!gd_caveset_load_from_file(filename))
129     {
130       if (!level_info_only)
131         Warn("cannot load BD cave set from file '%s'", filename);
132
133       return FALSE;
134     }
135
136     setString(&filename_loaded, filename);
137   }
138
139   if (level_pos < 0 || level_pos >= 5 * gd_caveset_count())
140   {
141     Warn("invalid level position %d in BD cave set", level_pos);
142
143     return FALSE;
144   }
145
146   native_bd_level.cave_nr  = level_pos % gd_caveset_count();
147   native_bd_level.level_nr = level_pos / gd_caveset_count();
148
149   if (native_bd_level.cave != NULL)
150     gd_cave_free(native_bd_level.cave);
151
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);
155
156   // set better initial cave speed (to set better native replay tape length)
157   set_initial_cave_speed(native_bd_level.cave);
158
159   native_bd_level.loaded_from_caveset = TRUE;
160
161   // check if this cave has any replays
162   if (native_bd_level.cave->replays != NULL)
163   {
164     List *item = getNativeLevelReplay_BD(native_bd_level.cave->replays);
165
166     // check if any matching replay was found
167     if (item != NULL)
168       native_bd_level.replay = (GdReplay *)item->data;
169   }
170
171   return TRUE;
172 }
173
174 boolean SaveNativeLevel_BD(char *filename)
175 {
176   GdCave *cave = gd_cave_new_from_cave(native_bd_level.cave);
177
178   gd_caveset_clear();
179   gd_caveset = list_append(gd_caveset, cave);
180
181   return gd_caveset_save_to_file(filename);
182 }
183
184
185 // ============================================================================
186 // game engine functions
187 // ============================================================================
188
189 int map_action_RND_to_BD(int action)
190 {
191   GdDirection player_move = gd_direction_from_keypress(action & JOY_UP,
192                                                        action & JOY_DOWN,
193                                                        action & JOY_LEFT,
194                                                        action & JOY_RIGHT);
195   boolean player_fire = (action & (JOY_BUTTON_1 | JOY_BUTTON_2));
196
197   return (player_move | (player_fire ? GD_REPLAY_FIRE_MASK : 0));
198 }
199
200 int map_action_BD_to_RND(int action)
201 {
202   GdDirection player_move = action & GD_REPLAY_MOVE_MASK;
203   boolean     player_fire = action & GD_REPLAY_FIRE_MASK;
204
205   int action_move = (player_move == GD_MV_UP            ? JOY_UP                :
206                      player_move == GD_MV_UP_RIGHT      ? JOY_UP   | JOY_RIGHT  :
207                      player_move == GD_MV_RIGHT         ?            JOY_RIGHT  :
208                      player_move == GD_MV_DOWN_RIGHT    ? JOY_DOWN | JOY_RIGHT  :
209                      player_move == GD_MV_DOWN          ? JOY_DOWN              :
210                      player_move == GD_MV_DOWN_LEFT     ? JOY_DOWN | JOY_LEFT   :
211                      player_move == GD_MV_LEFT          ?            JOY_LEFT   :
212                      player_move == GD_MV_UP_LEFT       ? JOY_UP   | JOY_LEFT   : JOY_NO_ACTION);
213   int action_fire = (player_fire ? JOY_BUTTON_1 : JOY_NO_ACTION);
214
215   return (action_move | action_fire);
216 }
217
218 boolean checkGameRunning_BD(void)
219 {
220   return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CAVE_RUNNING);
221 }
222
223 boolean checkGamePlaying_BD(void)
224 {
225   return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CAVE_RUNNING &&
226           game_bd.game->cave != NULL && game_bd.game->cave->hatched);
227 }
228
229 boolean checkBonusTime_BD(void)
230 {
231   return (game_bd.game != NULL && game_bd.game->state_counter == GAME_INT_CHECK_BONUS_TIME);
232 }
233
234 int getFramesPerSecond_BD(void)
235 {
236   if (game_bd.game != NULL && game_bd.game->cave != NULL && game_bd.game->cave->pal_timing)
237     return FRAMES_PER_SECOND_NTSC;
238
239   return FRAMES_PER_SECOND_PAL;
240 }
241
242 int getTimeLeft_BD(void)
243 {
244   if (game_bd.game != NULL && game_bd.game->cave != NULL)
245     return gd_cave_time_show(game_bd.game->cave, game_bd.game->cave->time);
246
247   return 0;
248 }
249
250 static void UpdateGameDoorValues_BD(void)
251 {
252   GdCave *cave = game_bd.game->cave;
253   int time_secs = gd_cave_time_show(cave, cave->time);
254   int gems_still_needed = MAX(0, (cave->diamonds_needed - cave->diamonds_collected));
255
256   game_bd.time_played = time_secs;
257   game_bd.gems_still_needed = gems_still_needed;
258   game_bd.score = game_bd.game->player_score;
259
260   if (game.LevelSolved)
261   {
262     // update time and score in panel while counting bonus time
263     game.LevelSolved_CountingTime  = game_bd.time_played;
264     game.LevelSolved_CountingScore = game_bd.score;
265   }
266 }
267
268 static void PrepareGameTileBitmap_BD(void)
269 {
270   struct GraphicInfo_BD *g_template = &graphic_info_bd_color_template;
271   struct GraphicInfo_BD *g_default  = &graphic_info_bd_object[O_STONE][0];
272
273   gd_prepare_tile_bitmap(native_bd_level.cave, g_template->bitmap, 1);
274   gd_set_tile_bitmap_reference(g_default->bitmap);
275 }
276
277 void PreparePreviewTileBitmap_BD(Bitmap *bitmap, int scale_down_factor)
278 {
279   gd_prepare_tile_bitmap(native_bd_level.cave, bitmap, scale_down_factor);
280 }
281
282 void SetPreviewTileBitmapReference_BD(Bitmap *bitmap)
283 {
284   gd_set_tile_bitmap_reference(bitmap);
285 }
286
287 Bitmap *GetPreviewTileBitmap_BD(Bitmap *bitmap)
288 {
289   return gd_get_tile_bitmap(bitmap);
290 }
291
292 unsigned int InitEngineRandom_BD(int seed)
293 {
294   if (seed == NEW_RANDOMIZE)
295   {
296     // get randomly selected seed to render the cave
297     seed = gd_random_int_range(0, GD_CAVE_SEED_MAX);
298   }
299
300   game_bd.random_seed = seed;
301
302   return (unsigned int)seed;
303 }
304
305 void InitGameEngine_BD(void)
306 {
307   game_bd.level_solved = FALSE;
308   game_bd.game_over = FALSE;
309   game_bd.cover_screen = FALSE;
310
311   game_bd.time_played = 0;
312   game_bd.gems_still_needed = 0;
313   game_bd.score = 0;
314
315   gd_caveset_last_selected       = native_bd_level.cave_nr;
316   gd_caveset_last_selected_level = native_bd_level.level_nr;
317
318   if (game_bd.game != NULL)
319     gd_game_free(game_bd.game);
320
321   game_bd.game = gd_game_new(native_bd_level.cave_nr, native_bd_level.level_nr);
322
323   game_bd.game->itercycle = 0;
324   game_bd.game->itermax = 8;    // default; dynamically changed at runtime
325   game_bd.game->itermax_last = game_bd.game->itermax;
326
327   // prepare tile bitmap with level-specific colors, if available
328   PrepareGameTileBitmap_BD();
329
330   // default: start with completely covered playfield
331   int next_state = GAME_INT_START_UNCOVER + 1;
332
333   // when skipping uncovering, start with uncovered playfield
334   if (setup.bd_skip_uncovering)
335     next_state = GAME_INT_LOAD_CAVE + 1;
336
337   // fast-forward game engine until cave loaded (covered or uncovered)
338   while (game_bd.game->state_counter < next_state)
339     play_game_func(game_bd.game, 0);
340
341   // when skipping uncovering, continue with uncovered playfield
342   if (setup.bd_skip_uncovering)
343     game_bd.game->state_counter = GAME_INT_UNCOVER_ALL + 1;
344
345   if (setup.bd_skip_uncovering)
346     gd_scroll(game_bd.game, TRUE, TRUE);
347
348   ClearRectangle(gd_screen_bitmap, 0, 0, SXSIZE, SYSIZE);
349
350   RedrawPlayfield_BD(TRUE);
351
352   UpdateGameDoorValues_BD();
353 }
354
355 void GameActions_BD(byte action[MAX_PLAYERS])
356 {
357   GdCave *cave = game_bd.game->cave;
358   boolean player_found = FALSE;
359   int player_x = 0;
360   int player_y = 0;
361   int x, y;
362
363   if (cave->getp)
364   {
365     for (y = 0; y < cave->h && !player_found; y++)
366     {
367       for (x = 0; x < cave->w && !player_found; x++)
368       {
369         int element = *cave->getp(cave, x, y);
370
371         if (element == O_PLAYER ||
372             element == O_PLAYER_BOMB ||
373             element == O_PLAYER_STIRRING ||
374             element == O_PLAYER_PNEUMATIC_LEFT ||
375             element == O_PLAYER_PNEUMATIC_RIGHT)
376         {
377           player_x = x;
378           player_y = y;
379
380           player_found = TRUE;
381         }
382       }
383     }
384   }
385
386   UpdateEngineValues(get_scroll_x(),
387                      get_scroll_y(),
388                      player_x,
389                      player_y);
390
391   if (setup.bd_skip_hatching && !game_bd.game->cave->hatched &&
392       game_bd.game->state_counter == GAME_INT_CAVE_RUNNING)
393   {
394     // fast-forward game engine until player hatched
395     while (!game_bd.game->cave->hatched)
396     {
397       play_game_func(game_bd.game, 0);
398
399       // also record or replay tape action during fast-forward
400       action = TapeCorrectAction_BD(action);
401     }
402   }
403
404   play_game_func(game_bd.game, action[0]);
405
406   // scroll without iterating engine if player out of sight (mainly due to wrap-around)
407   // (this is needed to prevent broken tapes in case of viewport or tile size changes)
408   while (game_bd.game->out_of_window)
409   {
410     RedrawPlayfield_BD(TRUE);
411
412     BlitScreenToBitmap_BD(backbuffer);
413
414     BackToFront();
415
416     play_game_func(game_bd.game, action[0]);
417   }
418
419   RedrawPlayfield_BD(FALSE);
420
421   UpdateGameDoorValues_BD();
422 }
423
424
425 // ============================================================================
426 // graphics functions
427 // ============================================================================
428
429 Bitmap *GetTitleScreen_BD(void)
430 {
431   return gd_get_title_screen_bitmap();
432 }
433
434 void CoverScreen_BD(void)
435 {
436   game_bd.cover_screen = FALSE;
437
438   if (setup.bd_skip_uncovering)
439     return;
440
441   game_bd.game->state_counter = GAME_INT_COVER_START;
442
443   // play game engine (with normal speed) until cave covered
444   while (game_bd.game->state_counter < GAME_INT_COVER_ALL + 1)
445   {
446     play_game_func(game_bd.game, 0);
447
448     RedrawPlayfield_BD(TRUE);
449
450     BlitScreenToBitmap_BD(backbuffer);
451
452     BackToFront();
453   }
454
455   // stop uncovering loop sound when not using native sound engine
456   FadeSounds();
457 }
458
459 void BlitScreenToBitmap_BD(Bitmap *target_bitmap)
460 {
461   GdCave *cave = native_bd_level.cave;
462   int xsize = SXSIZE;
463   int ysize = SYSIZE;
464   int full_xsize = (cave->x2 - cave->x1 + 1) * TILESIZE_VAR;
465   int full_ysize = (cave->y2 - cave->y1 + 1) * TILESIZE_VAR;
466   int sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
467   int sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
468   int sxsize = (full_xsize < xsize ? full_xsize : xsize);
469   int sysize = (full_ysize < ysize ? full_ysize : ysize);
470
471   BlitBitmap(gd_screen_bitmap, target_bitmap, 0, 0, sxsize, sysize, sx, sy);
472 }
473
474 void RedrawPlayfield_BD(boolean force_redraw)
475 {
476   gd_drawcave(gd_screen_bitmap, game_bd.game, force_redraw);
477 }