X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fgame_sp%2FSnikSnaks.c;h=a03e332e1754ba4f0b3362d8ae5a4da6c10e8489;hp=5053b3639d6caffdef62664f32056ae2af6edb10;hb=3ff2e8a0b5c27b99a9920bdf5ed82bc41bf40181;hpb=20a30378bfde4264628619380057730df6887972

diff --git a/src/game_sp/SnikSnaks.c b/src/game_sp/SnikSnaks.c
index 5053b363..a03e332e 100644
--- a/src/game_sp/SnikSnaks.c
+++ b/src/game_sp/SnikSnaks.c
@@ -4,18 +4,19 @@
 
 #include "SnikSnaks.h"
 
-static int subDrawSnikSnakFromAbove(int si, int bx);
-static int subDrawSnikSnakFromBelow(int si, int bx);
-static int subDrawSnikSnakFromLeft(int si, int bx);
-static int subDrawSnikSnakFromRight(int si, int bx);
-static int subDrawSnikSnakTurnLeft(int si, int bx);
-static int subDrawSnikSnakTurnRight(int si, int bx);
-static int subSnikSnakFromAbove(int si, int bx);
-static int subSnikSnakFromBelow(int si, int bx);
-static int subSnikSnakFromLeft(int si, int bx);
-static int subSnikSnakFromRight(int si, int bx);
-static int subSnikSnakTurnLeft(int si, int bx);
-static int subSnikSnakTurnRight(int si, int bx);
+
+static void subDrawSnikSnakFromAbove(int, int);
+static void subDrawSnikSnakFromBelow(int, int);
+static void subDrawSnikSnakFromLeft(int, int);
+static void subDrawSnikSnakFromRight(int, int);
+static void subDrawSnikSnakTurnLeft(int, int);
+static void subDrawSnikSnakTurnRight(int, int);
+static void subSnikSnakFromAbove(int, int);
+static void subSnikSnakFromBelow(int, int);
+static void subSnikSnakFromLeft(int, int);
+static void subSnikSnakFromRight(int, int);
+static void subSnikSnakTurnLeft(int, int);
+static void subSnikSnakTurnRight(int, int);
 
 // static char *VB_Name = "modSnikSnak";
 
@@ -25,23 +26,20 @@ static int subSnikSnakTurnRight(int si, int bx);
 // Animate/move Snik-Snaks
 // ==========================================================================
 
-int subAnimateSnikSnaks(int si)
+void subAnimateSnikSnaks(int si)
 {
-  int subAnimateSnikSnaks;
-
   int bx, Tmp;
 
   if (SnikSnaksElectronsFrozen == 1)
-    return subAnimateSnikSnaks;
+    return;
 
-#if 1
   /* (not sure why this was removed -- this broke several level solutions) */
   if (LowByte(PlayField16[si]) != fiSnikSnak)
-    return subAnimateSnikSnaks;
-#endif
+    return;
 
-  //  If LowByte(PlayField16(si)) <> fiSnikSnak Then Exit Function
+  // If LowByte(PlayField16(si)) <> fiSnikSnak Then Exit Function
   // Debug.Assert (LowByte(PlayField16[si]) == fiSnikSnak);
+
   bx = HighByte(PlayField16[si]);
   Tmp = bx / 8;
   switch (Tmp)
@@ -74,19 +72,16 @@ int subAnimateSnikSnaks(int si)
       // Debug.Assert(False);
       break;
   }
+}
 
-  return subAnimateSnikSnaks;
-} // subAnimateSnikSnaks
-
-int subDrawAnimatedSnikSnaks(int si)
+void subDrawAnimatedSnikSnaks(int si)
 {
-  int subDrawAnimatedSnikSnaks;
-
   int bx, Tmp;
 
   // If SnikSnaksElectronsFrozen = 1 Then Exit Function
+
   if (LowByte(PlayField16[si]) != fiSnikSnak)
-    return subDrawAnimatedSnikSnaks;
+    return;
 
   bx = HighByte(PlayField16[si]);
   Tmp = bx / 8;
@@ -116,15 +111,10 @@ int subDrawAnimatedSnikSnaks(int si)
       subDrawSnikSnakFromLeft(si, bx); // access si from left
       break;
   }
+}
 
