// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// tape.c
// ============================================================================
#define DEBUG_TAPE_WHEN_PLAYING FALSE
-/* tape button identifiers */
+// tape button identifiers
#define TAPE_CTRL_ID_EJECT 0
#define TAPE_CTRL_ID_EXTRA 1
#define TAPE_CTRL_ID_STOP 2
#define TAPE_CTRL_ID_PAUSE 3
#define TAPE_CTRL_ID_RECORD 4
#define TAPE_CTRL_ID_PLAY 5
+#define TAPE_CTRL_ID_INSERT_SOLUTION 6
+#define TAPE_CTRL_ID_PLAY_SOLUTION 7
-#define NUM_TAPE_BUTTONS 6
+#define NUM_TAPE_BUTTONS 8
-/* values for tape handling */
+// values for tape handling
#define TAPE_PAUSE_SECONDS_BEFORE_DEATH 5
-/* forward declaration for internal use */
+// forward declaration for internal use
static void HandleTapeButtons(struct GadgetInfo *);
-static void TapeStopWarpForward();
-static float GetTapeLengthSecondsFloat();
+static void TapeStopWarpForward(void);
+static float GetTapeLengthSecondsFloat(void);
static struct GadgetInfo *tape_gadget[NUM_TAPE_BUTTONS];
-/* ========================================================================= */
-/* video tape definitions */
-/* ========================================================================= */
+// ============================================================================
+// video tape definitions
+// ============================================================================
#define VIDEO_INFO_OFF (VIDEO_STATE_DATE_OFF | \
VIDEO_STATE_TIME_OFF | \
#define NUM_TAPE_FUNCTION_STATES 2
-/* ========================================================================= */
-/* video display functions */
-/* ========================================================================= */
+// ============================================================================
+// video display functions
+// ============================================================================
static void DrawVideoDisplay_Graphics(unsigned int state, unsigned int value)
{
{ -1, NULL },
},
{
- /* (no label for displaying optional frame) */
+ // (no label for displaying optional frame)
{ -1, NULL },
{ -1, NULL },
},
},
};
- for (k = 0; k < NUM_TAPE_FUNCTION_STATES; k++) /* on or off states */
+ for (k = 0; k < NUM_TAPE_FUNCTION_STATES; k++) // on or off states
{
- for (i = 0; i < NUM_TAPE_FUNCTIONS; i++) /* record, play, ... */
+ for (i = 0; i < NUM_TAPE_FUNCTIONS; i++) // record, play, ...
{
- for (j = 0; j < NUM_TAPE_FUNCTION_PARTS; j++) /* label or symbol */
+ for (j = 0; j < NUM_TAPE_FUNCTION_PARTS; j++) // label or symbol
{
int graphic = video_pos[i][j].graphic;
struct XY *pos = video_pos[i][j].pos;
if (value == skip_value)
continue;
- if (k == 1) /* on */
+ if (k == 1) // on
{
gd_bitmap = gfx->bitmap;
gd_x = gfx->src_x;
gd_y = gfx->src_y;
}
- else /* off */
+ else // off
{
gd_bitmap = gfx_bg->bitmap;
gd_x = gfx_bg->src_x + pos->x;
gd_y = gfx_bg->src_y + pos->y;
}
- /* some tape graphics may be undefined -- only draw if defined */
+ // some tape graphics may be undefined -- only draw if defined
if (gd_bitmap != NULL)
BlitBitmap(gd_bitmap, drawto, gd_x, gd_y, gfx->width, gfx->height,
VX + pos->x, VY + pos->y);
DrawVideoDisplay_DateTime(state, value);
}
-void DrawVideoDisplayLabel(unsigned int state)
+static void DrawVideoDisplayLabel(unsigned int state)
{
DrawVideoDisplay(state, VIDEO_DISPLAY_LABEL_ONLY);
}
-void DrawVideoDisplaySymbol(unsigned int state)
+static void DrawVideoDisplaySymbol(unsigned int state)
{
DrawVideoDisplay(state, VIDEO_DISPLAY_SYMBOL_ONLY);
}
-void DrawVideoDisplayCurrentState()
+static void DrawVideoDisplayCurrentState(void)
{
int state = 0;
DrawVideoDisplaySymbol(state);
}
-void DrawCompleteVideoDisplay()
+void DrawCompleteVideoDisplay(void)
{
struct GraphicInfo *g_tape = &graphic_info[IMG_BACKGROUND_TAPE];
- /* draw tape background */
+ // draw tape background
BlitBitmap(g_tape->bitmap, drawto, g_tape->src_x, g_tape->src_y,
gfx.vxsize, gfx.vysize, gfx.vx, gfx.vy);
- /* draw tape buttons (forced) */
+ // draw tape buttons (forced)
RedrawOrRemapTapeButtons();
DrawVideoDisplay(VIDEO_ALL_OFF, 0);
0, 0);
}
-void TapeDeactivateDisplayOn()
+void TapeDeactivateDisplayOn(void)
{
SetDrawDeactivationMask(REDRAW_FIELD);
audio.sound_deactivated = TRUE;
}
-/* ========================================================================= */
-/* tape logging functions */
-/* ========================================================================= */
+// ============================================================================
+// tape logging functions
+// ============================================================================
-void PrintTapeReplayProgress(boolean replay_finished)
+static void PrintTapeReplayProgress(boolean replay_finished)
{
static unsigned int counter_last = -1;
unsigned int counter = Counter();
}
-/* ========================================================================= */
-/* tape control functions */
-/* ========================================================================= */
+// ============================================================================
+// tape control functions
+// ============================================================================
void TapeSetDateFromEpochSeconds(time_t epoch_seconds)
{
tape.date = 10000 * (lt->tm_year % 100) + 100 * lt->tm_mon + lt->tm_mday;
}
-void TapeSetDateFromNow()
+void TapeSetDateFromNow(void)
{
TapeSetDateFromEpochSeconds(time(NULL));
}
-void TapeErase()
+void TapeErase(void)
{
int i;
tape.centered_player_nr_next = -1;
tape.set_centered_player = FALSE;
- tape.use_mouse = (level.game_engine_type == GAME_ENGINE_TYPE_MM);
+ // set flags for game actions to default values (may be overwritten later)
+ tape.use_key_actions = TRUE;
+ tape.use_mouse_actions = FALSE;
}
-static void TapeRewind()
+static void TapeRewind(void)
{
tape.counter = 0;
tape.delay_played = 0;
SetDrawDeactivationMask(REDRAW_NONE);
audio.sound_deactivated = FALSE;
+
+ // required here to update video display if tape door is closed
+ if (GetDoorState() & DOOR_CLOSE_2)
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
}
-static void TapeStartGameRecording()
+static void TapeStartGameRecording(void)
{
- TapeStartRecording(level.random_seed);
-
-#if defined(NETWORK_AVALIABLE)
- if (options.network)
- {
- SendToServer_StartPlaying();
-
- return;
- }
-#endif
-
- InitGame();
+ StartGameActions(network.enabled, TRUE, level.random_seed);
}
-static void TapeAppendRecording()
+static void TapeAppendRecording(void)
{
if (!tape.playing || !tape.pausing)
return;
UpdateAndDisplayGameControlValues();
}
-void TapeHaltRecording()
+void TapeHaltRecording(void)
{
tape.counter++;
tape.length_seconds = GetTapeLengthSeconds();
}
-void TapeStopRecording()
+void TapeStopRecording(void)
{
if (tape.recording)
TapeHaltRecording();
MapTapeEjectButton();
}
-boolean TapeAddAction(byte action[MAX_PLAYERS])
+boolean TapeAddAction(byte action[MAX_TAPE_ACTIONS])
{
int i;
- if (tape.pos[tape.counter].delay > 0) /* already stored action */
+ if (tape.pos[tape.counter].delay > 0) // already stored action
{
boolean changed_events = FALSE;
- for (i = 0; i < MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_TAPE_ACTIONS; i++)
if (tape.pos[tape.counter].action[i] != action[i])
changed_events = TRUE;
tape.pos[tape.counter].delay++;
}
- if (tape.pos[tape.counter].delay == 0) /* store new action */
+ if (tape.pos[tape.counter].delay == 0) // store new action
{
- for (i = 0; i < MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_TAPE_ACTIONS; i++)
tape.pos[tape.counter].action[i] = action[i];
tape.pos[tape.counter].delay++;
return TRUE;
}
-void TapeRecordAction(byte action_raw[MAX_PLAYERS])
+void TapeRecordAction(byte action_raw[MAX_TAPE_ACTIONS])
{
- byte action[MAX_PLAYERS];
+ byte action[MAX_TAPE_ACTIONS];
int i;
- if (!tape.recording) /* (record action even when tape is paused) */
+ if (!tape.recording) // (record action even when tape is paused)
return;
- for (i = 0; i < MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_TAPE_ACTIONS; i++)
action[i] = action_raw[i];
- if (!tape.use_mouse && tape.set_centered_player)
+ if (tape.use_key_actions && tape.set_centered_player)
{
for (i = 0; i < MAX_PLAYERS; i++)
if (tape.centered_player_nr_next == i ||
return;
}
- if (setup.show_snapshot_buttons &&
- game_status == GAME_MODE_PLAYING &&
- CheckEngineSnapshotList())
+ if (game_status == GAME_MODE_PLAYING)
{
- if (tape.pausing)
- MapUndoRedoButtons();
- else if (!tape.single_step)
- UnmapUndoRedoButtons();
+ if (setup.show_snapshot_buttons && CheckEngineSnapshotList())
+ {
+ if (tape.pausing)
+ MapUndoRedoButtons();
+ else if (!tape.single_step)
+ UnmapUndoRedoButtons();
+ }
+
+ ModifyPauseButtons();
}
}
-void TapeStartPlaying()
+void TapeStartPlaying(void)
{
if (TAPE_IS_EMPTY(tape))
return;
audio.sound_deactivated = FALSE;
}
-static void TapeStartGamePlaying()
+static void TapeStartGamePlaying(void)
{
TapeStartPlaying();
InitGame();
}
-void TapeStopPlaying()
+void TapeStopPlaying(void)
{
tape.playing = FALSE;
tape.pausing = FALSE;
MapTapeEjectButton();
}
-byte *TapePlayAction()
+byte *TapePlayAction(void)
{
int update_delay = FRAMES_PER_SECOND / 2;
boolean update_video_display = (FrameCounter % update_delay == 0);
boolean update_draw_label_on = ((FrameCounter / update_delay) % 2 == 1);
- static byte action[MAX_PLAYERS];
+ static byte action[MAX_TAPE_ACTIONS];
int i;
if (!tape.playing || tape.pausing)
}
}
- if (tape.counter >= tape.length) /* end of tape reached */
+ if (tape.counter >= tape.length) // end of tape reached
{
if (tape.warp_forward && !tape.auto_play)
{
DrawVideoDisplaySymbol(state);
}
- for (i = 0; i < MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_TAPE_ACTIONS; i++)
action[i] = tape.pos[tape.counter].action[i];
#if DEBUG_TAPE_WHEN_PLAYING
printf("%05d", FrameCounter);
- for (i = 0; i < MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_TAPE_ACTIONS; i++)
printf(" %08x", action[i]);
printf("\n");
#endif
tape.set_centered_player = FALSE;
tape.centered_player_nr_next = -999;
- if (!tape.use_mouse)
+ if (tape.use_key_actions)
{
for (i = 0; i < MAX_PLAYERS; i++)
{
return action;
}
-void TapeStop()
+void TapeStop(void)
{
if (tape.pausing)
TapeTogglePause(TAPE_TOGGLE_MANUAL);
}
}
-unsigned int GetTapeLengthFrames()
+unsigned int GetTapeLengthFrames(void)
{
unsigned int tape_length_frames = 0;
int i;
return tape_length_frames;
}
-unsigned int GetTapeLengthSeconds()
+unsigned int GetTapeLengthSeconds(void)
{
return (GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
}
-static float GetTapeLengthSecondsFloat()
+static float GetTapeLengthSecondsFloat(void)
{
return ((float)GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
}
DrawVideoDisplayCurrentState();
}
-static void TapeStopWarpForward()
+static void TapeStopWarpForward(void)
{
tape.fast_forward = FALSE;
tape.warp_forward = FALSE;
DrawVideoDisplayCurrentState();
}
-static void TapeSingleStep()
+static void TapeSingleStep(void)
{
- if (options.network)
+ if (network.enabled)
return;
if (!tape.pausing)
DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
}
-void TapeQuickSave()
+void TapeQuickSave(void)
{
if (game_status == GAME_MODE_MAIN)
{
return;
if (tape.recording)
- TapeHaltRecording(); /* prepare tape for saving on-the-fly */
+ TapeHaltRecording(); // prepare tape for saving on-the-fly
if (TAPE_IS_EMPTY(tape))
{
SaveEngineSnapshotSingle();
}
-void TapeQuickLoad()
+void TapeQuickLoad(void)
{
char *filename = getTapeFilename(level_nr);
tape.quick_resume = TRUE;
}
- else /* this should not happen (basically checked above) */
+ else // this should not happen (basically checked above)
{
int reopen_door = (game_status == GAME_MODE_PLAYING ? REQ_REOPEN : 0);
}
}
-void InsertSolutionTape()
+boolean hasSolutionTape(void)
{
+ boolean tape_file_exists = fileExists(getSolutionTapeFilename(level_nr));
boolean level_has_tape = (level.game_engine_type == GAME_ENGINE_TYPE_SP &&
level.native_sp_level->demo.is_available);
- if (!fileExists(getSolutionTapeFilename(level_nr)) && !level_has_tape)
+ return (tape_file_exists || level_has_tape);
+}
+
+boolean InsertSolutionTape(void)
+{
+ if (!hasSolutionTape())
{
Request("No solution tape for this level!", REQ_CONFIRM);
- return;
+ return FALSE;
}
+ if (!TAPE_IS_STOPPED(tape))
+ TapeStop();
+
// if tape recorder already contains a tape, remove it without asking
TapeErase();
LoadSolutionTape(level_nr);
+ DrawCompleteVideoDisplay();
+
if (TAPE_IS_EMPTY(tape))
+ {
Request("Loading solution tape for this level failed!", REQ_CONFIRM);
- DrawCompleteVideoDisplay();
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+boolean PlaySolutionTape(void)
+{
+ if (!InsertSolutionTape())
+ return FALSE;
+
+ TapeStartGamePlaying();
+
+ return TRUE;
}
-/* ------------------------------------------------------------------------- *
- * tape autoplay functions
- * ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// tape autoplay functions
+// ----------------------------------------------------------------------------
-void AutoPlayTape()
+void AutoPlayTape(void)
{
static LevelDirTree *autoplay_leveldir = NULL;
static boolean autoplay_initialized = FALSE;
if (autoplay_initialized)
{
- /* just finished auto-playing tape */
+ // just finished auto-playing tape
PrintTapeReplayProgress(TRUE);
num_levels_played++;
}
#if 0
- /* ACTIVATE THIS FOR LOADING/TESTING OF LEVELS ONLY */
+ // ACTIVATE THIS FOR LOADING/TESTING OF LEVELS ONLY
Print("Level %03d: (only testing level)\n", level_nr);
continue;
#endif
PrintLine("=", 79);
Print("Number of levels played: %d\n", num_levels_played);
Print("Number of levels solved: %d (%d%%)\n", num_levels_solved,
- (num_levels_played ? num_levels_solved * 100 / num_levels_played :0));
+ (num_levels_played ? num_levels_solved * 100 / num_levels_played : 0));
PrintLine("-", 79);
Print("Summary (for automatic parsing by scripts):\n");
- Print("LEVELDIR '%s', SOLVED %d/%d (%d%%)",
- autoplay_leveldir->identifier, num_levels_solved, num_levels_played,
- (num_levels_played ? num_levels_solved * 100 / num_levels_played :0));
+ Print("LEVELDIR [%s] '%s', SOLVED %d/%d (%d%%)",
+ (num_levels_played == num_levels_solved ? " OK " : "WARN"),
+ autoplay_leveldir->identifier, num_levels_solved, num_levels_played,
+ (num_levels_played ? num_levels_solved * 100 / num_levels_played : 0));
if (num_levels_played != num_levels_solved)
{
}
-/* ---------- new tape button stuff ---------------------------------------- */
+// ----------------------------------------------------------------------------
+// tape patch functions
+// ----------------------------------------------------------------------------
+
+static boolean PatchTape(struct TapeInfo *tape, char *mode)
+{
+ Print("[%d.%d.%d.%d]: ",
+ (tape->engine_version / 1000000) % 100,
+ (tape->engine_version / 10000 ) % 100,
+ (tape->engine_version / 100 ) % 100,
+ (tape->engine_version ) % 100);
+
+ if (strEqual(mode, "info"))
+ {
+ Print("property bits == 0x%02x\n", tape->property_bits);
+
+ return FALSE;
+ }
+
+ byte property_bits = tape->property_bits;
+ byte property_bitmask = 0;
+ boolean set_property_bit = TRUE;
+
+ if (strSuffix(mode, ":0") ||
+ strSuffix(mode, ":off") ||
+ strSuffix(mode, ":clear"))
+ set_property_bit = FALSE;
+
+ if (strEqual(mode, "em_random_bug") || strPrefix(mode, "em_random_bug:"))
+ {
+ // this bug was introduced in version 3.3.1.0 and fixed in version 4.0.1.2
+ if (tape->engine_version < VERSION_IDENT(3,3,1,0) ||
+ tape->engine_version >= VERSION_IDENT(4,0,1,2))
+ {
+ Print("This tape version cannot be patched against EM random bug!\n");
+
+ return FALSE;
+ }
+
+ property_bitmask = TAPE_PROPERTY_EM_RANDOM_BUG;
+ }
+ else
+ {
+ Print("Unknown patch mode '%s'!\n", mode);
+
+ return FALSE;
+ }
+
+ if (set_property_bit)
+ property_bits |= property_bitmask;
+ else
+ property_bits &= ~property_bitmask;
+
+ if (property_bits == tape->property_bits)
+ {
+ Print("Tape already patched for '%s'!\n", mode);
+
+ return FALSE;
+ }
+
+ Print("Patching for '%s' ... ", mode);
+
+ tape->property_bits = property_bits;
+
+ return TRUE;
+}
+
+void PatchTapes(void)
+{
+ static LevelDirTree *patchtapes_leveldir = NULL;
+ static int num_tapes_found = 0;
+ static int num_tapes_patched = 0;
+ char *mode = global.patchtapes_mode;
+ int i;
+
+ if (strEqual(mode, "help"))
+ {
+ PrintLine("=", 79);
+ Print("Supported patch modes:\n");
+ Print("- \"em_random_bug\" - use 64-bit random value bug for EM engine\n");
+ PrintLine("-", 79);
+ Print("Supported modifiers:\n");
+ Print("- add \":0\", \":off\" or \":clear\" to patch mode to un-patch tape file\n");
+ PrintLine("=", 79);
+
+ CloseAllAndExit(0);
+ }
+
+ patchtapes_leveldir = getTreeInfoFromIdentifier(leveldir_first,
+ global.patchtapes_leveldir);
+
+ if (patchtapes_leveldir == NULL)
+ Error(ERR_EXIT, "no such level identifier: '%s'",
+ global.patchtapes_leveldir);
+
+ leveldir_current = patchtapes_leveldir;
+
+ if (patchtapes_leveldir->first_level < 0)
+ patchtapes_leveldir->first_level = 0;
+ if (patchtapes_leveldir->last_level >= MAX_TAPES_PER_SET)
+ patchtapes_leveldir->last_level = MAX_TAPES_PER_SET - 1;
+
+ PrintLine("=", 79);
+ Print("Patching level tapes for patch mode '%s'\n", mode);
+ PrintLine("-", 79);
+ Print("Level series identifier: '%s'\n", patchtapes_leveldir->identifier);
+ Print("Level series name: '%s'\n", patchtapes_leveldir->name);
+ Print("Level series author: '%s'\n", patchtapes_leveldir->author);
+ Print("Number of levels: %d\n", patchtapes_leveldir->levels);
+ PrintLine("=", 79);
+ Print("\n");
+
+ int first_level = patchtapes_leveldir->first_level;
+ int last_level = patchtapes_leveldir->last_level;
+
+ for (i = first_level; i <= last_level; i++)
+ {
+ if (!global.patchtapes_all && !global.patchtapes_level[i])
+ continue;
+
+ Print("Tape %03d: ", i);
+
+ TapeErase();
+ LoadTape(i);
+
+ if (tape.no_valid_file)
+ {
+ Print("(not found)\n");
+
+ continue;
+ }
+
+ num_tapes_found++;
+
+ if (PatchTape(&tape, mode))
+ {
+ char *filename = getTapeFilename(i);
+ char *filename_orig = getStringCat2(filename, ".orig");
+
+ if (!fileExists(filename_orig))
+ rename(filename, filename_orig);
+
+ SaveTapeToFilename(filename);
+
+ Print("patched tape saved.\n");
+
+ num_tapes_patched++;
+ }
+ }
+
+ Print("\n");
+ PrintLine("=", 79);
+ Print("Number of tapes found: %d\n", num_tapes_found);
+ Print("Number of tapes patched: %d\n", num_tapes_patched);
+ PrintLine("=", 79);
+
+ CloseAllAndExit(0);
+}
+
+
+// ---------- new tape button stuff -------------------------------------------
static struct
{
TAPE_CTRL_ID_EJECT, "eject tape"
},
{
- /* (same position as "eject" button) */
+ // (same position as "eject" button)
IMG_GFX_TAPE_BUTTON_EXTRA, &tape.button.eject,
TAPE_CTRL_ID_EXTRA, "extra functions"
},
{
IMG_GFX_TAPE_BUTTON_PLAY, &tape.button.play,
TAPE_CTRL_ID_PLAY, "play tape"
+ },
+ {
+ IMG_GFX_TAPE_BUTTON_INSERT_SOLUTION,&tape.button.insert_solution,
+ TAPE_CTRL_ID_INSERT_SOLUTION, "insert solution tape"
+ },
+ {
+ IMG_GFX_TAPE_BUTTON_PLAY_SOLUTION, &tape.button.play_solution,
+ TAPE_CTRL_ID_PLAY_SOLUTION, "play solution tape"
}
};
-void CreateTapeButtons()
+void CreateTapeButtons(void)
{
int i;
for (i = 0; i < NUM_TAPE_BUTTONS; i++)
{
- struct GraphicInfo *gfx = &graphic_info[tapebutton_info[i].graphic];
+ int graphic = tapebutton_info[i].graphic;
+ struct GraphicInfo *gfx = &graphic_info[graphic];
struct XY *pos = tapebutton_info[i].pos;
struct GadgetInfo *gi;
int gd_x = gfx->src_x;
int id = i;
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_IMAGE_ID, graphic,
GDI_INFO_TEXT, tapebutton_info[i].infotext,
GDI_X, VX + pos->x,
GDI_Y, VY + pos->y,
}
}
-void FreeTapeButtons()
+void FreeTapeButtons(void)
{
int i;
FreeGadget(tape_gadget[i]);
}
-void MapTapeEjectButton()
+void MapTapeEjectButton(void)
{
UnmapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
MapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
}
-void MapTapeWarpButton()
+void MapTapeWarpButton(void)
{
UnmapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
MapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
}
-void MapTapeButtons()
+void MapTapeButtons(void)
{
int i;
MapGameButtonsOnTape();
}
-void UnmapTapeButtons()
+void UnmapTapeButtons(void)
{
int i;
UnmapGameButtonsOnTape();
}
-void RedrawTapeButtons()
+void RedrawTapeButtons(void)
{
int i;
if (tape.show_game_buttons)
RedrawGameButtonsOnTape();
-
- // RedrawGadget() may have set REDRAW_ALL if buttons are defined off-area
- redraw_mask &= ~REDRAW_ALL;
}
-void RedrawOrRemapTapeButtons()
+void RedrawOrRemapTapeButtons(void)
{
if (tape_gadget[TAPE_CTRL_ID_PLAY]->mapped)
{
}
else if (tape.pausing)
{
- if (tape.playing) /* PLAY -> PAUSE -> RECORD */
+ if (tape.playing) // PLAY -> PAUSE -> RECORD
TapeAppendRecording();
else
TapeTogglePause(TAPE_TOGGLE_MANUAL);
break;
case TAPE_CTRL_ID_PLAY:
- if (tape.recording && tape.pausing) /* PAUSE -> RECORD */
+ if (tape.recording && tape.pausing) // PAUSE -> RECORD
{
// ("TAPE_IS_EMPTY(tape)" is TRUE here -- probably fix this)
}
else if (tape.playing)
{
- if (tape.pausing) /* PAUSE -> PLAY */
+ if (tape.pausing) // PAUSE -> PLAY
{
TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
}
- else if (!tape.fast_forward) /* PLAY -> FFWD */
+ else if (!tape.fast_forward) // PLAY -> FFWD
{
tape.fast_forward = TRUE;
}
- else if (!tape.warp_forward) /* FFWD -> WARP */
+ else if (!tape.warp_forward) // FFWD -> WARP
{
tape.warp_forward = TRUE;
}
- else if (!tape.deactivate_display) /* WARP -> WARP BLIND */
+ else if (!tape.deactivate_display) // WARP -> WARP BLIND
{
tape.deactivate_display = TRUE;
TapeDeactivateDisplayOn();
}
- else /* WARP BLIND -> PLAY */
+ else // WARP BLIND -> PLAY
{
tape.fast_forward = FALSE;
tape.warp_forward = FALSE;
break;
+ case TAPE_CTRL_ID_INSERT_SOLUTION:
+ InsertSolutionTape();
+
+ break;
+
+ case TAPE_CTRL_ID_PLAY_SOLUTION:
+ PlaySolutionTape();
+
+ break;
+
default:
break;
}