added multi-part line debug logging functions
[rocksndiamonds.git] / src / tape.c
1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // tape.c
10 // ============================================================================
11
12 #include "libgame/libgame.h"
13
14 #include "tape.h"
15 #include "init.h"
16 #include "game.h"
17 #include "tools.h"
18 #include "files.h"
19 #include "network.h"
20 #include "anim.h"
21
22 #define DEBUG_TAPE_WHEN_PLAYING                 FALSE
23
24 // tape button identifiers
25 #define TAPE_CTRL_ID_EJECT                      0
26 #define TAPE_CTRL_ID_EXTRA                      1
27 #define TAPE_CTRL_ID_STOP                       2
28 #define TAPE_CTRL_ID_PAUSE                      3
29 #define TAPE_CTRL_ID_RECORD                     4
30 #define TAPE_CTRL_ID_PLAY                       5
31 #define TAPE_CTRL_ID_INSERT_SOLUTION            6
32 #define TAPE_CTRL_ID_PLAY_SOLUTION              7
33
34 #define NUM_TAPE_BUTTONS                        8
35
36 // values for tape handling
37 #define TAPE_PAUSE_SECONDS_BEFORE_DEATH         5
38 #define TAPE_MIN_SECONDS_FOR_UNDO_BUFFER        20
39
40 // forward declaration for internal use
41 static void HandleTapeButtons(struct GadgetInfo *);
42 static void TapeStopWarpForward(void);
43 static float GetTapeLengthSecondsFloat(void);
44 static void CopyTapeToUndoBuffer(void);
45
46 static struct GadgetInfo *tape_gadget[NUM_TAPE_BUTTONS];
47 static struct TapeInfo tape_undo_buffer;
48
49
50 // ============================================================================
51 // video tape definitions
52 // ============================================================================
53
54 #define VIDEO_INFO_OFF                  (VIDEO_STATE_DATE_OFF   |       \
55                                          VIDEO_STATE_TIME_OFF   |       \
56                                          VIDEO_STATE_FRAME_OFF)
57 #define VIDEO_STATE_OFF                 (VIDEO_STATE_PLAY_OFF   |       \
58                                          VIDEO_STATE_REC_OFF    |       \
59                                          VIDEO_STATE_PAUSE_OFF  |       \
60                                          VIDEO_STATE_FFWD_OFF   |       \
61                                          VIDEO_STATE_WARP_OFF   |       \
62                                          VIDEO_STATE_WARP2_OFF  |       \
63                                          VIDEO_STATE_PBEND_OFF  |       \
64                                          VIDEO_STATE_1STEP_OFF)
65 #define VIDEO_PRESS_OFF                 (VIDEO_PRESS_PLAY_OFF   |       \
66                                          VIDEO_PRESS_REC_OFF    |       \
67                                          VIDEO_PRESS_PAUSE_OFF  |       \
68                                          VIDEO_PRESS_STOP_OFF   |       \
69                                          VIDEO_PRESS_EJECT_OFF)
70 #define VIDEO_ALL_OFF                   (VIDEO_INFO_OFF         |       \
71                                          VIDEO_STATE_OFF        |       \
72                                          VIDEO_PRESS_OFF)
73
74 #define VIDEO_INFO_ON                   (VIDEO_STATE_DATE_ON    |       \
75                                          VIDEO_STATE_TIME_ON    |       \
76                                          VIDEO_STATE_FRAME_ON)
77 #define VIDEO_STATE_ON                  (VIDEO_STATE_PLAY_ON    |       \
78                                          VIDEO_STATE_REC_ON     |       \
79                                          VIDEO_STATE_PAUSE_ON   |       \
80                                          VIDEO_STATE_FFWD_ON    |       \
81                                          VIDEO_STATE_WARP_ON    |       \
82                                          VIDEO_STATE_WARP2_ON   |       \
83                                          VIDEO_STATE_PBEND_ON   |       \
84                                          VIDEO_STATE_1STEP_ON)
85 #define VIDEO_PRESS_ON                  (VIDEO_PRESS_PLAY_ON    |       \
86                                          VIDEO_PRESS_REC_ON     |       \
87                                          VIDEO_PRESS_PAUSE_ON   |       \
88                                          VIDEO_PRESS_STOP_ON    |       \
89                                          VIDEO_PRESS_EJECT_ON)
90 #define VIDEO_ALL_ON                    (VIDEO_INFO_ON          |       \
91                                          VIDEO_STATE_ON         |       \
92                                          VIDEO_PRESS_ON)
93
94 #define VIDEO_INFO                      (VIDEO_INFO_ON | VIDEO_INFO_OFF)
95 #define VIDEO_STATE                     (VIDEO_STATE_ON | VIDEO_STATE_OFF)
96 #define VIDEO_PRESS                     (VIDEO_PRESS_ON | VIDEO_PRESS_OFF)
97 #define VIDEO_ALL                       (VIDEO_ALL_ON | VIDEO_ALL_OFF)
98
99 #define NUM_TAPE_FUNCTIONS              11
100 #define NUM_TAPE_FUNCTION_PARTS         2
101 #define NUM_TAPE_FUNCTION_STATES        2
102
103
104 // ============================================================================
105 // video display functions
106 // ============================================================================
107
108 static void DrawVideoDisplay_Graphics(unsigned int state, unsigned int value)
109 {
110   int i, j, k;
111
112   static struct
113   {
114     int graphic;
115     struct XY *pos;
116   }
117   video_pos[NUM_TAPE_FUNCTIONS][NUM_TAPE_FUNCTION_PARTS] =
118   {
119     {
120       { IMG_GFX_TAPE_LABEL_PLAY,                &tape.label.play        },
121       { IMG_GFX_TAPE_SYMBOL_PLAY,               &tape.symbol.play       },
122     },
123     {
124       { IMG_GFX_TAPE_LABEL_RECORD,              &tape.label.record      },
125       { IMG_GFX_TAPE_SYMBOL_RECORD,             &tape.symbol.record     },
126     },
127     {
128       { IMG_GFX_TAPE_LABEL_PAUSE,               &tape.label.pause       },
129       { IMG_GFX_TAPE_SYMBOL_PAUSE,              &tape.symbol.pause      },
130     },
131     {
132       { IMG_GFX_TAPE_LABEL_DATE,                &tape.label.date        },
133       { -1,                                     NULL                    },
134     },
135     {
136       { IMG_GFX_TAPE_LABEL_TIME,                &tape.label.time        },
137       { -1,                                     NULL                    },
138     },
139     {
140       // (no label for displaying optional frame)
141       { -1,                                     NULL                    },
142       { -1,                                     NULL                    },
143     },
144     {
145       { IMG_GFX_TAPE_LABEL_FAST_FORWARD,        &tape.label.fast_forward  },
146       { IMG_GFX_TAPE_SYMBOL_FAST_FORWARD,       &tape.symbol.fast_forward },
147     },
148     {
149       { IMG_GFX_TAPE_LABEL_WARP_FORWARD,        &tape.label.warp_forward  },
150       { IMG_GFX_TAPE_SYMBOL_WARP_FORWARD,       &tape.symbol.warp_forward },
151     },
152     {
153       { IMG_GFX_TAPE_LABEL_WARP_FORWARD_BLIND,  &tape.label.warp_forward_blind},
154       { IMG_GFX_TAPE_SYMBOL_WARP_FORWARD_BLIND, &tape.symbol.warp_forward_blind},
155     },
156     {
157       { IMG_GFX_TAPE_LABEL_PAUSE_BEFORE_END,    &tape.label.pause_before_end  },
158       { IMG_GFX_TAPE_SYMBOL_PAUSE_BEFORE_END,   &tape.symbol.pause_before_end },
159     },
160     {
161       { IMG_GFX_TAPE_LABEL_SINGLE_STEP,         &tape.label.single_step  },
162       { IMG_GFX_TAPE_SYMBOL_SINGLE_STEP,        &tape.symbol.single_step },
163     },
164   };
165
166   for (k = 0; k < NUM_TAPE_FUNCTION_STATES; k++)        // on or off states
167   {
168     for (i = 0; i < NUM_TAPE_FUNCTIONS; i++)            // record, play, ...
169     {
170       for (j = 0; j < NUM_TAPE_FUNCTION_PARTS; j++)     // label or symbol
171       {
172         int graphic = video_pos[i][j].graphic;
173         struct XY *pos = video_pos[i][j].pos;
174
175         if (graphic == -1 ||
176             pos->x == -1 ||
177             pos->y == -1)
178           continue;
179
180         if (state & (1 << (i * 2 + k)))
181         {
182           struct GraphicInfo *gfx_bg = &graphic_info[IMG_BACKGROUND_TAPE];
183           struct GraphicInfo *gfx = &graphic_info[graphic];
184           Bitmap *gd_bitmap;
185           int gd_x, gd_y;
186           int skip_value =
187             (j == 0 ? VIDEO_DISPLAY_SYMBOL_ONLY : VIDEO_DISPLAY_LABEL_ONLY);
188
189           if (value == skip_value)
190             continue;
191
192           if (k == 1)           // on
193           {
194             gd_bitmap = gfx->bitmap;
195             gd_x = gfx->src_x;
196             gd_y = gfx->src_y;
197           }
198           else                  // off
199           {
200             gd_bitmap = gfx_bg->bitmap;
201             gd_x = gfx_bg->src_x + pos->x;
202             gd_y = gfx_bg->src_y + pos->y;
203           }
204
205           // some tape graphics may be undefined -- only draw if defined
206           if (gd_bitmap != NULL)
207             BlitBitmap(gd_bitmap, drawto, gd_x, gd_y, gfx->width, gfx->height,
208                        VX + pos->x, VY + pos->y);
209
210           redraw_mask |= REDRAW_DOOR_2;
211         }
212       }
213     }
214   }
215 }
216
217
218 #define DATETIME_NONE                   (0)
219
220 #define DATETIME_DATE_YYYY              (1 << 0)
221 #define DATETIME_DATE_YY                (1 << 1)
222 #define DATETIME_DATE_MON               (1 << 2)
223 #define DATETIME_DATE_MM                (1 << 3)
224 #define DATETIME_DATE_DD                (1 << 4)
225
226 #define DATETIME_TIME_HH                (1 << 5)
227 #define DATETIME_TIME_MIN               (1 << 6)
228 #define DATETIME_TIME_MM                (1 << 7)
229 #define DATETIME_TIME_SS                (1 << 8)
230
231 #define DATETIME_FRAME                  (1 << 9)
232
233 #define DATETIME_XOFFSET_1              (1 << 10)
234 #define DATETIME_XOFFSET_2              (1 << 11)
235
236 #define DATETIME_DATE                   (DATETIME_DATE_YYYY     |       \
237                                          DATETIME_DATE_YY       |       \
238                                          DATETIME_DATE_MON      |       \
239                                          DATETIME_DATE_MM       |       \
240                                          DATETIME_DATE_DD)
241
242 #define DATETIME_TIME                   (DATETIME_TIME_HH       |       \
243                                          DATETIME_TIME_MIN      |       \
244                                          DATETIME_TIME_MM       |       \
245                                          DATETIME_TIME_SS)
246
247 #define MAX_DATETIME_STRING_SIZE        32
248
249 static void DrawVideoDisplay_DateTime(unsigned int state, unsigned int value)
250 {
251   int i;
252
253   static char *month_shortnames[] =
254   {
255     "JAN",
256     "FEB",
257     "MAR",
258     "APR",
259     "MAY",
260     "JUN",
261     "JUL",
262     "AUG",
263     "SEP",
264     "OCT",
265     "NOV",
266     "DEC"
267   };
268
269   static struct
270   {
271     struct TextPosInfo *pos;
272     int type;
273   }
274   datetime_info[] =
275   {
276     { &tape.text.date,          DATETIME_DATE_DD                        },
277     { &tape.text.date,          DATETIME_DATE_MON | DATETIME_XOFFSET_1  },
278     { &tape.text.date,          DATETIME_DATE_YY  | DATETIME_XOFFSET_2  },
279     { &tape.text.date_yyyy,     DATETIME_DATE_YYYY                      },
280     { &tape.text.date_yy,       DATETIME_DATE_YY                        },
281     { &tape.text.date_mon,      DATETIME_DATE_MON                       },
282     { &tape.text.date_mm,       DATETIME_DATE_MM                        },
283     { &tape.text.date_dd,       DATETIME_DATE_DD                        },
284
285     { &tape.text.time,          DATETIME_TIME_MIN                       },
286     { &tape.text.time,          DATETIME_TIME_SS  | DATETIME_XOFFSET_1  },
287     { &tape.text.time_hh,       DATETIME_TIME_HH                        },
288     { &tape.text.time_mm,       DATETIME_TIME_MM                        },
289     { &tape.text.time_ss,       DATETIME_TIME_SS                        },
290
291     { &tape.text.frame,         DATETIME_FRAME                          },
292
293     { NULL,                     DATETIME_NONE                           },
294   };
295
296   for (i = 0; datetime_info[i].pos != NULL; i++)
297   {
298     struct TextPosInfo *pos = datetime_info[i].pos;
299     int type = datetime_info[i].type;
300     int xpos, ypos;
301
302     if (pos->x == -1 &&
303         pos->y == -1)
304       continue;
305
306     xpos = VX + pos->x + (type & DATETIME_XOFFSET_1 ? pos->xoffset  :
307                           type & DATETIME_XOFFSET_2 ? pos->xoffset2 : 0);
308     ypos = VY + pos->y;
309
310     if ((type & DATETIME_DATE) && (state & VIDEO_STATE_DATE_ON))
311     {
312       char s[MAX_DATETIME_STRING_SIZE];
313       int year2 = value / 10000;
314       int year4 = (year2 < 70 ? 2000 + year2 : 1900 + year2);
315       int month_index = (value / 100) % 100;
316       int month = month_index + 1;
317       int day = value % 100;
318
319       strcpy(s, (type & DATETIME_DATE_YYYY ? int2str(year4, 4) :
320                  type & DATETIME_DATE_YY   ? int2str(year2, 2) :
321                  type & DATETIME_DATE_MON  ? month_shortnames[month_index] :
322                  type & DATETIME_DATE_MM   ? int2str(month, 2) :
323                  type & DATETIME_DATE_DD   ? int2str(day, 2) : ""));
324
325       DrawText(xpos, ypos, s, pos->font);
326     }
327     else if ((type & DATETIME_TIME) && (state & VIDEO_STATE_TIME_ON))
328     {
329       char s[MAX_DATETIME_STRING_SIZE];
330       int hh = (value / 3600) % 100;
331       int min = value / 60;
332       int mm = (value / 60) % 60;
333       int ss = value % 60;
334
335       strcpy(s, (type & DATETIME_TIME_HH  ? int2str(hh, 2) :
336                  type & DATETIME_TIME_MIN ? int2str(min, 2) :
337                  type & DATETIME_TIME_MM  ? int2str(mm, 2) :
338                  type & DATETIME_TIME_SS  ? int2str(ss, 2) : ""));
339
340       DrawText(xpos, ypos, s, pos->font);
341     }
342     else if ((type & DATETIME_FRAME) && (state & VIDEO_STATE_FRAME_ON))
343     {
344       DrawText(xpos, ypos, int2str(value, pos->size), pos->font);
345     }
346   }
347 }
348
349 void DrawVideoDisplay(unsigned int state, unsigned int value)
350 {
351   DrawVideoDisplay_Graphics(state, value);
352   DrawVideoDisplay_DateTime(state, value);
353 }
354
355 static void DrawVideoDisplayLabel(unsigned int state)
356 {
357   DrawVideoDisplay(state, VIDEO_DISPLAY_LABEL_ONLY);
358 }
359
360 static void DrawVideoDisplaySymbol(unsigned int state)
361 {
362   DrawVideoDisplay(state, VIDEO_DISPLAY_SYMBOL_ONLY);
363 }
364
365 static void DrawVideoDisplayCurrentState(void)
366 {
367   int state = 0;
368
369   DrawVideoDisplay(VIDEO_STATE_OFF, 0);
370
371   if (tape.pausing)
372     state |= VIDEO_STATE_PAUSE_ON;
373
374   if (tape.recording)
375   {
376     state |= VIDEO_STATE_REC_ON;
377
378     if (tape.single_step)
379       state |= VIDEO_STATE_1STEP_ON;
380   }
381   else if (tape.playing)
382   {
383     state |= VIDEO_STATE_PLAY_ON;
384
385     if (!tape.pausing)
386     {
387       if (tape.deactivate_display)
388         state |= VIDEO_STATE_WARP2_ON;
389       else if (tape.warp_forward)
390         state |= VIDEO_STATE_WARP_ON;
391       else if (tape.fast_forward)
392         state |= VIDEO_STATE_FFWD_ON;
393
394       if (tape.pause_before_end)
395         state |= VIDEO_STATE_PBEND_ON;
396     }
397   }
398
399   // draw labels and symbols separately to prevent labels overlapping symbols
400   DrawVideoDisplayLabel(state);
401   DrawVideoDisplaySymbol(state);
402 }
403
404 void DrawCompleteVideoDisplay(void)
405 {
406   struct GraphicInfo *g_tape = &graphic_info[IMG_BACKGROUND_TAPE];
407
408   // draw tape background
409   BlitBitmap(g_tape->bitmap, drawto, g_tape->src_x, g_tape->src_y,
410              gfx.vxsize, gfx.vysize, gfx.vx, gfx.vy);
411
412   // draw tape buttons (forced)
413   RedrawOrRemapTapeButtons();
414
415   DrawVideoDisplay(VIDEO_ALL_OFF, 0);
416
417   if (tape.recording)
418   {
419     DrawVideoDisplay(VIDEO_STATE_REC_ON, 0);
420     DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
421     DrawVideoDisplay(VIDEO_STATE_TIME_ON, tape.length_seconds);
422     DrawVideoDisplay(VIDEO_STATE_FRAME_ON, tape.length_frames);
423
424     if (tape.pausing)
425       DrawVideoDisplay(VIDEO_STATE_PAUSE_ON, 0);
426   }
427   else if (tape.playing)
428   {
429     DrawVideoDisplay(VIDEO_STATE_PLAY_ON, 0);
430     DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
431     DrawVideoDisplay(VIDEO_STATE_TIME_ON, 0);
432     DrawVideoDisplay(VIDEO_STATE_FRAME_ON, 0);
433
434     if (tape.pausing)
435       DrawVideoDisplay(VIDEO_STATE_PAUSE_ON, 0);
436   }
437   else if (tape.date && tape.length)
438   {
439     DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
440     DrawVideoDisplay(VIDEO_STATE_TIME_ON, tape.length_seconds);
441     DrawVideoDisplay(VIDEO_STATE_FRAME_ON, tape.length_frames);
442   }
443
444   BlitBitmap(drawto, bitmap_db_door_2, gfx.vx, gfx.vy, gfx.vxsize, gfx.vysize,
445              0, 0);
446 }
447
448 void TapeDeactivateDisplayOn(void)
449 {
450   SetDrawDeactivationMask(REDRAW_FIELD);
451   audio.sound_deactivated = TRUE;
452 }
453
454 void TapeDeactivateDisplayOff(boolean redraw_display)
455 {
456   SetDrawDeactivationMask(REDRAW_NONE);
457   audio.sound_deactivated = FALSE;
458
459   if (redraw_display)
460   {
461     RedrawPlayfield();
462     DrawGameDoorValues();
463   }
464 }
465
466
467 // ============================================================================
468 // tape logging functions
469 // ============================================================================
470
471 static char tape_patch_info[MAX_OUTPUT_LINESIZE];
472
473 static void PrintTapeReplayProgress(boolean replay_finished)
474 {
475   static unsigned int counter_last = -1;
476   unsigned int counter = Counter();
477   unsigned int counter_seconds  = counter / 1000;
478
479   if (!replay_finished)
480   {
481     unsigned int counter_delay = 50;
482
483     if (counter > counter_last + counter_delay)
484     {
485       PrintNoLog("\r");
486       PrintNoLog("Tape %03d %s[%02d:%02d]: [%02d:%02d] - playing tape ... ",
487                  level_nr,  tape_patch_info,
488                  tape.length_seconds / 60, tape.length_seconds % 60,
489                  TapeTime / 60, TapeTime % 60);
490
491       counter_last = counter;
492     }
493   }
494   else
495   {
496     float tape_length_seconds = GetTapeLengthSecondsFloat();
497
498     PrintNoLog("\r");
499     Print("Tape %03d %s[%02d:%02d]: (%02d:%02d.%03d / %.2f %%) - %s.\n",
500           level_nr, tape_patch_info,
501           tape.length_seconds / 60, tape.length_seconds % 60,
502           counter_seconds / 60, counter_seconds % 60, counter % 1000,
503           (float)counter / tape_length_seconds / 10,
504           tape.auto_play_level_fixed ? "solved and fixed" :
505           tape.auto_play_level_solved ? "solved" :
506           tape.auto_play_level_not_fixable ? "NOT SOLVED, NOT FIXED" :
507           "NOT SOLVED");
508
509     counter_last = -1;
510   }
511 }
512
513
514 // ============================================================================
515 // tape control functions
516 // ============================================================================
517
518 void TapeSetDateFromEpochSeconds(time_t epoch_seconds)
519 {
520   struct tm *lt = localtime(&epoch_seconds);
521
522   tape.date = 10000 * (lt->tm_year % 100) + 100 * lt->tm_mon + lt->tm_mday;
523 }
524
525 void TapeSetDateFromNow(void)
526 {
527   TapeSetDateFromEpochSeconds(time(NULL));
528 }
529
530 void TapeErase(void)
531 {
532   int i;
533
534   CopyTapeToUndoBuffer();
535
536   tape.counter = 0;
537   tape.length = 0;
538   tape.length_frames = 0;
539   tape.length_seconds = 0;
540
541   if (leveldir_current)
542     setString(&tape.level_identifier, leveldir_current->identifier);
543
544   tape.level_nr = level_nr;
545   tape.pos[tape.counter].delay = 0;
546   tape.changed = TRUE;
547
548   tape.random_seed = InitRND(level.random_seed);
549
550   tape.file_version = FILE_VERSION_ACTUAL;
551   tape.game_version = GAME_VERSION_ACTUAL;
552   tape.engine_version = level.game_version;
553
554   TapeSetDateFromNow();
555
556   for (i = 0; i < MAX_PLAYERS; i++)
557     tape.player_participates[i] = FALSE;
558
559   tape.centered_player_nr_next = -1;
560   tape.set_centered_player = FALSE;
561
562   // set flags for game actions to default values (may be overwritten later)
563   tape.use_key_actions = TRUE;
564   tape.use_mouse_actions = FALSE;
565 }
566
567 static void TapeRewind(void)
568 {
569   tape.counter = 0;
570   tape.delay_played = 0;
571   tape.pause_before_end = FALSE;
572   tape.recording = FALSE;
573   tape.playing = FALSE;
574   tape.fast_forward = FALSE;
575   tape.warp_forward = FALSE;
576   tape.deactivate_display = FALSE;
577   tape.auto_play = (global.autoplay_leveldir != NULL);
578   tape.auto_play_level_solved = FALSE;
579   tape.auto_play_level_fixed = FALSE;
580   tape.auto_play_level_not_fixable = FALSE;
581   tape.quick_resume = FALSE;
582   tape.single_step = FALSE;
583
584   tape.centered_player_nr_next = -1;
585   tape.set_centered_player = FALSE;
586
587   InitRND(tape.random_seed);
588 }
589
590 static void TapeSetRandomSeed(int random_seed)
591 {
592   tape.random_seed = InitRND(random_seed);
593 }
594
595 void TapeStartRecording(int random_seed)
596 {
597   if (!TAPE_IS_STOPPED(tape))
598     TapeStop();
599
600   TapeErase();
601   TapeRewind();
602   TapeSetRandomSeed(random_seed);
603
604   tape.recording = TRUE;
605
606   DrawVideoDisplay(VIDEO_STATE_REC_ON, 0);
607   DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
608   DrawVideoDisplay(VIDEO_STATE_TIME_ON, 0);
609   DrawVideoDisplay(VIDEO_STATE_FRAME_ON, 0);
610
611   MapTapeWarpButton();
612
613   SetDrawDeactivationMask(REDRAW_NONE);
614   audio.sound_deactivated = FALSE;
615
616   // required here to update video display if tape door is closed
617   if (GetDoorState() & DOOR_CLOSE_2)
618     OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
619 }
620
621 static void TapeStartGameRecording(void)
622 {
623   StartGameActions(network.enabled, TRUE, level.random_seed);
624 }
625
626 static void TapeAppendRecording(void)
627 {
628   if (!tape.playing || !tape.pausing)
629     return;
630
631   // stop playing
632   tape.playing = FALSE;
633   tape.fast_forward = FALSE;
634   tape.warp_forward = FALSE;
635   tape.pause_before_end = FALSE;
636   tape.deactivate_display = FALSE;
637
638   // start recording
639   tape.recording = TRUE;
640   tape.changed = TRUE;
641
642   // set current delay (for last played move)
643   tape.pos[tape.counter].delay = tape.delay_played;
644
645   // set current date
646   TapeSetDateFromNow();
647
648   DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
649   DrawVideoDisplay(VIDEO_STATE_PLAY_OFF | VIDEO_STATE_REC_ON, 0);
650
651   UpdateAndDisplayGameControlValues();
652 }
653
654 void TapeHaltRecording(void)
655 {
656   tape.counter++;
657
658   // initialize delay for next tape entry (to be able to continue recording)
659   if (tape.counter < MAX_TAPE_LEN)
660     tape.pos[tape.counter].delay = 0;
661
662   tape.length = tape.counter;
663   tape.length_frames = GetTapeLengthFrames();
664   tape.length_seconds = GetTapeLengthSeconds();
665 }
666
667 void TapeStopRecording(void)
668 {
669   if (tape.recording)
670     TapeHaltRecording();
671
672   tape.recording = FALSE;
673   tape.pausing = FALSE;
674
675   DrawVideoDisplay(VIDEO_STATE_REC_OFF, 0);
676   MapTapeEjectButton();
677 }
678
679 boolean TapeAddAction(byte action[MAX_TAPE_ACTIONS])
680 {
681   int i;
682
683   if (tape.pos[tape.counter].delay > 0)         // already stored action
684   {
685     boolean changed_events = FALSE;
686
687     for (i = 0; i < MAX_TAPE_ACTIONS; i++)
688       if (tape.pos[tape.counter].action[i] != action[i])
689         changed_events = TRUE;
690
691     if (changed_events || tape.pos[tape.counter].delay >= 255)
692     {
693       if (tape.counter >= MAX_TAPE_LEN - 1)
694         return FALSE;
695
696       tape.counter++;
697       tape.pos[tape.counter].delay = 0;
698     }
699     else
700       tape.pos[tape.counter].delay++;
701   }
702
703   if (tape.pos[tape.counter].delay == 0)        // store new action
704   {
705     for (i = 0; i < MAX_TAPE_ACTIONS; i++)
706       tape.pos[tape.counter].action[i] = action[i];
707
708     tape.pos[tape.counter].delay++;
709   }
710
711   return TRUE;
712 }
713
714 void TapeRecordAction(byte action_raw[MAX_TAPE_ACTIONS])
715 {
716   byte action[MAX_TAPE_ACTIONS];
717   int i;
718
719   if (!tape.recording)          // (record action even when tape is paused)
720     return;
721
722   for (i = 0; i < MAX_TAPE_ACTIONS; i++)
723     action[i] = action_raw[i];
724
725   if (tape.use_key_actions && tape.set_centered_player)
726   {
727     for (i = 0; i < MAX_PLAYERS; i++)
728       if (tape.centered_player_nr_next == i ||
729           tape.centered_player_nr_next == -1)
730         action[i] |= KEY_SET_FOCUS;
731
732     tape.set_centered_player = FALSE;
733   }
734
735   if (!TapeAddAction(action))
736     TapeStopRecording();
737 }
738
739 void TapeTogglePause(boolean toggle_mode)
740 {
741   if (tape.playing && tape.pausing && (toggle_mode & TAPE_TOGGLE_PLAY_PAUSE))
742   {
743     // continue playing in normal mode
744     tape.fast_forward = FALSE;
745     tape.warp_forward = FALSE;
746     tape.deactivate_display = FALSE;
747
748     tape.pause_before_end = FALSE;
749   }
750
751   tape.pausing = !tape.pausing;
752
753   if (tape.single_step && (toggle_mode & TAPE_TOGGLE_MANUAL))
754     tape.single_step = FALSE;
755
756   DrawVideoDisplayCurrentState();
757
758   if (tape.deactivate_display)
759   {
760     if (tape.pausing)
761       TapeDeactivateDisplayOff(game_status == GAME_MODE_PLAYING);
762     else
763       TapeDeactivateDisplayOn();
764   }
765
766   if (tape.quick_resume)
767   {
768     tape.quick_resume = FALSE;
769
770     TapeStopWarpForward();
771     TapeAppendRecording();
772
773     if (!CheckEngineSnapshotSingle())
774       SaveEngineSnapshotSingle();
775
776     // restart step/move snapshots after quick loading tape
777     SaveEngineSnapshotToListInitial();
778
779     // do not map undo/redo buttons after quick loading tape
780     return;
781   }
782
783   if (game_status == GAME_MODE_PLAYING)
784   {
785     if (setup.show_snapshot_buttons && CheckEngineSnapshotList())
786     {
787       if (tape.pausing)
788         MapUndoRedoButtons();
789       else if (!tape.single_step)
790         UnmapUndoRedoButtons();
791     }
792
793     ModifyPauseButtons();
794   }
795 }
796
797 void TapeStartPlaying(void)
798 {
799   if (TAPE_IS_EMPTY(tape))
800     return;
801
802   if (!TAPE_IS_STOPPED(tape))
803     TapeStop();
804
805   TapeRewind();
806
807   tape.playing = TRUE;
808
809   DrawVideoDisplay(VIDEO_STATE_PLAY_ON, 0);
810   DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
811   DrawVideoDisplay(VIDEO_STATE_TIME_ON, 0);
812   DrawVideoDisplay(VIDEO_STATE_FRAME_ON, 0);
813
814   MapTapeWarpButton();
815
816   SetDrawDeactivationMask(REDRAW_NONE);
817   audio.sound_deactivated = FALSE;
818 }
819
820 static void TapeStartGamePlaying(void)
821 {
822   TapeStartPlaying();
823
824   InitGame();
825 }
826
827 void TapeStopPlaying(void)
828 {
829   tape.playing = FALSE;
830   tape.pausing = FALSE;
831
832   if (tape.warp_forward)
833     TapeStopWarpForward();
834
835   DrawVideoDisplay(VIDEO_STATE_PLAY_OFF, 0);
836   MapTapeEjectButton();
837 }
838
839 byte *TapePlayAction(void)
840 {
841   int update_delay = FRAMES_PER_SECOND / 2;
842   boolean update_video_display = (FrameCounter % update_delay == 0);
843   boolean update_draw_label_on = ((FrameCounter / update_delay) % 2 == 1);
844   static byte action[MAX_TAPE_ACTIONS];
845   int i;
846
847   if (!tape.playing || tape.pausing)
848     return NULL;
849
850   if (tape.pause_before_end)  // stop some seconds before end of tape
851   {
852     if (TapeTime > tape.length_seconds - TAPE_PAUSE_SECONDS_BEFORE_DEATH)
853     {
854       TapeStopWarpForward();
855       TapeTogglePause(TAPE_TOGGLE_MANUAL);
856
857       return NULL;
858     }
859   }
860
861   if (tape.counter >= tape.length)      // end of tape reached
862   {
863     if (tape.warp_forward && !tape.auto_play)
864     {
865       TapeStopWarpForward();
866       TapeTogglePause(TAPE_TOGGLE_MANUAL);
867     }
868     else
869     {
870       TapeStop();
871     }
872
873     return NULL;
874   }
875
876   if (update_video_display && !tape.deactivate_display)
877   {
878     int state = 0;
879
880     if (tape.warp_forward)
881       state |= VIDEO_STATE_WARP(update_draw_label_on);
882     else if (tape.fast_forward)
883       state |= VIDEO_STATE_FFWD(update_draw_label_on);
884
885     if (tape.pause_before_end)
886       state |= VIDEO_STATE_PBEND(update_draw_label_on);
887
888     // draw labels and symbols separately to prevent labels overlapping symbols
889     DrawVideoDisplayLabel(state);
890     DrawVideoDisplaySymbol(state);
891   }
892
893   for (i = 0; i < MAX_TAPE_ACTIONS; i++)
894     action[i] = tape.pos[tape.counter].action[i];
895
896 #if DEBUG_TAPE_WHEN_PLAYING
897   DebugContinued("", "%05d", FrameCounter);
898   for (i = 0; i < MAX_TAPE_ACTIONS; i++)
899     DebugContinued("", "   %08x", action[i]);
900   DebugContinued("tape:play", "\n");
901 #endif
902
903   tape.set_centered_player = FALSE;
904   tape.centered_player_nr_next = -999;
905
906   if (tape.use_key_actions)
907   {
908     for (i = 0; i < MAX_PLAYERS; i++)
909     {
910       if (action[i] & KEY_SET_FOCUS)
911       {
912         tape.set_centered_player = TRUE;
913         tape.centered_player_nr_next =
914           (tape.centered_player_nr_next == -999 ? i : -1);
915       }
916
917       action[i] &= ~KEY_SET_FOCUS;
918     }
919   }
920
921   tape.delay_played++;
922   if (tape.delay_played >= tape.pos[tape.counter].delay)
923   {
924     tape.counter++;
925     tape.delay_played = 0;
926   }
927
928   if (tape.auto_play)
929     PrintTapeReplayProgress(FALSE);
930
931   return action;
932 }
933
934 void TapeStop(void)
935 {
936   if (tape.pausing)
937     TapeTogglePause(TAPE_TOGGLE_MANUAL);
938
939   TapeStopRecording();
940   TapeStopPlaying();
941
942   DrawVideoDisplay(VIDEO_STATE_OFF, 0);
943
944   if (tape.date && tape.length)
945   {
946     DrawVideoDisplay(VIDEO_STATE_DATE_ON, tape.date);
947     DrawVideoDisplay(VIDEO_STATE_TIME_ON, tape.length_seconds);
948     DrawVideoDisplay(VIDEO_STATE_FRAME_ON, tape.length_frames);
949   }
950 }
951
952 unsigned int GetTapeLengthFrames(void)
953 {
954   unsigned int tape_length_frames = 0;
955   int i;
956
957   if (TAPE_IS_EMPTY(tape))
958     return(0);
959
960   for (i = 0; i < tape.length; i++)
961     tape_length_frames += tape.pos[i].delay;
962
963   return tape_length_frames;
964 }
965
966 unsigned int GetTapeLengthSeconds(void)
967 {
968   return (GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
969 }
970
971 static float GetTapeLengthSecondsFloat(void)
972 {
973   return ((float)GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
974 }
975
976 static void TapeStartWarpForward(int mode)
977 {
978   tape.fast_forward = (mode & AUTOPLAY_FFWD);
979   tape.warp_forward = (mode & AUTOPLAY_WARP);
980   tape.deactivate_display = (mode & AUTOPLAY_WARP_NO_DISPLAY);
981
982   tape.pausing = FALSE;
983
984   if (tape.deactivate_display)
985     TapeDeactivateDisplayOn();
986
987   DrawVideoDisplayCurrentState();
988 }
989
990 static void TapeStopWarpForward(void)
991 {
992   tape.fast_forward = FALSE;
993   tape.warp_forward = FALSE;
994   tape.deactivate_display = FALSE;
995
996   tape.pause_before_end = FALSE;
997
998   TapeDeactivateDisplayOff(game_status == GAME_MODE_PLAYING);
999
1000   DrawVideoDisplayCurrentState();
1001 }
1002
1003 static void TapeSingleStep(void)
1004 {
1005   if (network.enabled)
1006     return;
1007
1008   if (!tape.pausing)
1009     TapeTogglePause(TAPE_TOGGLE_MANUAL);
1010
1011   tape.single_step = !tape.single_step;
1012
1013   DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
1014 }
1015
1016 void TapeQuickSave(void)
1017 {
1018   if (game_status == GAME_MODE_MAIN)
1019   {
1020     Request("No game that can be saved!", REQ_CONFIRM);
1021
1022     return;
1023   }
1024
1025   if (game_status != GAME_MODE_PLAYING)
1026     return;
1027
1028   if (tape.recording)
1029     TapeHaltRecording();        // prepare tape for saving on-the-fly
1030
1031   if (TAPE_IS_EMPTY(tape))
1032   {
1033     Request("No tape that can be saved!", REQ_CONFIRM);
1034
1035     return;
1036   }
1037
1038   if (SaveTapeChecked(tape.level_nr))
1039     SaveEngineSnapshotSingle();
1040 }
1041
1042 void TapeQuickLoad(void)
1043 {
1044   char *filename = getTapeFilename(level_nr);
1045
1046   if (!fileExists(filename))
1047   {
1048     Request("No tape for this level!", REQ_CONFIRM);
1049
1050     return;
1051   }
1052
1053   if (tape.recording && !Request("Stop recording and load tape?",
1054                                  REQ_ASK | REQ_STAY_CLOSED))
1055   {
1056     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
1057
1058     return;
1059   }
1060
1061   if (game_status != GAME_MODE_PLAYING && game_status != GAME_MODE_MAIN)
1062     return;
1063
1064   if (CheckEngineSnapshotSingle())
1065   {
1066     TapeStartGamePlaying();
1067
1068     LoadEngineSnapshotSingle();
1069
1070     DrawCompleteVideoDisplay();
1071
1072     tape.playing = TRUE;
1073     tape.pausing = TRUE;
1074
1075     TapeStopWarpForward();
1076     TapeAppendRecording();
1077
1078     // restart step/move snapshots after quick loading tape
1079     SaveEngineSnapshotToListInitial();
1080
1081     if (FrameCounter > 0)
1082       return;
1083   }
1084
1085   TapeStop();
1086   TapeErase();
1087
1088   LoadTape(level_nr);
1089
1090   if (!TAPE_IS_EMPTY(tape))
1091   {
1092     TapeStartGamePlaying();
1093     TapeStartWarpForward(AUTOPLAY_MODE_WARP_NO_DISPLAY);
1094
1095     tape.quick_resume = TRUE;
1096   }
1097   else  // this should not happen (basically checked above)
1098   {
1099     int reopen_door = (game_status == GAME_MODE_PLAYING ? REQ_REOPEN : 0);
1100
1101     Request("No tape for this level!", REQ_CONFIRM | reopen_door);
1102   }
1103 }
1104
1105 boolean hasSolutionTape(void)
1106 {
1107   boolean tape_file_exists = fileExists(getSolutionTapeFilename(level_nr));
1108   boolean level_has_tape = (level.game_engine_type == GAME_ENGINE_TYPE_SP &&
1109                             level.native_sp_level->demo.is_available);
1110
1111   return (tape_file_exists || level_has_tape);
1112 }
1113
1114 boolean InsertSolutionTape(void)
1115 {
1116   if (!hasSolutionTape())
1117   {
1118     Request("No solution tape for this level!", REQ_CONFIRM);
1119
1120     return FALSE;
1121   }
1122
1123   if (!TAPE_IS_STOPPED(tape))
1124     TapeStop();
1125
1126   // if tape recorder already contains a tape, remove it without asking
1127   TapeErase();
1128
1129   LoadSolutionTape(level_nr);
1130
1131   DrawCompleteVideoDisplay();
1132
1133   if (TAPE_IS_EMPTY(tape))
1134   {
1135     Request("Loading solution tape for this level failed!", REQ_CONFIRM);
1136
1137     return FALSE;
1138   }
1139
1140   return TRUE;
1141 }
1142
1143 boolean PlaySolutionTape(void)
1144 {
1145   if (!InsertSolutionTape())
1146     return FALSE;
1147
1148   TapeStartGamePlaying();
1149
1150   return TRUE;
1151 }
1152
1153 static boolean checkTapesFromSameLevel(struct TapeInfo *t1, struct TapeInfo *t2)
1154 {
1155   return (strEqual(t1->level_identifier, t2->level_identifier) &&
1156           t1->level_nr == t2->level_nr);
1157 }
1158
1159 static void CopyTape(struct TapeInfo *tape_from, struct TapeInfo *tape_to)
1160 {
1161   if (tape_to->level_identifier != NULL)
1162     checked_free(tape_to->level_identifier);
1163
1164   *tape_to = *tape_from;
1165
1166   tape_to->level_identifier = getStringCopy(tape_from->level_identifier);
1167 }
1168
1169 static void SwapTapes(struct TapeInfo *t1, struct TapeInfo *t2)
1170 {
1171   struct TapeInfo tmp = *t1;
1172
1173   *t1 = *t2;
1174   *t2 = tmp;
1175 }
1176
1177 static void CopyTapeToUndoBuffer(void)
1178 {
1179   // copy tapes to undo buffer if large enough (or larger than last undo tape)
1180   // or if the last undo tape is from a different level set or level number
1181   if (tape.length_seconds >= TAPE_MIN_SECONDS_FOR_UNDO_BUFFER ||
1182       tape.length_seconds >= tape_undo_buffer.length_seconds ||
1183       !checkTapesFromSameLevel(&tape, &tape_undo_buffer))
1184   {
1185     CopyTape(&tape, &tape_undo_buffer);
1186   }
1187 }
1188
1189 void UndoTape(void)
1190 {
1191   // only undo tapes from same level set and with same level number
1192   if (!checkTapesFromSameLevel(&tape, &tape_undo_buffer))
1193     return;
1194
1195   if (!TAPE_IS_STOPPED(tape))
1196     TapeStop();
1197
1198   // swap last recorded tape with undo buffer, so undo can be reversed
1199   SwapTapes(&tape, &tape_undo_buffer);
1200
1201   DrawCompleteVideoDisplay();
1202 }
1203
1204 void FixTape_ForceSinglePlayer(void)
1205 {
1206   int i;
1207
1208   /* fix single-player tapes that contain player input for more than one
1209      player (due to a bug in 3.3.1.2 and earlier versions), which results
1210      in playing levels with more than one player in multi-player mode,
1211      even though the tape was originally recorded in single-player mode */
1212
1213   // remove player input actions for all players but the first one
1214   for (i = 1; i < MAX_PLAYERS; i++)
1215     tape.player_participates[i] = FALSE;
1216
1217   tape.changed = TRUE;
1218 }
1219
1220
1221 // ----------------------------------------------------------------------------
1222 // tape autoplay functions
1223 // ----------------------------------------------------------------------------
1224
1225 void AutoPlayTapes(void)
1226 {
1227   static LevelDirTree *autoplay_leveldir = NULL;
1228   static boolean autoplay_initialized = FALSE;
1229   static int autoplay_level_nr = -1;
1230   static int num_levels_played = 0;
1231   static int num_levels_solved = 0;
1232   static int num_tapes_patched = 0;
1233   static int num_tape_missing = 0;
1234   static boolean level_failed[MAX_TAPES_PER_SET];
1235   static int patch_nr = 0;
1236   static char *patch_name[] =
1237   {
1238     "original tape",
1239     "em_random_bug",
1240
1241     NULL
1242   };
1243   static int patch_version_first[] =
1244   {
1245     VERSION_IDENT(0,0,0,0),
1246     VERSION_IDENT(3,3,1,0),
1247
1248     -1
1249   };
1250   static int patch_version_last[] =
1251   {
1252     VERSION_IDENT(9,9,9,9),
1253     VERSION_IDENT(4,0,1,1),
1254
1255     -1
1256   };
1257   static byte patch_property_bit[] =
1258   {
1259     TAPE_PROPERTY_NONE,
1260     TAPE_PROPERTY_EM_RANDOM_BUG,
1261
1262     -1
1263   };
1264   int i;
1265
1266   if (autoplay_initialized)
1267   {
1268     if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1269     {
1270       if (tape.auto_play_level_solved)
1271       {
1272         if (patch_nr > 0)
1273         {
1274           // level solved by patched tape -- save fixed tape
1275           char *filename = getTapeFilename(level_nr);
1276           char *filename_orig = getStringCat2(filename, ".orig");
1277
1278           // create backup from old tape, if not yet existing
1279           if (!fileExists(filename_orig))
1280             rename(filename, filename_orig);
1281
1282           SaveTapeToFilename(filename);
1283
1284           tape.auto_play_level_fixed = TRUE;
1285           num_tapes_patched++;
1286         }
1287
1288         // continue with next tape
1289         patch_nr = 0;
1290       }
1291       else if (patch_name[patch_nr + 1] != NULL)
1292       {
1293         // level not solved by patched tape -- continue with next patch
1294         patch_nr++;
1295       }
1296       else
1297       {
1298         // level not solved by any patched tape -- continue with next tape
1299         tape.auto_play_level_not_fixable = TRUE;
1300         patch_nr = 0;
1301       }
1302     }
1303
1304     // just finished auto-playing tape
1305     PrintTapeReplayProgress(TRUE);
1306
1307     if (patch_nr == 0)
1308       num_levels_played++;
1309
1310     if (tape.auto_play_level_solved)
1311       num_levels_solved++;
1312
1313     if (level_nr >= 0 && level_nr < MAX_TAPES_PER_SET)
1314       level_failed[level_nr] = !tape.auto_play_level_solved;
1315   }
1316   else
1317   {
1318     DrawCompleteVideoDisplay();
1319
1320     audio.sound_enabled = FALSE;
1321     setup.engine_snapshot_mode = getStringCopy(STR_SNAPSHOT_MODE_OFF);
1322
1323     autoplay_leveldir = getTreeInfoFromIdentifier(leveldir_first,
1324                                                   global.autoplay_leveldir);
1325
1326     if (autoplay_leveldir == NULL)
1327       Fail("no such level identifier: '%s'", global.autoplay_leveldir);
1328
1329     leveldir_current = autoplay_leveldir;
1330
1331     if (autoplay_leveldir->first_level < 0)
1332       autoplay_leveldir->first_level = 0;
1333     if (autoplay_leveldir->last_level >= MAX_TAPES_PER_SET)
1334       autoplay_leveldir->last_level = MAX_TAPES_PER_SET - 1;
1335
1336     autoplay_level_nr = autoplay_leveldir->first_level;
1337
1338     PrintLine("=", 79);
1339     if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1340       Print("Automatically fixing level tapes\n");
1341     else
1342       Print("Automatically playing level tapes\n");
1343     PrintLine("-", 79);
1344     Print("Level series identifier: '%s'\n", autoplay_leveldir->identifier);
1345     Print("Level series name:       '%s'\n", autoplay_leveldir->name);
1346     Print("Level series author:     '%s'\n", autoplay_leveldir->author);
1347     Print("Number of levels:        %d\n",   autoplay_leveldir->levels);
1348     PrintLine("=", 79);
1349     Print("\n");
1350
1351     for (i = 0; i < MAX_TAPES_PER_SET; i++)
1352       level_failed[i] = FALSE;
1353
1354     // only private tapes may be modified
1355     if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1356       options.mytapes = TRUE;
1357
1358     autoplay_initialized = TRUE;
1359   }
1360
1361   while (1)
1362   {
1363     if (global.autoplay_mode != AUTOPLAY_MODE_FIX || patch_nr == 0)
1364       level_nr = autoplay_level_nr++;
1365
1366     if (level_nr > autoplay_leveldir->last_level)
1367       break;
1368
1369     // set patch info (required for progress output)
1370     strcpy(tape_patch_info, "");
1371     if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1372       snprintf(tape_patch_info, MAX_OUTPUT_LINESIZE, "[%-13s] ",
1373                patch_name[patch_nr]);
1374
1375     if (!global.autoplay_all && !global.autoplay_level[level_nr])
1376       continue;
1377
1378     TapeErase();
1379
1380     LoadLevel(level_nr);
1381
1382     if (level.no_level_file || level.no_valid_file)
1383     {
1384       Print("Tape %03d: (no level found)\n", level_nr);
1385
1386       continue;
1387     }
1388
1389 #if 0
1390     // ACTIVATE THIS FOR LOADING/TESTING OF LEVELS ONLY
1391     Print("Tape %03d: (only testing level)\n", level_nr);
1392     continue;
1393 #endif
1394
1395     if (options.mytapes)
1396       LoadTape(level_nr);
1397     else
1398       LoadSolutionTape(level_nr);
1399
1400     if (tape.no_valid_file)
1401     {
1402       num_tape_missing++;
1403
1404       Print("Tape %03d: (no tape found)\n", level_nr);
1405
1406       continue;
1407     }
1408
1409     if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1410     {
1411       if (tape.engine_version < patch_version_first[patch_nr] ||
1412           tape.engine_version > patch_version_last[patch_nr])
1413       {
1414         Print("Tape %03d %s[%02d:%02d]: (%s %d.%d.%d.%d) - skipped.\n",
1415               level_nr,  tape_patch_info,
1416               tape.length_seconds / 60, tape.length_seconds % 60,
1417               "not suitable for version",
1418               (tape.engine_version / 1000000) % 100,
1419               (tape.engine_version / 10000  ) % 100,
1420               (tape.engine_version / 100    ) % 100,
1421               (tape.engine_version          ) % 100);
1422
1423         if (patch_name[patch_nr + 1] != NULL)
1424         {
1425           // continue with next patch
1426           patch_nr++;
1427         }
1428         else
1429         {
1430           // continue with next tape
1431           patch_nr = 0;
1432         }
1433
1434         continue;
1435       }
1436
1437       tape.property_bits |= patch_property_bit[patch_nr];
1438     }
1439
1440     InitCounter();
1441
1442     TapeStartGamePlaying();
1443     TapeStartWarpForward(global.autoplay_mode);
1444
1445     return;
1446   }
1447
1448   Print("\n");
1449   PrintLine("=", 79);
1450   Print("Number of levels played: %d\n", num_levels_played);
1451   Print("Number of levels solved: %d (%d%%)\n", num_levels_solved,
1452         (num_levels_played ? num_levels_solved * 100 / num_levels_played : 0));
1453   if (global.autoplay_mode == AUTOPLAY_MODE_FIX)
1454     Print("Number of tapes fixed: %d\n", num_tapes_patched);
1455   PrintLine("-", 79);
1456   Print("Summary (for automatic parsing by scripts):\n");
1457   Print("LEVELDIR [%s] '%s', SOLVED %d/%d (%d%%)",
1458         (num_levels_played == num_levels_solved ? " OK " : "WARN"),
1459         autoplay_leveldir->identifier, num_levels_solved, num_levels_played,
1460         (num_levels_played ? num_levels_solved * 100 / num_levels_played : 0));
1461
1462   if (num_levels_played != num_levels_solved)
1463   {
1464     Print(", FAILED:");
1465     for (i = 0; i < MAX_TAPES_PER_SET; i++)
1466       if (level_failed[i])
1467         Print(" %03d", i);
1468   }
1469
1470   Print("\n");
1471   PrintLine("=", 79);
1472
1473   CloseAllAndExit(0);
1474 }
1475
1476
1477 // ----------------------------------------------------------------------------
1478 // tape patch functions
1479 // ----------------------------------------------------------------------------
1480
1481 static boolean PatchTape(struct TapeInfo *tape, char *mode)
1482 {
1483   Print("[%d.%d.%d.%d]: ",
1484         (tape->engine_version / 1000000) % 100,
1485         (tape->engine_version / 10000  ) % 100,
1486         (tape->engine_version / 100    ) % 100,
1487         (tape->engine_version          ) % 100);
1488
1489   if (strEqual(mode, "info"))
1490   {
1491     Print("property bits == 0x%02x\n", tape->property_bits);
1492
1493     return FALSE;
1494   }
1495
1496   byte property_bits = tape->property_bits;
1497   byte property_bitmask = 0;
1498   boolean set_property_bit = TRUE;
1499
1500   if (strSuffix(mode, ":0") ||
1501       strSuffix(mode, ":off") ||
1502       strSuffix(mode, ":clear"))
1503     set_property_bit = FALSE;
1504
1505   if (strEqual(mode, "em_random_bug") || strPrefix(mode, "em_random_bug:"))
1506   {
1507     // this bug was introduced in version 3.3.1.0 and fixed in version 4.0.1.2
1508     if (tape->engine_version <  VERSION_IDENT(3,3,1,0) ||
1509         tape->engine_version >= VERSION_IDENT(4,0,1,2))
1510     {
1511       Print("This tape version cannot be patched against EM random bug!\n");
1512
1513       return FALSE;
1514     }
1515
1516     property_bitmask = TAPE_PROPERTY_EM_RANDOM_BUG;
1517   }
1518   else
1519   {
1520     Print("Unknown patch mode '%s'!\n", mode);
1521
1522     return FALSE;
1523   }
1524
1525   if (set_property_bit)
1526     property_bits |= property_bitmask;
1527   else
1528     property_bits &= ~property_bitmask;
1529
1530   if (property_bits == tape->property_bits)
1531   {
1532     Print("Tape already patched for '%s'!\n", mode);
1533
1534     return FALSE;
1535   }
1536
1537   Print("Patching for '%s' ... ", mode);
1538
1539   tape->property_bits = property_bits;
1540
1541   return TRUE;
1542 }
1543
1544 void PatchTapes(void)
1545 {
1546   static LevelDirTree *patchtapes_leveldir = NULL;
1547   static int num_tapes_found = 0;
1548   static int num_tapes_patched = 0;
1549   char *mode = global.patchtapes_mode;
1550   int i;
1551
1552   if (strEqual(mode, "help"))
1553   {
1554     PrintLine("=", 79);
1555     Print("Supported patch modes:\n");
1556     Print("- \"em_random_bug\"   - use 64-bit random value bug for EM engine\n");
1557     PrintLine("-", 79);
1558     Print("Supported modifiers:\n");
1559     Print("- add \":0\", \":off\" or \":clear\" to patch mode to un-patch tape file\n");
1560     PrintLine("=", 79);
1561
1562     CloseAllAndExit(0);
1563   }
1564
1565   patchtapes_leveldir = getTreeInfoFromIdentifier(leveldir_first,
1566                                                   global.patchtapes_leveldir);
1567
1568   if (patchtapes_leveldir == NULL)
1569     Fail("no such level identifier: '%s'", global.patchtapes_leveldir);
1570
1571   leveldir_current = patchtapes_leveldir;
1572
1573   if (patchtapes_leveldir->first_level < 0)
1574     patchtapes_leveldir->first_level = 0;
1575   if (patchtapes_leveldir->last_level >= MAX_TAPES_PER_SET)
1576     patchtapes_leveldir->last_level = MAX_TAPES_PER_SET - 1;
1577
1578   PrintLine("=", 79);
1579   Print("Patching level tapes for patch mode '%s'\n", mode);
1580   PrintLine("-", 79);
1581   Print("Level series identifier: '%s'\n", patchtapes_leveldir->identifier);
1582   Print("Level series name:       '%s'\n", patchtapes_leveldir->name);
1583   Print("Level series author:     '%s'\n", patchtapes_leveldir->author);
1584   Print("Number of levels:        %d\n",   patchtapes_leveldir->levels);
1585   PrintLine("=", 79);
1586   Print("\n");
1587
1588   int first_level = patchtapes_leveldir->first_level;
1589   int last_level = patchtapes_leveldir->last_level;
1590
1591   for (i = first_level; i <= last_level; i++)
1592   {
1593     if (!global.patchtapes_all && !global.patchtapes_level[i])
1594       continue;
1595
1596     Print("Tape %03d: ", i);
1597
1598     TapeErase();
1599     LoadTape(i);
1600
1601     if (tape.no_valid_file)
1602     {
1603       Print("(no tape found)\n");
1604
1605       continue;
1606     }
1607
1608     num_tapes_found++;
1609
1610     if (PatchTape(&tape, mode))
1611     {
1612       char *filename = getTapeFilename(i);
1613       char *filename_orig = getStringCat2(filename, ".orig");
1614
1615       if (!fileExists(filename_orig))
1616         rename(filename, filename_orig);
1617
1618       SaveTapeToFilename(filename);
1619
1620       Print("patched tape saved.\n");
1621
1622       num_tapes_patched++;
1623     }
1624   }
1625
1626   Print("\n");
1627   PrintLine("=", 79);
1628   Print("Number of tapes found: %d\n", num_tapes_found);
1629   Print("Number of tapes patched: %d\n", num_tapes_patched);
1630   PrintLine("=", 79);
1631
1632   CloseAllAndExit(0);
1633 }
1634
1635
1636 // ---------- new tape button stuff -------------------------------------------
1637
1638 static struct
1639 {
1640   int graphic;
1641   struct XY *pos;
1642   int gadget_id;
1643   char *infotext;
1644 } tapebutton_info[NUM_TAPE_BUTTONS] =
1645 {
1646   {
1647     IMG_GFX_TAPE_BUTTON_EJECT,          &tape.button.eject,
1648     TAPE_CTRL_ID_EJECT,                 "eject tape"
1649   },
1650   {
1651     // (same position as "eject" button)
1652     IMG_GFX_TAPE_BUTTON_EXTRA,          &tape.button.eject,
1653     TAPE_CTRL_ID_EXTRA,                 "extra functions"
1654   },
1655   {
1656     IMG_GFX_TAPE_BUTTON_STOP,           &tape.button.stop,
1657     TAPE_CTRL_ID_STOP,                  "stop tape"
1658   },
1659   {
1660     IMG_GFX_TAPE_BUTTON_PAUSE,          &tape.button.pause,
1661     TAPE_CTRL_ID_PAUSE,                 "pause tape"
1662   },
1663   {
1664     IMG_GFX_TAPE_BUTTON_RECORD,         &tape.button.record,
1665     TAPE_CTRL_ID_RECORD,                "record tape"
1666   },
1667   {
1668     IMG_GFX_TAPE_BUTTON_PLAY,           &tape.button.play,
1669     TAPE_CTRL_ID_PLAY,                  "play tape"
1670   },
1671   {
1672     IMG_GFX_TAPE_BUTTON_INSERT_SOLUTION,&tape.button.insert_solution,
1673     TAPE_CTRL_ID_INSERT_SOLUTION,       "insert solution tape"
1674   },
1675   {
1676     IMG_GFX_TAPE_BUTTON_PLAY_SOLUTION,  &tape.button.play_solution,
1677     TAPE_CTRL_ID_PLAY_SOLUTION,         "play solution tape"
1678   }
1679 };
1680
1681 void CreateTapeButtons(void)
1682 {
1683   int i;
1684
1685   for (i = 0; i < NUM_TAPE_BUTTONS; i++)
1686   {
1687     int graphic = tapebutton_info[i].graphic;
1688     struct GraphicInfo *gfx = &graphic_info[graphic];
1689     struct XY *pos = tapebutton_info[i].pos;
1690     struct GadgetInfo *gi;
1691     int gd_x = gfx->src_x;
1692     int gd_y = gfx->src_y;
1693     int gd_xp = gfx->src_x + gfx->pressed_xoffset;
1694     int gd_yp = gfx->src_y + gfx->pressed_yoffset;
1695     int id = i;
1696
1697     gi = CreateGadget(GDI_CUSTOM_ID, id,
1698                       GDI_IMAGE_ID, graphic,
1699                       GDI_INFO_TEXT, tapebutton_info[i].infotext,
1700                       GDI_X, VX + pos->x,
1701                       GDI_Y, VY + pos->y,
1702                       GDI_WIDTH, gfx->width,
1703                       GDI_HEIGHT, gfx->height,
1704                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
1705                       GDI_STATE, GD_BUTTON_UNPRESSED,
1706                       GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
1707                       GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
1708                       GDI_DIRECT_DRAW, FALSE,
1709                       GDI_EVENT_MASK, GD_EVENT_RELEASED,
1710                       GDI_CALLBACK_ACTION, HandleTapeButtons,
1711                       GDI_END);
1712
1713     if (gi == NULL)
1714       Fail("cannot create gadget");
1715
1716     tape_gadget[id] = gi;
1717   }
1718 }
1719
1720 void FreeTapeButtons(void)
1721 {
1722   int i;
1723
1724   for (i = 0; i < NUM_TAPE_BUTTONS; i++)
1725     FreeGadget(tape_gadget[i]);
1726 }
1727
1728 void MapTapeEjectButton(void)
1729 {
1730   UnmapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
1731   MapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
1732 }
1733
1734 void MapTapeWarpButton(void)
1735 {
1736   UnmapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
1737   MapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
1738 }
1739
1740 void MapTapeButtons(void)
1741 {
1742   int i;
1743
1744   for (i = 0; i < NUM_TAPE_BUTTONS; i++)
1745     if (i != TAPE_CTRL_ID_EXTRA)
1746       MapGadget(tape_gadget[i]);
1747
1748   if (tape.recording || tape.playing)
1749     MapTapeWarpButton();
1750
1751   if (tape.show_game_buttons)
1752     MapGameButtonsOnTape();
1753 }
1754
1755 void UnmapTapeButtons(void)
1756 {
1757   int i;
1758
1759   for (i = 0; i < NUM_TAPE_BUTTONS; i++)
1760     UnmapGadget(tape_gadget[i]);
1761
1762   if (tape.show_game_buttons)
1763     UnmapGameButtonsOnTape();
1764 }
1765
1766 void RedrawTapeButtons(void)
1767 {
1768   int i;
1769
1770   for (i = 0; i < NUM_TAPE_BUTTONS; i++)
1771     RedrawGadget(tape_gadget[i]);
1772
1773   if (tape.show_game_buttons)
1774     RedrawGameButtonsOnTape();
1775 }
1776
1777 void RedrawOrRemapTapeButtons(void)
1778 {
1779   if (tape_gadget[TAPE_CTRL_ID_PLAY]->mapped)
1780   {
1781     // tape buttons already mapped
1782     RedrawTapeButtons();
1783   }
1784   else
1785   {
1786     UnmapTapeButtons();
1787     MapTapeButtons();
1788   }
1789 }
1790
1791 static void HandleTapeButtonsExt(int id)
1792 {
1793   if (game_status != GAME_MODE_MAIN && game_status != GAME_MODE_PLAYING)
1794     return;
1795
1796   switch (id)
1797   {
1798     case TAPE_CTRL_ID_EJECT:
1799       TapeStop();
1800
1801       if (TAPE_IS_EMPTY(tape))
1802       {
1803         LoadTape(level_nr);
1804
1805         if (TAPE_IS_EMPTY(tape))
1806           Request("No tape for this level!", REQ_CONFIRM);
1807       }
1808       else
1809       {
1810         if (tape.changed)
1811           SaveTapeChecked(level_nr);
1812
1813         TapeErase();
1814       }
1815
1816       DrawCompleteVideoDisplay();
1817       break;
1818
1819     case TAPE_CTRL_ID_EXTRA:
1820       if (tape.playing)
1821       {
1822         tape.pause_before_end = !tape.pause_before_end;
1823
1824         DrawVideoDisplayCurrentState();
1825       }
1826       else if (tape.recording)
1827       {
1828         TapeSingleStep();
1829       }
1830
1831       break;
1832
1833     case TAPE_CTRL_ID_STOP:
1834       TapeStop();
1835
1836       break;
1837
1838     case TAPE_CTRL_ID_PAUSE:
1839       TapeTogglePause(TAPE_TOGGLE_MANUAL);
1840
1841       break;
1842
1843     case TAPE_CTRL_ID_RECORD:
1844       if (TAPE_IS_STOPPED(tape))
1845       {
1846         TapeStartGameRecording();
1847       }
1848       else if (tape.pausing)
1849       {
1850         if (tape.playing)                       // PLAY -> PAUSE -> RECORD
1851           TapeAppendRecording();
1852         else
1853           TapeTogglePause(TAPE_TOGGLE_MANUAL);
1854       }
1855
1856       break;
1857
1858     case TAPE_CTRL_ID_PLAY:
1859       if (tape.recording && tape.pausing)       // PAUSE -> RECORD
1860       {
1861         // ("TAPE_IS_EMPTY(tape)" is TRUE here -- probably fix this)
1862
1863         TapeTogglePause(TAPE_TOGGLE_MANUAL);
1864       }
1865
1866       if (TAPE_IS_EMPTY(tape))
1867         break;
1868
1869       if (TAPE_IS_STOPPED(tape))
1870       {
1871         TapeStartGamePlaying();
1872       }
1873       else if (tape.playing)
1874       {
1875         if (tape.pausing)                       // PAUSE -> PLAY
1876         {
1877           TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
1878         }
1879         else if (!tape.fast_forward)            // PLAY -> FFWD
1880         {
1881           tape.fast_forward = TRUE;
1882         }
1883         else if (!tape.warp_forward)            // FFWD -> WARP
1884         {
1885           tape.warp_forward = TRUE;
1886         }
1887         else if (!tape.deactivate_display)      // WARP -> WARP BLIND
1888         {
1889           tape.deactivate_display = TRUE;
1890
1891           TapeDeactivateDisplayOn();
1892         }
1893         else                                    // WARP BLIND -> PLAY
1894         {
1895           tape.fast_forward = FALSE;
1896           tape.warp_forward = FALSE;
1897           tape.deactivate_display = FALSE;
1898
1899           TapeDeactivateDisplayOff(game_status == GAME_MODE_PLAYING);
1900         }
1901
1902         DrawVideoDisplayCurrentState();
1903       }
1904
1905       break;
1906
1907     case TAPE_CTRL_ID_INSERT_SOLUTION:
1908       InsertSolutionTape();
1909
1910       break;
1911
1912     case TAPE_CTRL_ID_PLAY_SOLUTION:
1913       PlaySolutionTape();
1914
1915       break;
1916
1917     default:
1918       break;
1919   }
1920 }
1921
1922 static void HandleTapeButtons(struct GadgetInfo *gi)
1923 {
1924   HandleTapeButtonsExt(gi->custom_id);
1925 }
1926
1927 void HandleTapeButtonKeys(Key key)
1928 {
1929   boolean eject_button_is_active = TAPE_IS_STOPPED(tape);
1930   boolean extra_button_is_active = !eject_button_is_active;
1931
1932   if (key == setup.shortcut.tape_eject && eject_button_is_active)
1933     HandleTapeButtonsExt(TAPE_CTRL_ID_EJECT);
1934   else if (key == setup.shortcut.tape_extra && extra_button_is_active)
1935     HandleTapeButtonsExt(TAPE_CTRL_ID_EXTRA);
1936   else if (key == setup.shortcut.tape_stop)
1937     HandleTapeButtonsExt(TAPE_CTRL_ID_STOP);
1938   else if (key == setup.shortcut.tape_pause)
1939     HandleTapeButtonsExt(TAPE_CTRL_ID_PAUSE);
1940   else if (key == setup.shortcut.tape_record)
1941     HandleTapeButtonsExt(TAPE_CTRL_ID_RECORD);
1942   else if (key == setup.shortcut.tape_play)
1943     HandleTapeButtonsExt(TAPE_CTRL_ID_PLAY);
1944 }