-  return subDrawAnimatedSnikSnaks;
-} // subAnimateSnikSnaks
-
-static int subSnikSnakTurnLeft(int si, int bx)
+static void subSnikSnakTurnLeft(int si, int bx)
 {
-  static int subSnikSnakTurnLeft;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, ah, bl;
 
   ax = (TimerVar & 3);
@@ -133,39 +123,35 @@ static int subSnikSnakTurnLeft(int si, int bx)
     if (ax == 3)
       goto loc_g_7622;
 
-    return subSnikSnakTurnLeft;
+    return;
   } // loc_g_75E0:
 
-#if 1
-  subDrawSnikSnakTurnLeft(si, bx);
-#else
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, aniFramesSnikSnak[bx]);
+  subDrawSnikSnakTurnLeft(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
 
   bx = (bx + 1) & 0x7;
   MovHighByte(&PlayField16[si], bx);
-  return subSnikSnakTurnLeft;
+
+  return;
 
 locMayExplode760A:
   ah = HighByte(ax);
   if (ah == 0x1B)
-    return subSnikSnakTurnLeft;
+    return;
 
   if (ah == 0x19)
-    return subSnikSnakTurnLeft;
+    return;
 
   if (ah == 0x18)
-    return subSnikSnakTurnLeft;
+    return;
 
   if (ah == 0x1A)
-    return subSnikSnakTurnLeft;
+    return;
 
   ExplodeFieldSP(si); // Explode
-  return subSnikSnakTurnLeft;
+
+  return;
 
 loc_g_7622:
   bl = HighByte(PlayField16[si]);
@@ -181,7 +167,7 @@ loc_g_7622:
   if (bl == 6)
     goto loc_g_76A7;
 
-  return subSnikSnakTurnLeft;
+  return;
 
 loc_g_763B: // pointing up
   ax = PlayField16[si - FieldWidth];
@@ -191,13 +177,14 @@ loc_g_763B: // pointing up
   if (LowByte(ax) == fiMurphy) // above is murphy -> explode
     goto locMayExplode760A;
 
-  return subSnikSnakTurnLeft;
+  return;
 
 loc_g_764E: // above is empty -> go up
   PlayField16[si] = 0x1BB;
   si = si - FieldWidth;
   PlayField16[si] = 0x1011;
-  return subSnikSnakTurnLeft;
+
+  return;
 
 loc_g_765E: // pointing left
   ax = PlayField16[si - 1];
@@ -207,13 +194,14 @@ loc_g_765E: // pointing left
   if (LowByte(ax) == fiMurphy) // left is murphy -> explode
     goto locMayExplode760A;
 
-  return subSnikSnakTurnLeft;
+  return;
 
 loc_g_7671: // left is empty -> go there
   PlayField16[si] = 0x2BB;
   si = si - 1;
   PlayField16[si] = 0x1811;
-  return subSnikSnakTurnLeft;
+
+  return;
 
 loc_g_7681: // pointing down
   ax = PlayField16[si + FieldWidth];
@@ -223,13 +211,14 @@ loc_g_7681: // pointing down
   if (LowByte(ax) == fiMurphy) // below is murphy -> explode
     goto locMayExplode760A;
 
-  return subSnikSnakTurnLeft;
+  return;
 
 loc_g_7697: // below is empty -> go down
   PlayField16[si] = 0x3BB;
   si = si + FieldWidth;
   PlayField16[si] = 0x2011;
-  return subSnikSnakTurnLeft;
+
+  return;
 
 loc_g_76A7: // pointing Right
   ax = PlayField16[si + 1];
@@ -239,21 +228,16 @@ loc_g_76A7: // pointing Right
   if (LowByte(ax) == fiMurphy) // right is murphy -> explode
     goto locMayExplode760A;
 
-  return subSnikSnakTurnLeft;
+  return;
 
 loc_g_76BD: // right is empty -> go there
   PlayField16[si] = 0x4BB;
   si = si + 1;
   PlayField16[si] = 0x2811;
+}
 
-  return subSnikSnakTurnLeft;
-} // subSnikSnakTurnLeft
-
-static int subSnikSnakTurnRight(int si, int bx)
+static void subSnikSnakTurnRight(int si, int bx)
 {
-  static int subSnikSnakTurnRight;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, ah, bl;
 
   ax = (TimerVar & 3);
@@ -262,39 +246,35 @@ static int subSnikSnakTurnRight(int si, int bx)
     if (ax == 3)
       goto loc_g_771F;
 
-    return subSnikSnakTurnRight;
+    return;
   } // loc_g_76DB:
 
