#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 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.use_mouse = (level.game_engine_type == GAME_ENGINE_TYPE_MM);
}
-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)
{
- StartGameActions(options.network, TRUE, level.random_seed);
+ 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();
{
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;
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++)
tape.pos[tape.counter].action[i] = action[i];
byte action[MAX_PLAYERS];
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++)
}
}
-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);
}
}
- 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)
{
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);
}
}
-boolean 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 TRUE;
}
-boolean PlaySolutionTape()
+boolean PlaySolutionTape(void)
{
if (!InsertSolutionTape())
return FALSE;
}
-/* ------------------------------------------------------------------------- *
- * 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
}
-/* ---------- new tape button stuff ---------------------------------------- */
+// ---------- 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"
},
}
};
-void CreateTapeButtons()
+void CreateTapeButtons(void)
{
int i;
}
}
-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;
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;
projects / rocksndiamonds.git / blobdiff