white space changes
[rocksndiamonds.git] / src / game_sp / Murphy.c
1 // ----------------------------------------------------------------------------
2 // Murphy.c
3 // ----------------------------------------------------------------------------
4
5 #include "Murphy.h"
6
7
8 static void subEatRedDisk(int si);
9 static boolean subMoveKillsMurphy(int si, int ax, int bl);
10
11 #define LocalStretch                    (2)
12 #define MurphyZoomFactor                (ZoomFactor)
13
14
15 // Variables that hold information about the animation sequence
16 static int dx1 = 0; // image/animation token
17 static int dx2 = 0; // an additional image position of a second sprite, for instance: yellow disk if pushed
18 static int MurphyDX = 0, MurphyDY = 0; // murphys move steps
19 static int SeqPos = 0; // index into dx()
20 static int ClearPos = 0; // Position to clear before blitting sprites, none=-1
21 static int dxPos = 0; // field-position  to draw dx(SeqPos)
22 static int dx2Step = 0; // position of dx2 relative to dx-position
23 static int dx1SequenceLength = 0;
24
25
26 void SaveEngineSnapshotValues_SP_Murphy(ListNode **buffers)
27 {
28   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(dx1));
29   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(dx2));
30   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(MurphyDX));
31   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(MurphyDY));
32   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(SeqPos));
33   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(ClearPos));
34   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(dxPos));
35   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(dx2Step));
36   SaveSnapshotBuffer(buffers, ARGS_ADDRESS_AND_SIZEOF(dx1SequenceLength));
37 }
38
39
40 // ==========================================================================
41 //                              SUBROUTINE
42 // Move Murphy in any direction
43 // ==========================================================================
44
45 void subAnimateMurphy(int *si)
46 {
47   int ax, al, bl, i, X, Y;
48   int time1, time2;
49   int tDeltaX, tDeltaY, tPos, Tmp;
50
51   ax = PlayField16[*si];
52   al = LowByte(ax);
53
54   if (al != fiMurphy)
55   {
56     MurphyMoveCounter = 0;             // We have no Murphy! Exit!
57
58     return;
59   }
60
61   MurphyMoveCounter = 1;             // We have a Murphy!
62   MurphyExplodePos = *si;
63
64   // (check if high byte of PlayField16 has stored movement information)
65   if (ax != fiMurphy) // yes--go proceed moving murphy?
66     goto locProceedMovingMurphy;
67
68   // FS: reset moving sequence variables
69   MurphyDX = 0;
70   MurphyDY = 0;
71   ClearPos = *si;
72   dxPos = *si;
73   dx1 = -1;
74   dx2 = -1;
75   SeqPos = 0;
76   // end of FS
77
78   ScratchGravity = 0; // scratch gravity off
79   if (GravityFlag != 0) // Gravity? (1=gravity on)
80   {
81     bl = LowByte(PlayField16[*si - FieldWidth]); // check above
82     if (! (bl == fiPortUp ||
83            bl == fiPortUpAndDown ||
84            bl == fiPortAllDirections))
85     {
86       if (PlayField16[*si + FieldWidth] == 0) // gravity on and space below!
87         ScratchGravity = 1;
88     }
89   } // loc_g_5E8B:
90
91   bl = DemoKeyCode;
92   if (bl != 0) // a key was pressed!
93     goto locKeyPressed5FCF;
94
95   RedDiskReleaseFlag = 1;
96   if (ScratchGravity != 0) // gravity pulls & space below?'-> force Space up to down
97   {
98     MurphyDY = 2;
99     goto loc_g_6364;
100   }
101
102   // ------------------------------------------------------------------
103   // Murphy's YAWN & SLEEP sequence, counted down by YawnSleepCounter:
104
105   YawnSleepCounter = YawnSleepCounter + 1;
106
107   if (YawnSleepCounter < 16)
108     return;
109
110   if (YawnSleepCounter < 2000)
111   {
112     // normal grin
113     // (default: single graphic, no animation)
114     subCopyAnimToScreen(*si, aniMurphy, YawnSleepCounter - 16);
115
116     return;
117   }
118
119   if (YawnSleepCounter < 4000)
120   {
121     // yawn! and look depressed afterwards...
122     // (default: 12 animation frames with delay of 8)
123     subCopyAnimToScreen(*si, aniMurphyYawn, YawnSleepCounter - 2000);
124
125     return;
126   }
127
128   if (YawnSleepCounter < 6400)
129   {
130     // yawn again!
131     // (default: 12 animation frames with delay of 8)
132     subCopyAnimToScreen(*si, aniMurphyYawn, YawnSleepCounter - 4000);
133
134     return;
135   }
136
137   // time1 = 6400 + 12 * 8;     // (default: 6496 == 6400 + 12 * 8)
138   time1 = 6400 + 12 * 10;
139
140   if (YawnSleepCounter < time1)
141   {
142     // yawn again! - third time
143     // (default: 12 animation frames with delay of 8)
144     subCopyAnimToScreen(*si, aniMurphyYawn, YawnSleepCounter - 6400);
145
146     return;
147   }
148
149   // time2 = 6496 + 3 * 64;     // (default: 6688 == 6496 + 3 * 64)
150   time2 = 6496 + 3 * 100;
151
152   if (YawnSleepCounter > time2)         // Murphy already went to sleep
153     return;
154
155   if (PlayField16[*si - 1] == 0)
156   {
157     if (PlayField16[*si + 1] == 0)
158     {
159       // no sleep -- go back to "wait and start yawning" phase
160       YawnSleepCounter = 144;
161
162       return;
163     }
164     else
165     {
166       // go to sleep (right side)
167       // (default: 3 animation frames with delay of 64)
168       subCopyAnimToScreen(*si, aniMurphySleepRight, YawnSleepCounter - time1);
169
170       return;
171     }
172   }
173
174   // go to sleep (left side)
175   // (default: 3 animation frames with delay of 64)
176   subCopyAnimToScreen(*si, aniMurphySleepLeft, YawnSleepCounter - time1);
177
178   return;
179
180   // end of YAWN-SLEEP-Sequence
181
182   // ------------------------------------------------------------------
183   // ==========================================================================
184   //                       (Direct Jump) a key was pressed
185   // ==========================================================================
186
187 locKeyPressed5FCF:
188   if (ScratchGravity == 0)
189     goto loc_g_6003;
190
191   if (PlayField16[*si + FieldWidth] != 0)
192     goto loc_g_6003;
193
194   if (bl == keyUp)
195   {
196     if (PlayField16[*si - FieldWidth] == fiBase)
197       goto loc_g_6003;
198
199   }
200   else if (bl == keyLeft)
201   {
202     if (PlayField16[*si - 1] == fiBase)
203       goto loc_g_6003;
204
205   }
206   else if (bl == keyRight)
207   {
208     if (PlayField16[*si + 1] == fiBase)
209       goto loc_g_6003;
210   } // loc_g_6001:
211
212   bl = keyDown;                      // force moving down!
213 loc_g_6003:
214   switch (bl)
215   {
216     case keyUp: // 1
217       RedDiskReleaseFlag = 0; // moving down to up ...
218       goto loc_g_6078;
219
220       break;
221
222     case keyLeft: // 2
223       RedDiskReleaseFlag = 0; // moving right to left ...
224       goto loc_g_60DA;
225
226       break;
227
228     case keyDown: // 3
229       RedDiskReleaseFlag = 0; // moving up to down ...
230       goto loc_g_6154;
231
232       break;
233
234     case keyRight: // 4
235       RedDiskReleaseFlag = 0; // moving left to right ...
236       goto loc_g_61B6;
237
238       break;
239
240     case keySpaceUp: // 5
241       RedDiskReleaseFlag = 0; // touching down to up ...
242       goto loc_g_622E;
243
244       break;
245
246     case keySpaceLeft: // 6
247       RedDiskReleaseFlag = 0; // touching right to left ...
248       goto loc_g_6258;
249
250       break;
251
252     case keySpaceDown: // 7
253       RedDiskReleaseFlag = 0; // touching up to down ...
254       goto loc_g_6288;
255
256       break;
257
258     case keySpaceRight: // 8
259       RedDiskReleaseFlag = 0; // touching left to right ...
260       goto loc_g_62B2;
261
262       break;
263
264     case keySpace: // 9
265       goto loc_g_62E2;                         // no move ...
266
267       break;
268
269     default:
270       RedDiskReleaseFlag = 0;
271       return;
272       break;
273   }
274
275   // ==========================================================================
276   // moving down to up ...
277   // ==========================================================================
278
279 loc_g_6078:
280   // FS:
281   MurphyDY = -2;
282   // end of FS
283   ax = PlayField16[*si - FieldWidth];
284   al = LowByte(ax);
285   if (ax == fiSpace)
286     goto loc_g_6312;
287
288   if (ax == fiBase)
289     goto loc_g_63D3;
290
291   if (al == fiBug)
292     goto loc_g_63C2;
293
294   if (ax == fiInfotron)
295     goto loc_g_65C6;
296
297   if (ax == fiExit)
298     goto loc_g_6756;
299
300   if (al == fiTerminal)
301     goto loc_g_6817;
302
303   if (al == fiPortUp || al == fiPortUpAndDown || al == fiPortAllDirections)
304     goto loc_g_6916;
305
306   if (al == fiRedDisk)
307     goto loc_g_69A6;
308
309   if (al == fiYellowDisk)
310     goto loc_g_6AB8;
311
312   if (! subMoveKillsMurphy(*si - FieldWidth, ax, bl))
313     goto loc_g_6078;
314
315   return;
316
317   // ==========================================================================
318   // moving right to left ...
319   // ==========================================================================
320
321 loc_g_60DA:
322   // FS:
323   MurphyDX = -2;
324   // end of FS
325   MurphyVarFaceLeft = 1;
326   ax = PlayField16[*si - 1];
327   al = LowByte(ax);
328   if (ax == fiSpace)
329     goto loc_g_6341;
330
331   if (ax == fiBase)
332     goto loc_g_641C;
333
334   if (al == fiBug)
335     goto loc_g_640B;
336
337   if (ax == fiInfotron)
338     goto loc_g_65FE;
339
340   if (ax == fiExit)
341     goto loc_g_6756;
342
343   if (ax == fiZonk)
344     goto loc_g_679B;
345
346   if (al == fiTerminal)
347     goto loc_g_684E;
348
349   if (al == fiPortLeft || al == fiPortLeftAndRight || al == fiPortAllDirections)
350     goto loc_g_693A;
351
352   if (ax == fiRedDisk)
353     goto loc_g_69CE;
354
355   if (ax == fiYellowDisk)
356     goto loc_g_6AF1;
357
358   if (ax == fiOrangeDisk)
359     goto loc_g_6B9B;
360
361   if (! subMoveKillsMurphy(*si - 1, ax, bl))
362     goto loc_g_60DA;
363
364   return;
365
366   // ==========================================================================
367   // moving up to down ...
368   // ==========================================================================
369
370 loc_g_6154:
371   // FS:
372   MurphyDY = 2;
373   // end of FS
374   ax = PlayField16[*si + FieldWidth];
375   al = LowByte(ax);
376   if (ax == fiSpace)
377     goto loc_g_6364;
378
379   if (ax == fiBase)
380     goto loc_g_6459;
381
382   if (al == fiBug)
383     goto loc_g_6448;
384
385   if (ax == fiInfotron)
386     goto loc_g_662A;
387
388   if (ax == fiExit)
389     goto loc_g_6756;
390
391   if (al == fiTerminal)
392     goto loc_g_6884;
393
394   if (al == fiPortDown || al == fiPortUpAndDown || al == fiPortAllDirections)
395     goto loc_g_695E;
396
397   if (al == fiRedDisk)
398     goto loc_g_69F7;
399
400   if (al == fiYellowDisk)
401     goto loc_g_6B2A;
402
403   if (! subMoveKillsMurphy(*si + FieldWidth, ax, bl))
404     goto loc_g_6154;
405
406   return;
407
408   // ==========================================================================
409   // moving left to right ...
410   // ==========================================================================
411
412 loc_g_61B6:
413   // FS:
414   MurphyDX = 2;
415   // end of FS
416   MurphyVarFaceLeft = 0;
417   ax = PlayField16[*si + 1];
418   al = LowByte(ax);
419   if (ax == fiSpace)
420     goto loc_g_6399;
421
422   if (ax == fiBase)
423     goto loc_g_64A2;
424
425   if (al == fiBug)
426     goto loc_g_6491;
427
428   if (ax == fiInfotron)
429     goto loc_g_6662;
430
431   if (ax == fiExit)
432     goto loc_g_6756;
433
434   if (ax == fiZonk)
435     goto loc_g_67D4;
436
437   if (al == fiTerminal)
438     goto loc_g_68BA;
439
440   if (al == fiPortRight || al == fiPortLeftAndRight || al == fiPortAllDirections)
441     goto loc_g_6982;
442
443   if (al == fiRedDisk)
444     goto loc_g_6A1F;
445
446   if (al == fiYellowDisk)
447     goto loc_g_6B63;
448
449   if (ax == fiOrangeDisk)
450     goto loc_g_6BD3;
451
452   if (! subMoveKillsMurphy(*si + 1, ax, bl))
453     goto loc_g_61B6;
454
455   return;
456
457   // ==========================================================================
458   // touching down to up ...
459   // ==========================================================================
460
461 loc_g_622E:
462   // FS:
463   ClearPos = -1;
464   dxPos = *si - FieldWidth;
465   // end of FS
466   ax = PlayField16[*si - FieldWidth];
467   al = LowByte(ax);
468   al = LowByte(ax);
469   if (ax == fiBase)
470     goto loc_g_64DF;
471
472   if (al == fiBug)
473     goto loc_g_64CE;
474
475   if (ax == fiInfotron)
476     goto loc_g_668E;
477
478   if (al == fiTerminal)
479     goto loc_g_6817;
480
481   if (al == fiRedDisk)
482     goto loc_g_6A48;
483
484   return;
485
486   // ==========================================================================
487   // touching right to left ...
488   // ==========================================================================
489
490 loc_g_6258:
491   // FS:
492   ClearPos = -1;
493   dxPos = *si - 1;
494   // end of FS
495   MurphyVarFaceLeft = 1;
496   ax = PlayField16[*si - 1];
497   al = LowByte(ax);
498   if (ax == fiBase)
499     goto loc_g_651D;
500
501   if (al == fiBug)
502     goto loc_g_650C;
503
504   if (ax == fiInfotron)
505     goto loc_g_66C0;
506
507   if (al == fiTerminal)
508     goto loc_g_684E;
509
510   if (al == fiRedDisk)
511     goto loc_g_6A64;
512
513   return;
514
515   // ==========================================================================
516   // touching up to down ...
517   // ==========================================================================
518
519 loc_g_6288:
520   // FS:
521   ClearPos = -1;
522   dxPos = *si + FieldWidth;
523   // end of FS
524   ax = PlayField16[*si + FieldWidth];
525   al = LowByte(ax);
526   if (ax == fiBase)
527     goto loc_g_655B;
528
529   if (al == fiBug)
530     goto loc_g_654A;
531
532   if (ax == fiInfotron)
533     goto loc_g_66F2;
534
535   if (al == fiTerminal)
536     goto loc_g_6884;
537
538   if (al == fiRedDisk)
539     goto loc_g_6A80;
540
541   return;
542
543   // ==========================================================================
544   // touching left to right ...
545   // ==========================================================================
546
547 loc_g_62B2:
548   // FS:
549   ClearPos = -1;
550   dxPos = *si + 1;
551   // end of FS
552   MurphyVarFaceLeft = 0;
553   ax = PlayField16[*si + 1];
554   al = LowByte(ax);
555   if (ax == fiBase)
556     goto loc_g_6599;
557
558   if (al == fiBug)
559     goto loc_g_6588;
560
561   if (ax == fiInfotron)
562     goto loc_g_6724;
563
564   if (al == fiTerminal)
565     goto loc_g_68BA;
566
567   if (al == fiRedDisk)
568     goto loc_g_6A9C;
569
570   return;
571
572   // ==========================================================================
573   // Release Red disk: no move ...
574   // ==========================================================================
575
576 loc_g_62E2:
577   // FS:
578   ClearPos = -1;
579   // end of FS
580   if (LowByte(RedDiskCount) == 0)
581     return;
582
583   if (LowByte(RedDiskReleasePhase) != 0)
584     return;
585
586   if (LowByte(RedDiskReleaseFlag) != 1)
587     return;
588
589   MovHighByte(&PlayField16[*si], 0x2A);
590   MovingPictureSequencePhase = 0x40; // init picture move sequence
591   dx1 = aniRedDisk;
592   MovLowByte(&RedDiskReleasePhase, 1);
593   RedDiskReleaseMurphyPos = *si;             // remember Murphy's location
594   goto loc_Split;
595
596   // ==========================================================================
597   // SPACE moving down to up
598   // ==========================================================================
599
600 loc_g_6312:
601   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyMoveUpRight : aniMurphyMoveUpLeft);
602   PlayField16[*si - FieldWidth] = 0x103;
603   PlayField16[*si] = 0x300;
604   *si = *si - FieldWidth;
605   goto loc_StopNoSplit;
606
607   // ==========================================================================
608   // SPACE moving right to left
609   // ==========================================================================
610
611 loc_g_6341:
612   dx1 = aniMurphyMoveLeft;
613   PlayField16[*si - 1] = 0x203;
614   PlayField16[*si] = 0x300;
615   *si = *si - 1;
616   goto loc_StopNoSplit;
617
618   // ==========================================================================
619   // SPACE moving up to down, and when gravity is pulling!
620   // ==========================================================================
621
622 loc_g_6364:
623   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyMoveUpRight : aniMurphyMoveUpLeft);
624   PlayField16[*si + FieldWidth] = 0x303;
625   PlayField16[*si] = 0x300;
626   *si = *si + FieldWidth;
627   goto loc_StopNoSplit;
628
629   // ==========================================================================
630   // SPACE moving left to right
631   // ==========================================================================
632
633 loc_g_6399:
634   dx1 = aniMurphyMoveRight;
635   PlayField16[*si + 1] = 0x403;
636   PlayField16[*si] = 0x300;
637   *si = *si + 1;
638   goto loc_StopNoSplit;
639
640   // ==========================================================================
641   // BUG moving down to up
642   // ==========================================================================
643
644 loc_g_63C2:
645   if (SgnHighByte(PlayField16[*si - FieldWidth]) >= 0)
646   {
647     ExplodeFieldSP(*si);                 // Explode
648
649     return;
650   }
651
652   PlayField16[*si - FieldWidth] = fiBase;
653   // ==========================================================================
654   // BASE moving down to up
655   // ==========================================================================
656
657 loc_g_63D3:
658   subSoundFX(*si, fiBase, actDigging);
659
660   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyDigUpRight : aniMurphyDigUpLeft);
661   PlayField16[*si - FieldWidth] = 0x503;
662   PlayField16[*si] = 0x300;
663   *si = *si - FieldWidth;
664   goto loc_StopNoSplit;
665
666   // ==========================================================================
667   // BUG moving right to left
668   // ==========================================================================
669
670 loc_g_640B:
671   if (SgnHighByte(PlayField16[*si - 1]) >= 0)
672   {
673     ExplodeFieldSP(*si);                 // Explode
674
675     return;
676   }
677
678   PlayField16[*si - 1] = fiBase;
679   // ==========================================================================
680   // BASE moving right to left
681   // ==========================================================================
682
683 loc_g_641C:
684   subSoundFX(*si, fiBase, actDigging);
685
686   dx1 = aniMurphyDigLeft;
687   PlayField16[*si - 1] = 0x203;
688   PlayField16[*si] = 0x300;
689   *si = *si - 1;
690   goto loc_StopNoSplit;
691
692   // ==========================================================================
693   // BUG moving up to down
694   // ==========================================================================
695
696 loc_g_6448:
697   if (SgnHighByte(PlayField16[*si + FieldWidth]) >= 0)
698   {
699     ExplodeFieldSP(*si);                 // Explode
700
701     return;
702   }
703
704   PlayField16[*si + FieldWidth] = fiBase;
705   // ==========================================================================
706   // BASE moving up to down
707   // ==========================================================================
708
709 loc_g_6459:
710   subSoundFX(*si, fiBase, actDigging);
711
712   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyDigUpRight : aniMurphyDigUpLeft);
713   PlayField16[*si + FieldWidth] = 0x703;
714   PlayField16[*si] = 0x300;
715   *si = *si + FieldWidth;
716   goto loc_StopNoSplit;
717
718   // ==========================================================================
719   // BUG moving left to right
720   // ==========================================================================
721
722 loc_g_6491:
723   if (SgnHighByte(PlayField16[*si + 1]) >= 0)
724   {
725     ExplodeFieldSP(*si);                 // Explode
726
727     return;
728   }
729
730   PlayField16[*si + 1] = fiBase;
731   // ==========================================================================
732   // BASE moving left to right
733   // ==========================================================================
734
735 loc_g_64A2:
736   subSoundFX(*si, fiBase, actDigging);
737
738   dx1 = aniMurphyDigRight;
739   PlayField16[*si + 1] = 0x803;
740   PlayField16[*si] = 0x300;
741   *si = *si + 1;
742   goto loc_StopNoSplit;
743
744   // ==========================================================================
745   // BUG touching down to up
746   // ==========================================================================
747
748 loc_g_64CE:
749   if (SgnHighByte(PlayField16[*si - FieldWidth]) >= 0)
750   {
751     ExplodeFieldSP(*si);                 // Explode
752
753     return;
754   }
755
756   PlayField16[*si - FieldWidth] = fiBase;
757   // ==========================================================================
758   // BASE touching down to up
759   // ==========================================================================
760
761 loc_g_64DF:
762   subCopyImageToScreen(*si, aniMurphyTouchUp);
763   subSoundFX(*si, fiBase, actDigging);
764
765   dx1 = aniTouchBase;
766   dxPos = *si - FieldWidth;
767   MovHighByte(&PlayField16[*si], 0x10);
768   goto loc_StopNoSplit;
769
770   // ==========================================================================
771   // BUG touching right to left
772   // ==========================================================================
773
774 loc_g_650C:
775   if (SgnHighByte(PlayField16[*si - 1]) >= 0)
776   {
777     ExplodeFieldSP(*si);                 // Explode
778
779     return;
780   }
781
782   PlayField16[*si - 1] = fiBase;
783   // ==========================================================================
784   // BASE touching right to left
785   // ==========================================================================
786
787 loc_g_651D:
788   subCopyImageToScreen(*si, aniMurphyTouchLeft);
789   subSoundFX(*si, fiBase, actDigging);
790
791   dx1 = aniTouchBase;
792   dxPos = *si - 1;
793   MovHighByte(&PlayField16[*si], 0x11);
794   goto loc_StopNoSplit;
795
796   // ==========================================================================
797   // BUG touching up to down
798   // ==========================================================================
799
800 loc_g_654A:
801   if (SgnHighByte(PlayField16[*si + FieldWidth]) >= 0)
802   {
803     ExplodeFieldSP(*si);                 // Explode
804
805     return;
806   }
807
808   PlayField16[*si + FieldWidth] = fiBase;
809   // ==========================================================================
810   // BASE touching up to down
811   // ==========================================================================
812
813 loc_g_655B:
814   subCopyImageToScreen(*si, aniMurphyTouchDown);
815   subSoundFX(*si, fiBase, actDigging);
816
817   dx1 = aniTouchBase;
818   dxPos = *si + FieldWidth;
819   MovHighByte(&PlayField16[*si], 0x12);
820   goto loc_StopNoSplit;
821
822   // ==========================================================================
823   // BUG touching left to right
824   // ==========================================================================
825
826 loc_g_6588:
827   if (SgnHighByte(PlayField16[*si + 1]) >= 0)
828   {
829     ExplodeFieldSP(*si);                 // Explode
830
831     return;
832   }
833
834   PlayField16[*si + 1] = fiBase;
835   // ==========================================================================
836   // BASE touching left to right
837   // ==========================================================================
838
839 loc_g_6599:
840   subCopyImageToScreen(*si, aniMurphyTouchRight);
841   subSoundFX(*si, fiBase, actDigging);
842
843   dx1 = aniTouchBase;
844   dxPos = *si + 1;
845   MovHighByte(&PlayField16[*si], 0x13);
846   goto loc_StopNoSplit;
847
848   // ==========================================================================
849   // INFOTRON moving down to up
850   // ==========================================================================
851
852 loc_g_65C6:
853   subSoundFX(*si, fiInfotron, actCollecting);
854
855   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyEatUpRight : aniMurphyEatUpLeft);
856   PlayField16[*si - FieldWidth] = 0x903;
857   PlayField16[*si] = 0x300;
858   *si = *si - FieldWidth;
859   goto loc_StopNoSplit;
860
861   // ==========================================================================
862   // INFOTRON moving right to left
863   // ==========================================================================
864
865 loc_g_65FE:
866   subSoundFX(*si, fiInfotron, actCollecting);
867
868   dx1 = aniEatInfotronLeft;
869   PlayField16[*si - 1] = 0xA03;
870   PlayField16[*si] = 0x300;
871   *si = *si - 1;
872   goto loc_StopNoSplit;
873
874   // ==========================================================================
875   // INFOTRON moving up to down
876   // ==========================================================================
877
878 loc_g_662A:
879   subSoundFX(*si, fiInfotron, actCollecting);
880
881   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyEatUpRight : aniMurphyEatUpLeft);
882   PlayField16[*si + FieldWidth] = 0xB03;
883   PlayField16[*si] = 0x300;
884   *si = *si + FieldWidth;
885   goto loc_StopNoSplit;
886
887   // ==========================================================================
888   // INFOTRON moving left to right
889   // ==========================================================================
890
891 loc_g_6662:
892   subSoundFX(*si, fiInfotron, actCollecting);
893
894   dx1 = aniEatInfotronRight;
895   PlayField16[*si + 1] = 0xC03;
896   PlayField16[*si] = 0x300;
897   *si = *si + 1;
898   goto loc_StopNoSplit;
899
900   // ==========================================================================
901   // INFOTRON touching down to up
902   // ==========================================================================
903
904 loc_g_668E:
905   subCopyImageToScreen(*si, aniMurphyTouchUp);
906   subSoundFX(*si, fiInfotron, actCollecting);
907
908   dx1 = aniTouchInfotron;
909   MovHighByte(&PlayField16[*si], 0x14);
910   MovHighByte(&PlayField16[*si - FieldWidth], 0xFF);
911   goto loc_StopNoSplit;
912
913   // ==========================================================================
914   // INFOTRON touching right to left
915   // ==========================================================================
916
917 loc_g_66C0:
918   subCopyImageToScreen(*si, aniMurphyTouchLeft);
919   subSoundFX(*si, fiInfotron, actCollecting);
920
921   dx1 = aniTouchInfotron;
922   MovHighByte(&PlayField16[*si], 0x15);
923   MovHighByte(&PlayField16[*si - 1], 0xFF);
924   goto loc_StopNoSplit;
925
926   // ==========================================================================
927   // INFOTRON touching up to down
928   // ==========================================================================
929
930 loc_g_66F2:
931   subCopyImageToScreen(*si, aniMurphyTouchDown);
932   subSoundFX(*si, fiInfotron, actCollecting);
933
934   dx1 = aniTouchInfotron;
935   MovHighByte(&PlayField16[*si], 0x16);
936   MovHighByte(&PlayField16[*si + FieldWidth], 0xFF);
937   goto loc_StopNoSplit;
938
939   // ==========================================================================
940   // INFOTRON touching left to right
941   // ==========================================================================
942
943 loc_g_6724:
944   subCopyImageToScreen(*si, aniMurphyTouchRight);
945   subSoundFX(*si, fiInfotron, actCollecting);
946
947   dx1 = aniTouchInfotron;
948   MovHighByte(&PlayField16[*si], 0x17);
949   MovHighByte(&PlayField16[*si + 1], 0xFF);
950   goto loc_StopNoSplit;
951
952   // ==========================================================================
953   // EXIT pressed from any direction
954   // ==========================================================================
955
956 loc_g_6756:
957   // FS
958   ClearPos = -1;
959   MurphyDX = 0;
960   MurphyDY = 0;
961   // end of FS
962   if (LowByte(InfotronsNeeded) != 0)
963     return;
964
965   game_sp.level_solved = TRUE;
966
967   subSoundFX(*si, fiExit, actPassing);
968
969   LeadOutCounter = 0x40;          // quit: start lead-out
970   dx1 = aniMurphyExit;
971   MovHighByte(&PlayField16[*si], 0xD);
972   goto loc_StopNoSplit;
973
974   // ==========================================================================
975   // ZONK moving right to left
976   // ==========================================================================
977
978 loc_g_679B:
979   ax = PlayField16[*si - 2];
980   if (ax != 0)
981     return;
982
983   MovHighByte(&PlayField16[*si - 2], 1);
984   subCopyImageToScreen(*si, aniPushLeft); // draw pushing murphy
985   dx1 = aniZonkRollLeft;
986   dxPos = *si - 1;
987   dx2 = aniPushLeft;
988   dx2Step = 1;
989   MovHighByte(&PlayField16[*si], 0xE);
990   goto loc_MoveNoSplit;
991
992   // ==========================================================================
993   // ZONK moving left to right
994   // ==========================================================================
995
996 loc_g_67D4:
997   ax = PlayField16[*si + 2];
998   if (ax != 0)
999     return;
1000
1001   ax = PlayField16[*si + FieldWidth + 1];
1002   if (ax == 0) // zonk falls
1003     return;
1004
1005   MovHighByte(&PlayField16[*si + 2], 1);
1006   subCopyImageToScreen(*si, aniPushRight); // draw pushing murphy
1007   dx1 = aniZonkRollRight;
1008   dxPos = *si + 1;
1009   dx2 = aniPushRight;
1010   dx2Step = -1;
1011   MovHighByte(&PlayField16[*si], 0xF);
1012   goto loc_MoveNoSplit;
1013
1014   // ==========================================================================
1015   // TERMINAL moving/touching down to up
1016   // ==========================================================================
1017
1018 loc_g_6817:
1019   subCopyImageToScreen(*si, aniMurphyTouchUp);
1020   if (YellowDisksExploded != 0)
1021   {
1022     YawnSleepCounter = 40; // stay hypnotized
1023
1024     return;
1025   } // loc_g_6838:
1026
1027   // draw new terminal type
1028   GfxGraphic[GetX(*si - FieldWidth)][GetY(*si - FieldWidth)] = aniTerminalActive;
1029   TerminalState[*si - FieldWidth] = 8;
1030   goto loc_g_68F0;
1031
1032   // ==========================================================================
1033   // TERMINAL moving/touching right to left
1034   // ==========================================================================
1035
1036 loc_g_684E:
1037   subCopyImageToScreen(*si, aniMurphyTouchLeft);
1038   if (YellowDisksExploded != 0)
1039   {
1040     YawnSleepCounter = 40; // stay hypnotized
1041
1042     return;
1043   } // loc_g_6838:
1044
1045   // draw new terminal type
1046   GfxGraphic[GetX(*si - 1)][GetY(*si - 1)] = aniTerminalActive;
1047   TerminalState[*si - 1] = 8;
1048   goto loc_g_68F0;
1049
1050   // ==========================================================================
1051   // TERMINAL moving/touching up to down
1052   // ==========================================================================
1053
1054 loc_g_6884:
1055   subCopyImageToScreen(*si, aniMurphyTouchDown);
1056   if (YellowDisksExploded != 0)
1057   {
1058     YawnSleepCounter = 40; // stay hypnotized
1059
1060     return;
1061   } // loc_g_6838:
1062
1063   // draw new terminal type
1064   GfxGraphic[GetX(*si + FieldWidth)][GetY(*si + FieldWidth)] = aniTerminalActive;
1065   TerminalState[*si + FieldWidth] = 8;
1066   goto loc_g_68F0;
1067
1068   // ==========================================================================
1069   // TERMINAL moving/touching left to right
1070   // ==========================================================================
1071
1072 loc_g_68BA:
1073   subCopyImageToScreen(*si, aniMurphyTouchRight);
1074   if (YellowDisksExploded != 0)
1075   {
1076     YawnSleepCounter = 40; // stay hypnotized
1077
1078     return;
1079   } // loc_g_6838:
1080
1081   // draw new terminal type
1082   GfxGraphic[GetX(*si + 1)][GetY(*si + 1)] = aniTerminalActive;
1083   TerminalState[*si + 1] = 8;
1084   // ==========================================================================
1085   // common TERMINAL stuff moving/touching from all directions
1086   // ==========================================================================
1087
1088 loc_g_68F0:
1089   TerminalMaxCycles = 7;
1090   YellowDisksExploded = 1;
1091   for (i = 0; i <= LevelMax; i++)
1092   {
1093     if (PlayField16[i] == fiYellowDisk)
1094       ExplodeFieldSP (i);
1095   }
1096
1097   return;
1098
1099   // ==========================================================================
1100   // PORT down to up, VERTICAL PORT, CROSS PORT all moving down to up
1101   // ==========================================================================
1102
1103 loc_g_6916:
1104   if (PlayField16[*si - 2 * FieldWidth] != 0)
1105     return;
1106
1107   dx1 = aniSplitUpDown;
1108   dx2Step = -FieldWidth;
1109   PlayField16[*si] = 0x1803;
1110   PlayField16[*si - 2 * FieldWidth] = 0x300;
1111   goto loc_StopSplit;
1112
1113   // ==========================================================================
1114   // PORT right to left, HORIZONTAL PORT, CROSS PORT all moving right to left
1115   // ==========================================================================
1116
1117 loc_g_693A:
1118   if (PlayField16[*si - 2] != 0)
1119     return;
1120
1121   dx1 = aniMurphyMoveLeft;
1122   dx2Step = -1;
1123   PlayField16[*si] = 0x1903;
1124   PlayField16[*si - 2] = 0x300;
1125   goto loc_StopSplit;
1126
1127   // ==========================================================================
1128   // PORT up to down, VERTICAL PORT, CROSS PORT all moving up to down
1129   // ==========================================================================
1130
1131 loc_g_695E:
1132   if (PlayField16[*si + 2 * FieldWidth] != 0)
1133     return;
1134
1135   dx1 = aniSplitUpDown;
1136   dx2Step = FieldWidth;
1137   PlayField16[*si] = 0x1A03;
1138   PlayField16[*si + 2 * FieldWidth] = 0x300;
1139   goto loc_StopSplit;
1140
1141   // ==========================================================================
1142   // PORT left to right, HORIZONTAL PORT, CROSS PORT all moving left to right
1143   // ==========================================================================
1144
1145 loc_g_6982:
1146   if (PlayField16[*si + 2] != 0)
1147     return;
1148
1149   dx1 = aniMurphyMoveRight;
1150   dx2Step = 1;
1151   PlayField16[*si] = 0x1B03;
1152   PlayField16[*si + 2] = 0x300;
1153
1154 loc_StopSplit:
1155   MovingPictureSequencePhase = 0; // stop picture move sequence
1156   SplitMoveFlag = 1; // port: split movement
1157   goto loc_Split;
1158
1159   // ==========================================================================
1160   // RED DISK moving down to up
1161   // ==========================================================================
1162
1163 loc_g_69A6:
1164   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyEatUpRight : aniMurphyEatUpLeft);
1165   PlayField16[*si] = 0x1C03;
1166   PlayField16[*si - FieldWidth] = 0x300;
1167   goto loc_StopNoSplit;
1168
1169   // ==========================================================================
1170   // RED DISK moving right to left
1171   // ==========================================================================
1172
1173 loc_g_69CE:
1174   dx1 = aniMurphyEatLeft;
1175   PlayField16[*si] = 0x300; // !!!!!! this time we move murphy at sequence-start!
1176   PlayField16[*si - 1] = 0x1D03;
1177   *si = *si - 1;
1178   goto loc_StopNoSplit;
1179
1180   // ==========================================================================
1181   // RED DISK moving up to down
1182   // ==========================================================================
1183
1184 loc_g_69F7:
1185   dx1 = (MurphyVarFaceLeft == 0 ? aniMurphyEatUpRight : aniMurphyEatUpLeft);
1186   PlayField16[*si] = 0x1E03;
1187   PlayField16[*si + FieldWidth] = 0x300;
1188   goto loc_StopNoSplit;
1189
1190   // ==========================================================================
1191   // RED DISK moving left to right
1192   // ==========================================================================
1193
1194 loc_g_6A1F:
1195   //  dx = aniMurphyEatRightRedDisk 'this sequence is 9 steps long!
1196   dx1 = aniMurphyEatRight;
1197   // --------------------------------------------------------------------------
1198   // BugFix
1199   // Table data_h_145A, pointed to by table data_h_105E, has a severe bug:
1200   // The Red Disk sequence is 8 pictures long, but 9 are displayed, because it
1201   // has 1 extra entry, which causes Murphy to end slightly shifted to the left!
1202   // We may not fix the table, because then the timing of the game changes
1203   // and several existing demo's do not run properly anymore.
1204   // We only correct Murphies x-location here, when the sequence starts.
1205   // Remember that this is not the real bug-fix, but we must live with
1206   // this existing bug and correct for the consequences of it.
1207
1208   if (AllowEatRightRedDiskBug == 0) // Murphy's screen x-position
1209     MurphyScreenXPos = MurphyScreenXPos - 2 * MurphyZoomFactor;
1210
1211   SeqPos = -1;
1212   // FS: for me this means to blit the first animation frame twice
1213   // end of BugFix
1214   // --------------------------------------------------------------------------
1215   PlayField16[*si] = 0x300; // !!!!!! this time we move murphy at sequence-start!
1216   PlayField16[*si + 1] = 0x1F03;
1217   *si = *si + 1;
1218   goto loc_StopNoSplit;
1219
1220   // ==========================================================================
1221   // RED DISK touching down to up
1222   // ==========================================================================
1223
1224 loc_g_6A48:
1225   dx1 = aniTouchRedDisk;
1226   MovHighByte(&PlayField16[*si], 0x20);
1227   MovHighByte(&PlayField16[*si - FieldWidth], 3);
1228   goto loc_StopNoSplit;
1229
1230   // ==========================================================================
1231   // RED DISK touching right to left
1232   // ==========================================================================
1233
1234 loc_g_6A64:
1235   dx1 = aniTouchRedDisk;
1236   MovHighByte(&PlayField16[*si], 0x21);
1237   MovHighByte(&PlayField16[*si - 1], 3);
1238   goto loc_StopNoSplit;
1239
1240   // ==========================================================================
1241   // RED DISK touching up to down
1242   // ==========================================================================
1243
1244 loc_g_6A80:
1245   dx1 = aniTouchRedDisk;
1246   MovHighByte(&PlayField16[*si], 0x22);
1247   MovHighByte(&PlayField16[*si + FieldWidth], 3);
1248   goto loc_StopNoSplit;
1249
1250   // ==========================================================================
1251   // RED DISK touching left to right
1252   // ==========================================================================
1253
1254 loc_g_6A9C:
1255   dx1 = aniTouchRedDisk;
1256   MovHighByte(&PlayField16[*si], 0x23);
1257   MovHighByte(&PlayField16[*si + 1], 3);
1258
1259 loc_StopNoSplit:
1260   MovingPictureSequencePhase = 0; // stop picture move sequence
1261   goto loc_NoSplit;
1262
1263   // ==========================================================================
1264   // YELLOW DISK moving down to up
1265   // ==========================================================================
1266
1267 loc_g_6AB8:
1268   if (PlayField16[*si - 2 * FieldWidth] != 0)
1269     return;
1270
1271   PlayField16[*si - 2 * FieldWidth] = 0x1200;
1272   dx1 = aniYellowDisk;
1273   dxPos = *si - FieldWidth;
1274   dx2 = (MurphyVarFaceLeft == 0 ? aniPushRight : aniPushLeft);
1275   dx2Step = FieldWidth;
1276   PlayField16[*si] = 0x2403;
1277   subCopyImageToScreen(*si, dx2);
1278   goto loc_MoveNoSplit;
1279
1280   // ==========================================================================
1281   // YELLOW DISK moving right to left
1282   // ==========================================================================
1283
1284 loc_g_6AF1:
1285   if (PlayField16[*si - 2] != 0)
1286     return;
1287
1288   PlayField16[*si - 2] = 0x1200;
1289   subCopyImageToScreen(*si, aniPushLeft);
1290   dx1 = aniYellowDisk;
1291   dxPos = *si - 1;
1292   dx2 = aniPushLeft;
1293   dx2Step = 1;
1294   PlayField16[*si] = 0x2503;
1295   goto loc_MoveNoSplit;
1296
1297   // ==========================================================================
1298   // YELLOW DISK moving up to down
1299   // ==========================================================================
1300
1301 loc_g_6B2A:
1302   if (PlayField16[*si + 2 * FieldWidth] != 0)
1303     return;
1304
1305   PlayField16[*si + 2 * FieldWidth] = 0x1200;
1306   dx1 = aniYellowDisk;
1307   dxPos = *si + FieldWidth;
1308   dx2 = (MurphyVarFaceLeft == 0 ? aniPushRight : aniPushLeft);
1309   dx2Step = -FieldWidth;
1310   PlayField16[*si] = 0x2703;
1311   subCopyImageToScreen(*si, dx2);
1312   goto loc_MoveNoSplit;
1313
1314   // ==========================================================================
1315   // YELLOW DISK moving left to right
1316   // ==========================================================================
1317
1318 loc_g_6B63:
1319   if (PlayField16[*si + 2] != 0)
1320     return;
1321
1322   PlayField16[*si + 2] = 0x1200;
1323   subCopyImageToScreen(*si, aniPushRight);
1324   dx1 = aniYellowDisk;
1325   dxPos = *si + 1;
1326   dx2 = aniPushRight;
1327   dx2Step = -1;
1328   PlayField16[*si] = 0x2603;
1329   goto loc_MoveNoSplit;
1330
1331   // ==========================================================================
1332   // ORANGE DISK moving right to left
1333   // ==========================================================================
1334
1335 loc_g_6B9B:
1336   if (PlayField16[*si - 2] != 0)
1337     return;
1338
1339   PlayField16[*si - 2] = 0x800;
1340   subCopyImageToScreen(*si, aniPushLeft);
1341   dx1 = aniOrangeDisk;
1342   dxPos = *si - 1;
1343   dx2 = aniPushLeft;
1344   dx2Step = 1;
1345   PlayField16[*si] = 0x2803;
1346   goto loc_MoveNoSplit;
1347
1348   // ==========================================================================
1349   // ORANGE DISK moving left to right
1350   // ==========================================================================
1351
1352 loc_g_6BD3:
1353   if (PlayField16[*si + 2] != 0)
1354     return;
1355
1356   if (PlayField16[*si + FieldWidth + 1] == 0) // falling goes before pushing
1357     return;
1358
1359   PlayField16[*si + 2] = 0x100;
1360   subCopyImageToScreen(*si, aniPushRight);
1361   dx1 = aniOrangeDisk;
1362   dxPos = *si + 1;
1363   dx2 = aniPushRight;
1364   dx2Step = -1;
1365   PlayField16[*si] = 0x2903;
1366   // ==========================================================================
1367   // Copy screen animation action table to action work space
1368   // (To paint sequence: Push Zonk/Disk / release red disk / Port passing)
1369   // ==========================================================================
1370
1371 loc_MoveNoSplit:
1372   MovingPictureSequencePhase = 8; // init picture move sequence
1373
1374 loc_NoSplit:
1375   SplitMoveFlag = 0; // no port: no split movement
1376
1377 loc_Split:
1378   //  copy/store global move sequence info????????????????????????????????????
1379   //  ... dont think so ...(FS)
1380   // ==========================================================================
1381   // Proceed with all movements
1382   // ==========================================================================
1383
1384 locProceedMovingMurphy: // proceed moving murphy
1385   YawnSleepCounter = 0; // Wake up sleeping Murphy
1386   ax = MovingPictureSequencePhase;            // sequence busy?
1387   if (ax == 0)             // no -- start sequence!
1388     goto loc_g_6C8F;
1389
1390   ax = ax - 1;   // next picture of sequence
1391   MovingPictureSequencePhase = ax;            // store for later
1392
1393   if (ax == 0) // Sound effects
1394   {
1395     switch (HighByte(PlayField16[*si]))
1396     {
1397       case 0xE:
1398       case 0xF:
1399         subSoundFX(*si, fiZonk, actPushing);
1400         break;
1401
1402       case 0x28:
1403       case 0x29:
1404         subSoundFX(*si, fiOrangeDisk, actPushing);
1405         break;
1406
1407       case 0x24:
1408       case 0x25:
1409       case 0x26:
1410       case 0x27:
1411         subSoundFX(*si, fiYellowDisk, actPushing);
1412         break;
1413
1414       default:
1415         break;
1416     }
1417   }
1418
1419   bl = HighByte(PlayField16[*si]);
1420   if (bl == 0xE)        // Push Zonk to left
1421     goto loc_g_6F7E;
1422
1423   if (bl == 0xF)        // Push Zonk to right
1424     goto loc_g_6FBC;
1425
1426   if (bl == 0x28)       // Push orange disk to left
1427     goto loc_g_6FFA;
1428
1429   if (bl == 0x29)       // Push orange disk to right
1430     goto loc_g_7038;
1431
1432   if (bl == 0x24)       // Push yellow disk up
1433     goto loc_g_7076;
1434
1435   if (bl == 0x25)       // Push yellow disk to left
1436     goto loc_g_70B4;
1437
1438   if (bl == 0x27)       // Push yellow disk down
1439     goto loc_g_70F2;
1440
1441   if (bl == 0x26)       // Push yellow disk to right
1442     goto loc_g_7130;
1443
1444   if (bl == 0x2A)       // Red disk release timer
1445     goto loc_g_716E;
1446
1447   return;
1448
1449   // ==========================================================================
1450   // Paint frame of MOVING.DAT sequence
1451   // ==========================================================================
1452
1453 loc_g_6C8F:
1454
1455   if (SeqPos <= 0)
1456     dx1SequenceLength = getSequenceLength(dx1);
1457
1458   if (SplitMoveFlag == 0)
1459   {
1460     // ++++++++++++++++++++++++++
1461     // Begin of normal movement
1462     MurphyScreenXPos = MurphyScreenXPos + MurphyDX * MurphyZoomFactor;
1463     MurphyScreenYPos = MurphyScreenYPos + MurphyDY * MurphyZoomFactor;
1464
1465     if (!(ClearPos < 0)) // clear field that murphy is leaving
1466       subCopyImageToScreen(ClearPos, aniSpace);
1467
1468     tDeltaX = MurphyDX * LocalStretch * (SeqPos + 1);
1469     tDeltaY = MurphyDY * LocalStretch * (SeqPos + 1);
1470
1471     X = GetStretchX(dxPos) + tDeltaX;
1472     Y = GetStretchY(dxPos) + tDeltaY;
1473     Tmp = (SeqPos < 0 ? 0 : SeqPos); // 9StepBugFix!(red disk move right)
1474
1475     if (isSnappingSequence(dx1) && SeqPos == dx1SequenceLength - 1)
1476       dx1 = aniSpace;
1477
1478     DDSpriteBuffer_BltImg(X, Y, dx1, Tmp);
1479     GfxGraphic[GetX(*si)][GetY(*si)] = -1;      // (Murphy's position)
1480     GfxGraphic[GetX(dxPos)][GetY(dxPos)] = -1;  // (snapping position)
1481
1482     if (!(dx2 < 0))
1483     {
1484       tPos = dxPos + dx2Step;
1485       X = GetStretchX(tPos);
1486       Y = GetStretchY(tPos);
1487
1488       // (SeqPos iterates from 0 to 7 while pushing)
1489       DDSpriteBuffer_BltImg(X + tDeltaX, Y + tDeltaY, dx2, SeqPos);
1490     }
1491
1492     // End of normal movement
1493     // ------------------------
1494   }
1495   else
1496   {
1497     // ++++++++++++++++++++++++++++++++
1498     // Begin of split movement (port)
1499     MurphyScreenXPos = MurphyScreenXPos + 2 * MurphyDX * MurphyZoomFactor;
1500     MurphyScreenYPos = MurphyScreenYPos + 2 * MurphyDY * MurphyZoomFactor;
1501     subCopyImageToScreen(ClearPos, aniSpace); // clear the field that murphy leaves
1502     tDeltaX = MurphyDX * LocalStretch * (SeqPos + 1);
1503     tDeltaY = MurphyDY * LocalStretch * (SeqPos + 1);
1504     X = GetStretchX(dxPos) + tDeltaX;
1505     Y = GetStretchY(dxPos) + tDeltaY;
1506     DDSpriteBuffer_BltImg(X, Y, dx1, SeqPos); // plot first murphy
1507
1508     tPos = dxPos + dx2Step;
1509     X = GetStretchX(tPos);
1510     Y = GetStretchY(tPos);
1511     DDSpriteBuffer_BltImg(X + tDeltaX, Y + tDeltaY, dx1, SeqPos); // plot second murphy
1512     DDSpriteBuffer_BltImg(X, Y, fiGraphic[LowByte(PlayField16[tPos])], 0); // replot the port on top
1513     // End of split movement (port)
1514     // ------------------------------
1515   } // loc_g_6D1E:'loc_g_6D28:
1516
1517   SeqPos = SeqPos + 1;
1518   if (SeqPos < dx1SequenceLength)
1519     return;
1520
1521   // Follow-up after movement completed     'loc_g_6D35:
1522   MurphyXPos = MurphyXPos + MurphyDX;
1523   MurphyYPos = MurphyYPos + MurphyDY;
1524   bl = HighByte(PlayField16[*si]);  // animation phase
1525   MovHighByte(&PlayField16[*si], 0);
1526
1527   if (bl == 0x1)    // space, moving up
1528     goto loc_g_6EC8;
1529
1530   if (bl == 0x2)    // space, moving left
1531     goto loc_g_6EE6;
1532
1533   if (bl == 0x3)    // space, moving down
1534     goto loc_g_6F04;
1535
1536   if (bl == 0x4)    // space, moving right
1537     goto loc_g_71C4;
1538
1539   if (bl == 0x5)    // base , moving up
1540     goto loc_g_6EC8;
1541
1542   if (bl == 0x6)    // base , moving left -> 6 is not used, value is set to 2 instead of 6!
1543     goto loc_g_6EE6;
1544
1545   if (bl == 0x7)    // base , moving down
1546     goto loc_g_6F04;
1547
1548   if (bl == 0x8)    // base , moving right
1549     goto loc_g_71C4;
1550
1551   if (bl == 0x9)    // infotron, moving up
1552     goto loc_g_6EBA;
1553
1554   if (bl == 0xA)      // infotron, moving left
1555     goto loc_g_6ED8;
1556
1557   if (bl == 0xB)    // infotron, moving down
1558     goto loc_g_6EF6;
1559
1560   if (bl == 0xC)      // infotron, moving right
1561     goto loc_g_71B6;
1562
1563   if (bl == 0xD)      // exit
1564     goto loc_g_6F77;
1565
1566   if (bl == 0xE)      // zonk, pushing left
1567     goto loc_g_6F18;
1568
1569   if (bl == 0xF)      // zonk, pushing right
1570     goto loc_g_6F3B;
1571
1572   if (bl == 0x10)   // base , touching up
1573     goto loc_g_71E2;
1574
1575   if (bl == 0x11)   // base , touching left
1576     goto loc_g_71FE;
1577
1578   if (bl == 0x12)   // base , touching down
1579     goto loc_g_721A;
1580
1581   if (bl == 0x13)   // base , touching right
1582     goto loc_g_7236;
1583
1584   if (bl == 0x14)   // infotron touching up
1585     goto loc_g_71D4;
1586
1587   if (bl == 0x15)   // infotron touching left
1588     goto loc_g_71F0;
1589
1590   if (bl == 0x16)   // infotron touching down
1591     goto loc_g_720C;
1592
1593   if (bl == 0x17)   // infotron touching right
1594     goto loc_g_7228;
1595
1596   if (bl == 0x18)     // port up
1597     goto loc_g_7244;
1598
1599   if (bl == 0x19)     // port left
1600     goto loc_g_7272;
1601
1602   if (bl == 0x1A)     // port down
1603     goto loc_g_729F;
1604
1605   if (bl == 0x1B)     // port right
1606     goto loc_g_72CD;
1607
1608   if (bl == 0x1C)   // red disk, moving up
1609     goto loc_g_72FA;
1610
1611   if (bl == 0x1D)   // red disk, moving left
1612     goto loc_g_7318;
1613
1614   if (bl == 0x1E)   // red disk, moving down
1615     goto loc_g_7333;
1616
1617   if (bl == 0x1F)   // red disk, moving right -> 9-Step-Bug!
1618     goto loc_g_7351;
1619
1620   if (bl == 0x20)   // red disk, touching up
1621     goto loc_g_736C;
1622
1623   if (bl == 0x21)   // red disk, touching left
1624     goto loc_g_7381;
1625
1626   if (bl == 0x22)   // red disk, touching down
1627     goto loc_g_7396;
1628
1629   if (bl == 0x23)   // red disk, touching right
1630     goto loc_g_73AB;
1631
1632   if (bl == 0x24)     // yellow disk, pushing up
1633     goto loc_g_73C0;
1634
1635   if (bl == 0x25)     // yellow disk, pushing left
1636     goto loc_g_73DD;
1637
1638   if (bl == 0x26)     // yellow disk, pushing right -> order of "down" exchanged with "right"!
1639     goto loc_g_7417;
1640
1641   if (bl == 0x27)     // yellow disk, pushing down  -> order of "down" exchanged with "right"!
1642     goto loc_g_73FA;
1643
1644   if (bl == 0x28)     // orange disk, pushing left
1645     goto loc_g_7434;
1646
1647   if (bl == 0x29)     // orange disk, pushing right
1648     goto loc_g_7451;
1649
1650   if (bl == 0x2A)   // red disk, release
1651     goto loc_g_747F;
1652
1653   ExitToMenuFlag = 1;
1654
1655   return;
1656
1657   // ==========================================================================
1658   //                       infotron, moving up
1659   // ==========================================================================
1660
1661 loc_g_6EBA:
1662   if (0 < LowByte(InfotronsNeeded))
1663     InfotronsNeeded = InfotronsNeeded - 1;
1664
1665 loc_g_6EC8: // space, base
1666   PlayField16[*si] = fiMurphy;
1667   subAdjustZonksInfotronsAboveMurphy(*si + FieldWidth);
1668
1669   return;
1670
1671   // ==========================================================================
1672   //                       infotron, moving left
1673   // ==========================================================================
1674
1675 loc_g_6ED8:
1676   if (0 < LowByte(InfotronsNeeded))
1677     InfotronsNeeded = InfotronsNeeded - 1;
1678
1679 loc_g_6EE6: // space, base
1680   PlayField16[*si] = fiMurphy;
1681   subAdjustZonksInfotronsAboveMurphy(*si + 1);
1682
1683   return;
1684
1685   // ==========================================================================
1686   //                       infotron, moving down
1687   // ==========================================================================
1688
1689 loc_g_6EF6:
1690   if (0 < LowByte(InfotronsNeeded))
1691     InfotronsNeeded = InfotronsNeeded - 1;
1692
1693 loc_g_6F04: // space, base
1694   if (LowByte(PlayField16[*si - FieldWidth]) != fiExplosion)
1695     PlayField16[*si - FieldWidth] = 0;
1696
1697   PlayField16[*si] = fiMurphy;
1698
1699   return;
1700
1701   // ==========================================================================
1702   //                       infotron, moving right
1703   // ==========================================================================
1704
1705 loc_g_71B6:
1706   if (0 < LowByte(InfotronsNeeded))
1707     InfotronsNeeded = InfotronsNeeded - 1;
1708
1709 loc_g_71C4: // space, base
1710   subAdjustZonksInfotronsAboveMurphy(*si - 1);
1711   PlayField16[*si] = fiMurphy;
1712
1713   return;
1714
1715   // ==========================================================================
1716   //                       infotron, touching up
1717   // ==========================================================================
1718
1719 loc_g_71D4:
1720   if (0 < LowByte(InfotronsNeeded))
1721     InfotronsNeeded = InfotronsNeeded - 1;
1722
1723 loc_g_71E2: // base
1724   if (LowByte(PlayField16[*si - FieldWidth]) != fiExplosion)
1725     PlayField16[*si - FieldWidth] = 0;
1726
1727   return;
1728
1729   // ==========================================================================
1730   //                       infotron, touching left
1731   // ==========================================================================
1732
1733 loc_g_71F0:
1734   if (0 < LowByte(InfotronsNeeded))
1735     InfotronsNeeded = InfotronsNeeded - 1;
1736
1737 loc_g_71FE: // base
1738   if (LowByte(PlayField16[*si - 1]) != fiExplosion)
1739     PlayField16[*si - 1] = 0;
1740
1741   return;
1742
1743   // ==========================================================================
1744   //                       infotron, touching down
1745   // ==========================================================================
1746
1747 loc_g_720C:
1748   if (0 < LowByte(InfotronsNeeded))
1749     InfotronsNeeded = InfotronsNeeded - 1;
1750
1751 loc_g_721A: // base
1752   if (LowByte(PlayField16[*si + FieldWidth]) != fiExplosion)
1753     PlayField16[*si + FieldWidth] = 0;
1754
1755   return;
1756
1757   // ==========================================================================
1758   //                       infotron, touching right
1759   // ==========================================================================
1760
1761 loc_g_7228:
1762   if (0 < LowByte(InfotronsNeeded))
1763     InfotronsNeeded = InfotronsNeeded - 1;
1764
1765 loc_g_7236: // base
1766   if (LowByte(PlayField16[*si + 1]) != fiExplosion)
1767     PlayField16[*si + 1] = 0;
1768
1769   return;
1770
1771   // ==========================================================================
1772   //                       zonk, pushing left
1773   // ==========================================================================
1774
1775 loc_g_6F18:
1776   if (LowByte(PlayField16[*si]) != fiExplosion)
1777     PlayField16[*si] = 0;
1778
1779   PlayField16[*si - 1] = fiMurphy;
1780   PlayField16[*si - 2] = fiZonk;
1781   subExplodeSnikSnaksBelow(*si - 2);
1782   *si = *si - 1;
1783
1784   return;
1785
1786   // ==========================================================================
1787   //                       zonk, pushing right
1788   // ==========================================================================
1789
1790 loc_g_6F3B:
1791   if (LowByte(PlayField16[*si]) != fiExplosion)
1792     PlayField16[*si] = 0;
1793
1794   PlayField16[*si + 1] = fiMurphy;
1795   PlayField16[*si + 2] = fiZonk;
1796   subExplodeSnikSnaksBelow(*si + 2);
1797   *si = *si + 1;
1798
1799   return;
1800
1801   // ==========================================================================
1802   //                       exit
1803   // ==========================================================================
1804
1805 loc_g_6F77:
1806   ExitToMenuFlag = 1;
1807
1808   PlayField16[*si] = fiSpace;   // remove Murphy from playfield after exiting
1809
1810   return;
1811
1812   // ==========================================================================
1813   //               Push Zonk from right to left
1814   // ==========================================================================
1815
1816 loc_g_6F7E:
1817   if (DemoKeyCode == keyLeft && PlayField16[*si - 1] == fiZonk)
1818     return;
1819
1820   PlayField16[*si] = fiMurphy; // else restore - no more zonk pushing!
1821   PlayField16[*si - 1] = fiZonk;
1822   if (LowByte(PlayField16[*si - 2]) != fiExplosion)
1823     PlayField16[*si - 2] = 0;
1824
1825   subCopyImageToScreen(*si, aniMurphy);
1826
1827   return;
1828
1829   // ==========================================================================
1830   //                       Push Zonk from left to right
1831   // ==========================================================================
1832
1833 loc_g_6FBC:
1834   if (DemoKeyCode == keyRight && PlayField16[*si + 1] == fiZonk)
1835     return;
1836
1837   PlayField16[*si] = fiMurphy; // else restore - no more zonk pushing!
1838   PlayField16[*si + 1] = fiZonk;
1839   if (LowByte(PlayField16[*si + 2]) != fiExplosion)
1840     PlayField16[*si + 2] = 0;
1841
1842   subCopyImageToScreen(*si, aniMurphy);
1843
1844   return;
1845
1846   // ==========================================================================
1847   //               Push orange disk from right to left
1848   // ==========================================================================
1849
1850 loc_g_6FFA:
1851   if (DemoKeyCode == keyLeft && PlayField16[*si - 1] == fiOrangeDisk)
1852     return;
1853
1854   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1855   PlayField16[*si - 1] = fiOrangeDisk;
1856   if (LowByte(PlayField16[*si - 2]) != fiExplosion)
1857     PlayField16[*si - 2] = 0;
1858
1859   subCopyImageToScreen(*si, aniMurphy);
1860
1861   return;
1862
1863   // ==========================================================================
1864   //               Push orange disk from left to right
1865   // ==========================================================================
1866
1867 loc_g_7038:
1868   if (DemoKeyCode == keyRight && PlayField16[*si + 1] == fiOrangeDisk)
1869     return;
1870
1871   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1872   PlayField16[*si + 1] = fiOrangeDisk;
1873   if (LowByte(PlayField16[*si + 2]) != fiExplosion)
1874     PlayField16[*si + 2] = 0;
1875
1876   subCopyImageToScreen(*si, aniMurphy);
1877
1878   return;
1879
1880   // ==========================================================================
1881   //               Push yellow disk from down to up
1882   // ==========================================================================
1883
1884 loc_g_7076:
1885   if (DemoKeyCode == keyUp && PlayField16[*si - FieldWidth] == fiYellowDisk)
1886     return;
1887
1888   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1889   PlayField16[*si - FieldWidth] = fiYellowDisk;
1890   if (LowByte(PlayField16[*si - 2 * FieldWidth]) != fiExplosion)
1891     PlayField16[*si - 2 * FieldWidth] = 0;
1892
1893   subCopyImageToScreen(*si, aniMurphy);
1894
1895   return;
1896
1897   // ==========================================================================
1898   //               Push yellow disk from right to left
1899   // ==========================================================================
1900
1901 loc_g_70B4:
1902   if (DemoKeyCode == keyLeft && PlayField16[*si - 1] == fiYellowDisk)
1903     return;
1904
1905   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1906   PlayField16[*si - 1] = fiYellowDisk;
1907   if (LowByte(PlayField16[*si - 2]) != fiExplosion)
1908     PlayField16[*si - 2] = 0;
1909
1910   subCopyImageToScreen(*si, aniMurphy);
1911
1912   return;
1913
1914   // ==========================================================================
1915   //               Push yellow disk from up to down
1916   // ==========================================================================
1917
1918 loc_g_70F2:
1919   if (DemoKeyCode == keyDown && PlayField16[*si + FieldWidth] == fiYellowDisk)
1920     return;
1921
1922   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1923   PlayField16[*si + FieldWidth] = fiYellowDisk;
1924   if (LowByte(PlayField16[*si + 2 * FieldWidth]) != fiExplosion)
1925     PlayField16[*si + 2 * FieldWidth] = 0;
1926
1927   subCopyImageToScreen(*si, aniMurphy);
1928
1929   return;
1930
1931   // ==========================================================================
1932   //               Push yellow disk from left to right
1933   // ==========================================================================
1934
1935 loc_g_7130:
1936   if (DemoKeyCode == keyRight && PlayField16[*si + 1] == fiYellowDisk)
1937     return;
1938
1939   PlayField16[*si] = fiMurphy; // else restore - no more pushing!
1940   PlayField16[*si + 1] = fiYellowDisk;
1941   if (LowByte(PlayField16[*si + 2]) != fiExplosion)
1942     PlayField16[*si + 2] = 0;
1943
1944   subCopyImageToScreen(*si, aniMurphy);
1945
1946   return;
1947
1948   // ==========================================================================
1949   //               time red disk release (space)
1950   // ==========================================================================
1951
1952 loc_g_716E:
1953   if (DemoKeyCode != keySpace)
1954   {
1955     PlayField16[*si] = fiMurphy;
1956     subCopyImageToScreen(*si, aniMurphy);
1957     RedDiskReleasePhase = 0;
1958   }
1959   else if (MovingPictureSequencePhase == 0x20)
1960   {
1961     // anxious murphy, dropping red disk
1962     subCopyImageToScreen(*si, aniMurphyDropping);
1963     RedDiskReleasePhase = 1;
1964   }
1965
1966   return;
1967
1968   // ==========================================================================
1969   // Special port down to up
1970   // ==========================================================================
1971
1972 loc_g_7244:
1973   if (LowByte(PlayField16[*si]) != fiExplosion)
1974     PlayField16[*si] = 0;
1975
1976   PlayField16[*si - 2 * FieldWidth] = fiMurphy;
1977   SplitMoveFlag = 0;
1978   *si = *si - FieldWidth;
1979   if (HighByte(PlayField16[*si]) == 1)
1980     subSpPortTest(*si);
1981
1982   *si = *si - FieldWidth;
1983
1984   return;
1985
1986   // ==========================================================================
1987   // Special port right to left
1988   // ==========================================================================
1989
1990 loc_g_7272:
1991   if (LowByte(PlayField16[*si]) != fiExplosion)
1992     PlayField16[*si] = 0;
1993
1994   PlayField16[*si - 2] = fiMurphy;
1995   SplitMoveFlag = 0;
1996   *si = *si - 1;
1997   if (HighByte(PlayField16[*si]) == 1)
1998     subSpPortTest(*si);
1999
2000   *si = *si - 1;
2001
2002   return;
2003
2004   // ==========================================================================
2005   // Special port up to down
2006   // ==========================================================================
2007
2008 loc_g_729F:
2009   if (LowByte(PlayField16[*si]) != fiExplosion)
2010     PlayField16[*si] = 0;
2011
2012   PlayField16[*si + 2 * FieldWidth] = fiMurphy;
2013   SplitMoveFlag = 0;
2014   *si = *si + FieldWidth;
2015   if (HighByte(PlayField16[*si]) == 1)
2016     subSpPortTest(*si);
2017
2018   *si = *si + FieldWidth;
2019
2020   return;
2021
2022   // ==========================================================================
2023   // Special port left to right
2024   // ==========================================================================
2025
2026 loc_g_72CD:
2027   if (LowByte(PlayField16[*si]) != fiExplosion)
2028     PlayField16[*si] = 0;
2029
2030   PlayField16[*si + 2] = fiMurphy;
2031   SplitMoveFlag = 0;
2032   *si = *si + 1;
2033   if (HighByte(PlayField16[*si]) == 1)
2034     subSpPortTest(*si);
2035
2036   *si = *si + 1;
2037
2038   return;
2039
2040   // ==========================================================================
2041   // Move Red Disk up
2042   // ==========================================================================
2043
2044 loc_g_72FA:
2045   if (LowByte(PlayField16[*si]) != fiExplosion)
2046     PlayField16[*si] = 0;
2047
2048   *si = *si - FieldWidth;
2049   PlayField16[*si] = fiMurphy;
2050   subEatRedDisk(*si); // inc+show Murphy's red disks
2051
2052   return;
2053
2054   // ==========================================================================
2055   // Move Red Disk left
2056   // ==========================================================================
2057
2058 loc_g_7318:
2059   if (LowByte(PlayField16[*si + 1]) != fiExplosion)
2060     PlayField16[*si + 1] = 0;
2061
2062   PlayField16[*si] = fiMurphy;
2063   subEatRedDisk(*si); // inc+show Murphy's red disks
2064
2065   return;
2066
2067   // ==========================================================================
2068   // Move Red Disk down
2069   // ==========================================================================
2070
2071 loc_g_7333:
2072   if (LowByte(PlayField16[*si]) != fiExplosion)
2073     PlayField16[*si] = 0;
2074
2075   *si = *si + FieldWidth;
2076   PlayField16[*si] = fiMurphy;
2077   subEatRedDisk(*si); // inc+show Murphy's red disks
2078
2079   return;
2080
2081   // ==========================================================================
2082   // Move Red Disk right
2083   // ==========================================================================
2084
2085 loc_g_7351:
2086   if (LowByte(PlayField16[*si - 1]) != fiExplosion)
2087     PlayField16[*si - 1] = 0;
2088
2089   PlayField16[*si] = fiMurphy;
2090   subEatRedDisk(*si); // inc+show Murphy's red disks
2091
2092   return;
2093
2094   // ==========================================================================
2095   // Eat Red Disk up
2096   // ==========================================================================
2097
2098 loc_g_736C:
2099   if (LowByte(PlayField16[*si - FieldWidth]) != fiExplosion)
2100     PlayField16[*si - FieldWidth] = 0;
2101
2102   subEatRedDisk(*si - FieldWidth); // inc+show Murphy's red disks
2103
2104   return;
2105
2106   // ==========================================================================
2107   // Eat Red Disk left
2108   // ==========================================================================
2109
2110 loc_g_7381:
2111   if (LowByte(PlayField16[*si - 1]) != fiExplosion)
2112     PlayField16[*si - 1] = 0;
2113
2114   subEatRedDisk(*si - 1); // inc+show Murphy's red disks
2115
2116   return;
2117
2118   // ==========================================================================
2119   // Eat Red Disk down
2120   // ==========================================================================
2121
2122 loc_g_7396:
2123   if (LowByte(PlayField16[*si + FieldWidth]) != fiExplosion)
2124     PlayField16[*si + FieldWidth] = 0;
2125
2126   subEatRedDisk(*si + FieldWidth); // inc+show Murphy's red disks
2127
2128   return;
2129
2130   // ==========================================================================
2131   // Eat Red Disk right
2132   // ==========================================================================
2133
2134 loc_g_73AB:
2135   if (LowByte(PlayField16[*si + 1]) != fiExplosion)
2136     PlayField16[*si + 1] = 0;
2137
2138   subEatRedDisk(*si + 1); // inc+show Murphy's red disks
2139
2140   return;
2141
2142   // ==========================================================================
2143   //                       yellow disk, pushing up
2144   // ==========================================================================
2145
2146 loc_g_73C0:
2147   if (LowByte(PlayField16[*si]) != fiExplosion)
2148     PlayField16[*si] = 0;
2149
2150   *si = *si - FieldWidth;
2151   PlayField16[*si] = fiMurphy;
2152   PlayField16[*si - FieldWidth] = fiYellowDisk;
2153
2154   return;
2155
2156   // ==========================================================================
2157   //                       yellow disk, pushing left
2158   // ==========================================================================
2159
2160 loc_g_73DD:
2161   if (LowByte(PlayField16[*si]) != fiExplosion)
2162     PlayField16[*si] = 0;
2163
2164   *si = *si - 1;
2165   PlayField16[*si] = fiMurphy;
2166   PlayField16[*si - 1] = fiYellowDisk;
2167
2168   return;
2169
2170   // ==========================================================================
2171   //                       yellow disk, pushing down
2172   // ==========================================================================
2173
2174 loc_g_73FA:
2175   if (LowByte(PlayField16[*si]) != fiExplosion)
2176     PlayField16[*si] = 0;
2177
2178   *si = *si + FieldWidth;
2179   PlayField16[*si] = fiMurphy;
2180   PlayField16[*si + FieldWidth] = fiYellowDisk;
2181
2182   return;
2183
2184   // ==========================================================================
2185   //                       yellow disk pushing right
2186   // ==========================================================================
2187
2188 loc_g_7417:
2189   if (LowByte(PlayField16[*si]) != fiExplosion)
2190     PlayField16[*si] = 0;
2191
2192   *si = *si + 1;
2193   PlayField16[*si] = fiMurphy;
2194   PlayField16[*si + 1] = fiYellowDisk;
2195
2196   return;
2197
2198   // ==========================================================================
2199   //                       orange disk, pushing left
2200   // ==========================================================================
2201
2202 loc_g_7434:
2203   if (LowByte(PlayField16[*si]) != fiExplosion)
2204     PlayField16[*si] = 0;
2205
2206   *si = *si - 1;
2207   PlayField16[*si] = fiMurphy;
2208   PlayField16[*si - 1] = fiOrangeDisk;
2209
2210   return;
2211
2212   // ==========================================================================
2213   //                       orange disk, pushing right
2214   // ==========================================================================
2215
2216 loc_g_7451:
2217   if (LowByte(PlayField16[*si]) != fiExplosion)
2218     PlayField16[*si] = 0;
2219
2220   *si = *si + 1;
2221   PlayField16[*si] = fiMurphy;
2222   PlayField16[*si + 1] = fiOrangeDisk;
2223   if (PlayField16[*si + FieldWidth + 1] == 0) // make it fall down if below is empty
2224   {
2225     MovHighByte(&PlayField16[*si + 1], 0x20);
2226     MovHighByte(&PlayField16[*si + FieldWidth + 1], fiOrangeDisk);
2227   }
2228
2229   return;
2230
2231   // ==========================================================================
2232   //                     Release a red disk
2233   // ==========================================================================
2234
2235 loc_g_747F:
2236   PlayField16[*si] = fiMurphy;
2237   RedDiskReleasePhase = 2;
2238   RedDiskCount = RedDiskCount - 1;
2239
2240   subSoundFX(*si, fiRedDisk, actDropping);
2241 } // subAnimateMurphy
2242
2243 // ==========================================================================
2244 //                              SUBROUTINE
2245 // ==========================================================================
2246 void subExplodeSnikSnaksBelow(int si)
2247 {
2248   int ax;
2249
2250   ax = LowByte(PlayField16[si + FieldWidth]);
2251   if (ax == 0x11 || ax == 0xBB)
2252     ExplodeFieldSP(si + FieldWidth);
2253 } // subExplodeSnikSnaksBelow
2254
2255 // ==========================================================================
2256 //                              SUBROUTINE
2257 // Does pushing against an object kill Murphy?
2258 // ==========================================================================
2259 static boolean subMoveKillsMurphy(int si, int ax, int bl)
2260 {
2261   static boolean subMoveKillsMurphy;
2262
2263   int al, ah;
2264
2265   al = LowByte(ax);
2266   ah = HighByte(ax);
2267   if (ax == 0xFFFF || ax == 0xAAAA || ah == 0)
2268     goto loc_g_752E;
2269
2270   if (al == fiZonk)
2271     goto loc_g_74E7;
2272
2273   if (al == fiExplosion)
2274     goto loc_g_7530;
2275
2276   if (fiOrangeDisk <= al && al <= fiPortUp)
2277     goto loc_g_752E;
2278
2279   ExplodeFieldSP(si);                 // Explode
2280   subMoveKillsMurphy = True;
2281   return subMoveKillsMurphy;
2282
2283 loc_g_74E7: // zonk
2284   if (bl == keyLeft)
2285     goto loc_g_74F6;
2286
2287   if (bl == keyRight)
2288     goto loc_g_7512;
2289
2290   ExplodeFieldSP(si);                 // Explode
2291   subMoveKillsMurphy = True;
2292   return subMoveKillsMurphy;
2293
2294 loc_g_74F6: // zonk left
2295   ah = ah & 0xF0;
2296   if (! (ah == 0x20 || ah == 0x40 || ah == 0x50 || ah == 0x70))
2297     ExplodeFieldSP(si);
2298
2299   subMoveKillsMurphy = True;                           // Set carry flag
2300   return subMoveKillsMurphy;
2301
2302 loc_g_7512: // zonk right
2303   ah = ah & 0xF0;
2304   if (! (ah == 0x30 || ah == 0x40 || ah == 0x60 || ah == 0x70))
2305     ExplodeFieldSP(si);
2306
2307 loc_g_752E: // Marked fields and Ports
2308   subMoveKillsMurphy = True;                           // Set carry flag
2309   return subMoveKillsMurphy;
2310
2311 loc_g_7530: // explosion
2312   if ((ah & 0x80) != 0)
2313     goto loc_g_753A;
2314
2315   if (ah >= 4)
2316     goto loc_g_753F;
2317
2318 loc_g_753A:
2319   ExplodeFieldSP(si);                 // Explode
2320   subMoveKillsMurphy = True;                           // Set carry flag
2321   return subMoveKillsMurphy;
2322
2323 loc_g_753F:
2324   PlayField16[si] = 0;
2325   subMoveKillsMurphy = False;
2326
2327   return subMoveKillsMurphy;
2328 } // subMoveKillsMurphy
2329
2330 // ==========================================================================
2331 //                              SUBROUTINE
2332 // Test If si 's a special (grav) port and If so Then fetch new values (see below)
2333 // change conditions to port specs
2334 // The 10-port data base is at data_h_0D28, 10 entries of 6 bytes each:
2335 // (hi),(lo),(gravity),(freeze zonks),(freeze enemies),(unused)
2336 // ==========================================================================
2337
2338 void subSpPortTest(int si)
2339 {
2340   int i;
2341
2342   for (i = 0; i < LInfo.SpecialPortCount; i++)
2343   {
2344     if (LInfo.SpecialPort[i].PortLocation / 2 == si)
2345     {
2346       GravityFlag              = LInfo.SpecialPort[i].Gravity;
2347       FreezeZonks              = LInfo.SpecialPort[i].FreezeZonks;
2348       SnikSnaksElectronsFrozen = LInfo.SpecialPort[i].FreezeEnemies;
2349
2350       break;
2351     }
2352   }
2353 }
2354
2355 void subCopyAnimToScreen(int si, int graphic, int sync_frame)
2356 {
2357   int X, Y;
2358
2359   // +++++++++++++++++++++++++++++++++++++++++
2360   X = GetStretchX(si);
2361   Y = GetStretchY(si);
2362   DDSpriteBuffer_BltImg(X, Y, graphic, sync_frame);
2363   // +++++++++++++++++++++++++++++++++++++++++
2364 }
2365
2366 void subCopyImageToScreen(int si, int graphic)
2367 {
2368   subCopyAnimToScreen(si, graphic, 0);
2369 }
2370
2371 static void subEatRedDisk(int si)
2372 {
2373   if (AllowRedDiskCheat == 0)
2374   {
2375     if (RedDiskReleasePhase != 0)
2376     {
2377       if (RedDiskReleaseMurphyPos == si)
2378         return;
2379     }
2380   }
2381
2382   RedDiskCount = (RedDiskCount + 1) % 256;
2383 }
2384
2385 void subAdjustZonksInfotronsAboveMurphy(int si)
2386 {
2387   int ax;
2388
2389   if (LowByte(PlayField16[si]) != fiExplosion)
2390     PlayField16[si] = 0;
2391
2392   ax = PlayField16[si - FieldWidth];
2393   if (ax == 0 || ax == 0x9999)
2394     goto loc_g_15A8;
2395
2396   if (ax == fiZonk || ax == fiInfotron)
2397   {
2398     MovHighByte(&PlayField16[si - FieldWidth], 0x40); // make falling straigt down
2399   }
2400
2401   return;
2402
2403 loc_g_15A8: // empty above
2404   ax = PlayField16[si - FieldWidth - 1];
2405   if (ax == fiZonk || ax == fiInfotron)
2406     goto loc_g_15C5;
2407
2408 loc_g_15B6:
2409   ax = PlayField16[si - FieldWidth + 1];
2410   if (ax == fiZonk || ax == fiInfotron)
2411     goto loc_g_15E8;
2412
2413   return;
2414
2415 loc_g_15C5: // zonk/infotron above left
2416   ax = PlayField16[si - 1];
2417   if (! (ax == fiZonk || ax == fiInfotron || ax == fiRAM)) // continue testing right above
2418     goto loc_g_15B6;
2419
2420   MovHighByte(&PlayField16[si - FieldWidth - 1], 0x60); // make roll right
2421   PlayField16[si - FieldWidth] = 0x8888;
2422
2423   return;
2424
2425 loc_g_15E8: // zonk/infotron above right
2426   ax = PlayField16[si + 1];
2427   if (ax == fiZonk || ax == fiInfotron || ax == fiRAM)
2428   {
2429     MovHighByte(&PlayField16[si - FieldWidth + 1], 0x50); // make roll left
2430     PlayField16[si - FieldWidth] = 0x8888;
2431   }
2432 }