-#if 1
-  subDrawSnikSnakTurnRight(si, bx);
-#else
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, aniFramesSnikSnak[0x10 - bx]);
+  subDrawSnikSnakTurnRight(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
 
   bx = ((bx + 1) & 0x7) | 8;
   MovHighByte(&PlayField16[si], bx);
-  return subSnikSnakTurnRight;
+
+  return;
 
 locMayExplode7707:
   ah = HighByte(ax);
   if (ah == 0x1B)
-    return subSnikSnakTurnRight;
+    return;
 
   if (ah == 0x19)
-    return subSnikSnakTurnRight;
+    return;
 
   if (ah == 0x18)
-    return subSnikSnakTurnRight;
+    return;
 
   if (ah == 0x1A)
-    return subSnikSnakTurnRight;
+    return;
 
   ExplodeFieldSP(si); // Explode
-  return subSnikSnakTurnRight;
+
+  return;
 
 loc_g_771F:
   bl = HighByte(PlayField16[si]);
@@ -310,7 +290,7 @@ loc_g_771F:
   if (bl == 0xE)
     goto loc_g_775B;
 
-  return subSnikSnakTurnRight;
+  return;
 
 loc_g_7738: // pointing up
   ax = PlayField16[si - FieldWidth];
@@ -320,13 +300,14 @@ loc_g_7738: // pointing up
   if (LowByte(ax) == fiMurphy) // above is murphy -> explode
     goto locMayExplode7707;
 
-  return subSnikSnakTurnRight;
+  return;
 
 loc_g_774B: // above is empty -> go up
   PlayField16[si] = 0x1BB;
   si = si - FieldWidth;
   PlayField16[si] = 0x1011;
-  return subSnikSnakTurnRight;
+
+  return;
 
 loc_g_775B: // pointing left
   ax = PlayField16[si - 1];
@@ -336,13 +317,14 @@ loc_g_775B: // pointing left
   if (LowByte(ax) == fiMurphy) // left is murphy -> explode
     goto locMayExplode7707;
 
-  return subSnikSnakTurnRight;
+  return;
 
 loc_g_776E: // left is empty -> go there
   PlayField16[si] = 0x2BB;
   si = si - 1;
   PlayField16[si] = 0x1811;
-  return subSnikSnakTurnRight;
+
+  return;
 
 loc_g_777E: // pointing down
   ax = PlayField16[si + FieldWidth];
@@ -352,13 +334,14 @@ loc_g_777E: // pointing down
   if (LowByte(ax) == fiMurphy) // below is murphy -> explode
     goto locMayExplode7707;
 
-  return subSnikSnakTurnRight;
+  return;
 
 loc_g_7794: // below is empty -> go down
   PlayField16[si] = 0x3BB;
   si = si + FieldWidth;
   PlayField16[si] = 0x2011;
-  return subSnikSnakTurnRight;
+
+  return;
 
 loc_g_77A4: // pointing Right
   ax = PlayField16[si + 1];
@@ -368,35 +351,22 @@ loc_g_77A4: // pointing Right
   if (LowByte(ax) == fiMurphy) // right is murphy -> explode
     goto locMayExplode7707;
 
-  return subSnikSnakTurnRight;
+  return;
 
 loc_g_77BA: // right is empty -> go there
   PlayField16[si] = 0x4BB;
   si = si + 1;
   PlayField16[si] = 0x2811;
+}
 
-  return subSnikSnakTurnRight;
-} // subSnikSnakTurnRight
-
-static int subSnikSnakFromBelow(int si, int bx)
+static void subSnikSnakFromBelow(int si, int bx)
 {
-  static int subSnikSnakFromBelow;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, bl;
 
-#if 1
-  subDrawSnikSnakFromBelow(si, bx);
-  bx = bx - 0xF;  // get and increment sequence#
-#else
-  bx = bx - 0xF;  // get and increment sequence#
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si + FieldWidth);
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniSnikSnakUp + bx);
+  subDrawSnikSnakFromBelow(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
+  bx = bx - 0xF;  // get and increment sequence#
 
   bl = LowByte(bx);
   if (bl == 7 && LowByte(PlayField16[si + FieldWidth]) != fiExplosion)
@@ -408,7 +378,8 @@ static int subSnikSnakFromBelow(int si, int bx)
   {
     bl = bl + 0x10;
     MovHighByte(&PlayField16[si], bl);
-    return subSnikSnakFromBelow;
+
+    return;
   } // loc_g_7813
 
   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
@@ -416,7 +387,8 @@ static int subSnikSnakFromBelow(int si, int bx)
   if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
   {
     MovHighByte(&PlayField16[si], 1); // start to turn left
-    return subSnikSnakFromBelow;
+
+    return;
   } // loc_g_7826: and 'loc_g_7833:
 
   ax = PlayField16[si - FieldWidth]; // cannot turn left -> check above
@@ -425,47 +397,37 @@ static int subSnikSnakFromBelow(int si, int bx)
     PlayField16[si] = 0x1BB; // mark as "sniksnak leaving"
     si = si - FieldWidth; // go up!
     PlayField16[si] = 0x1011;
-    return subSnikSnakFromBelow;
+
+    return;
   } // loc_g_784A:
 
   if (LowByte(ax) == fiMurphy) // check for murphy above
   {
     ExplodeFieldSP(si); // Explode
-    return subSnikSnakFromBelow;
+
+    return;
   } // loc_g_7855:
 
   ax = PlayField16[si + 1]; // check right field
   if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
   {
     MovHighByte(&PlayField16[si], 9); // start to turn right
-    return subSnikSnakFromBelow;
+
+    return;
   } // loc_g_7862: and 'loc_g_786F:
 
   // else: no way to go, start turning around
   MovHighByte(&PlayField16[si], 1);
+}
 
-  return subSnikSnakFromBelow;
-} // subSnikSnakFromBelow
-
-static int subSnikSnakFromRight(int si, int bx)
+static void subSnikSnakFromRight(int si, int bx)
 {
-  static int subSnikSnakFromRight;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, bl;
 
-#if 1
-  subDrawSnikSnakFromRight(si, bx);
-  bx = bx - 0x17;  // get and increment sequence#
-#else
-  bx = bx - 0x17;  // get and increment sequence#
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si + 1);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniSnikSnakLeft + bx);
+  subDrawSnikSnakFromRight(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
+  bx = bx - 0x17;  // get and increment sequence#
 
   bl = LowByte(bx);
   if (bl == 7 && LowByte(PlayField16[si + 1]) != fiExplosion)
@@ -477,7 +439,8 @@ static int subSnikSnakFromRight(int si, int bx)
   {
     bl = bl + 0x18;
     MovHighByte(&PlayField16[si], bl);
-    return subSnikSnakFromRight;
+
+    return;
   } // loc_g_78B9:
 
   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
@@ -485,7 +448,8 @@ static int subSnikSnakFromRight(int si, int bx)
   if (ax == 0 || LowByte(ax) == fiMurphy) // empty or murphy?
   {
     MovHighByte(&PlayField16[si], 3); // yes -> turn left down
-    return subSnikSnakFromRight;
+
+    return;
   } // loc_g_78CC: and 'loc_g_78D9:
 
   ax = PlayField16[si - 1]; // check left, etc ... see the comments on subSnikSnakFromBelow()
@@ -494,46 +458,36 @@ static int subSnikSnakFromRight(int si, int bx)
     PlayField16[si] = 0x2BB;
     si = si - 1;                // 1 field left
     PlayField16[si] = 0x1811;
-    return subSnikSnakFromRight;
+
+    return;
   } // loc_g_78F0:
 
   if (LowByte(ax) == fiMurphy)
   {
     ExplodeFieldSP(si);      // Explode
-    return subSnikSnakFromRight;
+
+    return;
   } // loc_g_78FB:
 
   ax = PlayField16[si - FieldWidth]; // check above
   if (ax == 0 || LowByte(ax) == fiMurphy)
   {
     MovHighByte(&PlayField16[si], 0xF);
-    return subSnikSnakFromRight;
+
+    return;
   } // loc_g_7908:loc_g_7915:
 
   MovHighByte(&PlayField16[si], 3);
+}
 
-  return subSnikSnakFromRight;
-} // subSnikSnakFromRight
-
-static int subSnikSnakFromAbove(int si, int bx)
+static void subSnikSnakFromAbove(int si, int bx)
 {
-  static int subSnikSnakFromAbove;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, bl;
 
-#if 1
-  subDrawSnikSnakFromAbove(si, bx);
-  bx = bx - 0x1F;  // get and increment sequence#
-#else
-  bx = bx - 0x1F;  // get and increment sequence#
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si - FieldWidth);
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniSnikSnakDown + bx);
+  subDrawSnikSnakFromAbove(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
+  bx = bx - 0x1F;  // get and increment sequence#
 
   bl = LowByte(bx);
   if (bl == 7 && LowByte(PlayField16[si - FieldWidth]) != fiExplosion)
@@ -545,7 +499,8 @@ static int subSnikSnakFromAbove(int si, int bx)
   {
     bl = bl + 0x20;
     MovHighByte(&PlayField16[si], bl);
-    return subSnikSnakFromAbove;
+
+    return;
   } // loc_g_7813
 
   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
@@ -553,7 +508,8 @@ static int subSnikSnakFromAbove(int si, int bx)
   if (ax == 0 || LowByte(ax) == fiMurphy)
   {
     MovHighByte(&PlayField16[si], 5);
-    return subSnikSnakFromAbove;
+
+    return;
   } // loc_g_7986:
 
   ax = PlayField16[si + FieldWidth]; // check below
@@ -562,46 +518,36 @@ static int subSnikSnakFromAbove(int si, int bx)
     PlayField16[si] = 0x3BB;
     si = si + FieldWidth;                 // 1 field down
     PlayField16[si] = 0x2011;
-    return subSnikSnakFromAbove;
+
+    return;
   } // loc_g_799D:
 
   if (LowByte(ax) == fiMurphy)
   {
     ExplodeFieldSP(si);        // Explode
-    return subSnikSnakFromAbove;
+
+    return;
   } // loc_g_79A8:
 
   ax = PlayField16[si - 1]; // check left
   if (ax == 0 || LowByte(ax) == fiMurphy)
   {
     MovHighByte(&PlayField16[si], 0xD);
-    return subSnikSnakFromAbove;
+
+    return;
   } // loc_g_79C2:
 
   MovHighByte(&PlayField16[si], 5);
+}
 
-  return subSnikSnakFromAbove;
-} // subSnikSnakFromAbove
-
-static int subSnikSnakFromLeft(int si, int bx)
+static void subSnikSnakFromLeft(int si, int bx)
 {
-  static int subSnikSnakFromLeft;
-
-  // int ax, ah, bl, dx, X, Y;
   int ax, bl;
 
-#if 1
-  subDrawSnikSnakFromLeft(si, bx);
-  bx = bx - 0x27;  // get and increment sequence#
-#else
-  bx = bx - 0x27;  // get and increment sequence#
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si - 1);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniSnikSnakRight + bx);
+  subDrawSnikSnakFromLeft(si, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
+  bx = bx - 0x27;  // get and increment sequence#
 
   bl = LowByte(bx);
   if (bl == 7 && LowByte(PlayField16[si - 1]) != fiExplosion)
@@ -613,7 +559,8 @@ static int subSnikSnakFromLeft(int si, int bx)
   {
     bl = bl + 0x28;
     MovHighByte(&PlayField16[si], bl);
-    return subSnikSnakFromLeft;
+
+    return;
   } // loc_g_78B9:
 
   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
@@ -621,7 +568,8 @@ static int subSnikSnakFromLeft(int si, int bx)
   if (ax == 0 || LowByte(ax) == fiMurphy)
   {
     MovHighByte(&PlayField16[si], 7);
-    return subSnikSnakFromLeft;
+
+    return;
   } // loc_g_7A2D:
 
   ax = PlayField16[si + 1]; // check right(straight on)
@@ -630,155 +578,98 @@ static int subSnikSnakFromLeft(int si, int bx)
     PlayField16[si] = 0x4BB;
     si = si + 1;                   // 1 field right
     PlayField16[si] = 0x2811;
-    return subSnikSnakFromLeft;
+
+    return;
   } // loc_g_7A44:
 
   if (LowByte(ax) == fiMurphy)
   {
     ExplodeFieldSP(si);    // Explode
-    return subSnikSnakFromLeft;
+
+    return;
   } // loc_g_7A4F:
 
   ax = PlayField16[si + FieldWidth]; // check below
   if (ax == 0 || LowByte(ax) == fiMurphy)
   {
     MovHighByte(&PlayField16[si], 0xB);
-    return subSnikSnakFromLeft;
+
+    return;
   } // loc_g_7A69:
 
   MovHighByte(&PlayField16[si], 7);
+}
 
-  return subSnikSnakFromLeft;
-} // subSnikSnakFromLeft
-
-static int subDrawSnikSnakTurnLeft(int si, int bx)
+static void subDrawSnikSnakTurnLeft(int si, int bx)
 {
-  static int subDrawSnikSnakTurnLeft;
-
-#if 1
-  // int pos = bx / 2;
   int pos = ((bx + 7) % 8) / 2;
 
-  GfxGraphic[GetX(si)][GetY(si)] = aniSnikSnakTurningLeft[pos];
-#else
-  int X, Y;
-
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, aniFramesSnikSnak[bx]);
+  GfxGraphic[GetX(si)][GetY(si)] = aniSnikSnakTurningLeft[pos];
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
-
-  return subDrawSnikSnakTurnLeft;
 }
 
-static int subDrawSnikSnakTurnRight(int si, int bx)
+static void subDrawSnikSnakTurnRight(int si, int bx)
 {
-  static int subDrawSnikSnakTurnRight;
-
-#if 1
-  // int pos = (bx - 8) / 2;
   int pos = ((bx - 1) % 8) / 2;
 
-  GfxGraphic[GetX(si)][GetY(si)] = aniSnikSnakTurningRight[pos];
-#else
-  int X, Y;
-
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-  X = GetStretchX(si);
-  Y = GetStretchY(si);
-  StretchedSprites.BltEx(X, Y, aniFramesSnikSnak[0x10 - bx]);
+  GfxGraphic[GetX(si)][GetY(si)] = aniSnikSnakTurningRight[pos];
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-#endif
-
-  return subDrawSnikSnakTurnRight;
 }
 
-static int subDrawSnikSnakFromBelow(int si, int bx)
+static void subDrawSnikSnakFromBelow(int si, int bx)
 {
-  static int subDrawSnikSnakFromBelow;
-
   int X, Y;
 
   bx = bx - 0xF; // get and anti-increment sequence#
+
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
   X = GetStretchX(si);
   Y = GetStretchY(si + FieldWidth);
-#if 1
-  StretchedSprites.BltImg(X, Y, aniSpace, 0);
-  StretchedSprites.BltImg(X, Y - bx * TwoPixels, aniSnikSnakUp, bx);
-#else
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniSnikSnakUp + bx);
-#endif
+  DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
+  DDSpriteBuffer_BltImg(X, Y - bx * TwoPixels, aniSnikSnakUp, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  return subDrawSnikSnakFromBelow;
 }
 
-static int subDrawSnikSnakFromRight(int si, int bx)
+static void subDrawSnikSnakFromRight(int si, int bx)
 {
-  static int subDrawSnikSnakFromRight;
-
   int X, Y;
 
   bx = bx - 0x17; // get and increment sequence#
+
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
   X = GetStretchX(si + 1);
   Y = GetStretchY(si);
-#if 1
-  StretchedSprites.BltImg(X, Y, aniSpace, 0);
-  StretchedSprites.BltImg(X - bx * TwoPixels, Y, aniSnikSnakLeft, bx);
-#else
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniSnikSnakLeft + bx);
-#endif
+  DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
+  DDSpriteBuffer_BltImg(X - bx * TwoPixels, Y, aniSnikSnakLeft, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  return subDrawSnikSnakFromRight;
 }
 
-static int subDrawSnikSnakFromAbove(int si, int bx)
+static void subDrawSnikSnakFromAbove(int si, int bx)
 {
-  static int subDrawSnikSnakFromAbove;
-
   int X, Y;
 
   bx = bx - 0x1F; // get and increment sequence#
+
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
   X = GetStretchX(si);
   Y = GetStretchY(si - FieldWidth);
-#if 1
-  StretchedSprites.BltImg(X, Y, aniSpace, 0);
-  StretchedSprites.BltImg(X, Y + bx * TwoPixels, aniSnikSnakDown, bx);
-#else
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniSnikSnakDown + bx);
-#endif
+  DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
+  DDSpriteBuffer_BltImg(X, Y + bx * TwoPixels, aniSnikSnakDown, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  return subDrawSnikSnakFromAbove;
 }
 
-static int subDrawSnikSnakFromLeft(int si, int bx)
+static void subDrawSnikSnakFromLeft(int si, int bx)
 {
-  static int subDrawSnikSnakFromLeft;
-
   int X, Y;
 
   bx = bx - 0x27; // get and increment sequence#
+
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
   X = GetStretchX(si - 1);
   Y = GetStretchY(si);
-#if 1
-  StretchedSprites.BltImg(X, Y, aniSpace, 0);
-  StretchedSprites.BltImg(X + bx * TwoPixels, Y, aniSnikSnakRight, bx);
-#else
-  StretchedSprites.BltEx(X, Y, 0);
-  StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniSnikSnakRight + bx);
-#endif
+  DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
+  DDSpriteBuffer_BltImg(X + bx * TwoPixels, Y, aniSnikSnakRight, bx);
   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  return subDrawSnikSnakFromLeft;
 }