src/game_sp/SnikSnaks.c

   1 // ----------------------------------------------------------------------------
   2 // SnikSnaks.c
   3 // ----------------------------------------------------------------------------
   4
   5 #include "SnikSnaks.h"
   6
   7 static int subDrawSnikSnakFromAbove(int si, int bx);
   8 static int subDrawSnikSnakFromBelow(int si, int bx);
   9 static int subDrawSnikSnakFromLeft(int si, int bx);
  10 static int subDrawSnikSnakFromRight(int si, int bx);
  11 static int subDrawSnikSnakTurnLeft(int si, int bx);
  12 static int subDrawSnikSnakTurnRight(int si, int bx);
  13 static int subSnikSnakFromAbove(int si, int bx);
  14 static int subSnikSnakFromBelow(int si, int bx);
  15 static int subSnikSnakFromLeft(int si, int bx);
  16 static int subSnikSnakFromRight(int si, int bx);
  17 static int subSnikSnakTurnLeft(int si, int bx);
  18 static int subSnikSnakTurnRight(int si, int bx);
  19
  20 static char *VB_Name = "modSnikSnak";
  21 // --- Option Explicit
  22 // ==========================================================================
  23 //                              SUBROUTINE
  24 // Animate/move Snik-Snaks
  25 // ==========================================================================
  26
  27 int subAnimateSnikSnaks(int si)
  28 {
  29   int subAnimateSnikSnaks;
  30
  31   int bx, Tmp;
  32
  33   if (SnikSnaksElectronsFrozen == 1)
  34     return subAnimateSnikSnaks;
  35
  36   //  If LowByte(PlayField16(si)) <> fiSnikSnak Then Exit Function
  37   // Debug.Assert (LowByte(PlayField16[si]) == fiSnikSnak);
  38   bx = HighByte(PlayField16[si]);
  39   Tmp = bx / 8;
  40   switch (Tmp)
  41   {
  42     case 0:
  43       subSnikSnakTurnLeft(si, bx); // turning, bx=0 -> point N, bx = 1 -> point NW etc.
  44       break;
  45
  46     case 1:
  47       subSnikSnakTurnRight(si, bx); // turn right
  48       break;
  49
  50     case 2:
  51       subSnikSnakFromBelow(si, bx); // access si from below
  52       break;
  53
  54     case 3:
  55       subSnikSnakFromRight(si, bx); // access si from right
  56       break;
  57
  58     case 4:
  59       subSnikSnakFromAbove(si, bx); // access si from above
  60       break;
  61
  62     case 5:
  63       subSnikSnakFromLeft(si, bx); // access si from left
  64       break;
  65
  66     default:
  67       // Debug.Assert(False);
  68       break;
  69   }
  70
  71   return subAnimateSnikSnaks;
  72 } // subAnimateSnikSnaks
  73
  74 int subDrawAnimatedSnikSnaks(int si)
  75 {
  76   int subDrawAnimatedSnikSnaks;
  77
  78   int bx, Tmp;
  79
  80   // If SnikSnaksElectronsFrozen = 1 Then Exit Function
  81   if (LowByte(PlayField16[si]) != fiSnikSnak)
  82     return subDrawAnimatedSnikSnaks;
  83
  84   bx = HighByte(PlayField16[si]);
  85   Tmp = bx / 8;
  86   switch (Tmp)
  87   {
  88     case 0:
  89       subDrawSnikSnakTurnLeft(si, bx); // turning, bx=0 -> point N, bx = 1 -> point NW etc.
  90       break;
  91
  92     case 1:
  93       subDrawSnikSnakTurnRight(si, bx); // turn right
  94       break;
  95
  96     case 2:
  97       subDrawSnikSnakFromBelow(si, bx); // access si from below
  98       break;
  99
 100     case 3:
 101       subDrawSnikSnakFromRight(si, bx); // access si from right
 102       break;
 103
 104     case 4:
 105       subDrawSnikSnakFromAbove(si, bx); // access si from above
 106       break;
 107
 108     case 5:
 109       subDrawSnikSnakFromLeft(si, bx); // access si from left
 110       break;
 111   }
 112
 113   return subDrawAnimatedSnikSnaks;
 114 } // subAnimateSnikSnaks
 115
 116 static int subSnikSnakTurnLeft(int si, int bx)
 117 {
 118   static int subSnikSnakTurnLeft;
 119
 120   int ax, ah, bl, dx, X, Y;
 121
 122   ax = (TimerVar & 3);
 123   if (ax != 0)
 124   {
 125     if (ax == 3)
 126       goto loc_g_7622;
 127
 128     return subSnikSnakTurnLeft;
 129   } // loc_g_75E0:
 130
 131   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 132   X = GetStretchX(si);
 133   Y = GetStretchY(si);
 134   StretchedSprites.BltEx(X, Y, aniSnikSnak[bx]);
 135   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 136   bx = (bx + 1) & 0x7;
 137   MovHighByte(&PlayField16[si], bx);
 138   return subSnikSnakTurnLeft;
 139
 140 locMayExplode760A:
 141   ah = HighByte(ax);
 142   if (ah == 0x1B)
 143     return subSnikSnakTurnLeft;
 144
 145   if (ah == 0x19)
 146     return subSnikSnakTurnLeft;
 147
 148   if (ah == 0x18)
 149     return subSnikSnakTurnLeft;
 150
 151   if (ah == 0x1A)
 152     return subSnikSnakTurnLeft;
 153
 154   ExplodeFieldSP(si); // Explode
 155   return subSnikSnakTurnLeft;
 156
 157 loc_g_7622:
 158   bl = HighByte(PlayField16[si]);
 159   if (bl == 0)
 160     goto loc_g_763B;
 161
 162   if (bl == 2)
 163     goto loc_g_765E;
 164
 165   if (bl == 4)
 166     goto loc_g_7681;
 167
 168   if (bl == 6)
 169     goto loc_g_76A7;
 170
 171   return subSnikSnakTurnLeft;
 172
 173 loc_g_763B: // pointing up
 174   ax = PlayField16[si - FieldWidth];
 175   if (ax == 0) // above is empty -> go up
 176     goto loc_g_764E;
 177
 178   if (LowByte(ax) == fiMurphy) // above is murphy -> explode
 179     goto locMayExplode760A;
 180
 181   return subSnikSnakTurnLeft;
 182
 183 loc_g_764E: // above is empty -> go up
 184   PlayField16[si] = 0x1BB;
 185   si = si - FieldWidth;
 186   PlayField16[si] = 0x1011;
 187   return subSnikSnakTurnLeft;
 188
 189 loc_g_765E: // pointing left
 190   ax = PlayField16[si - 1];
 191   if (ax == 0) // left is empty -> go there
 192     goto loc_g_7671;
 193
 194   if (LowByte(ax) == fiMurphy) // left is murphy -> explode
 195     goto locMayExplode760A;
 196
 197   return subSnikSnakTurnLeft;
 198
 199 loc_g_7671: // left is empty -> go there
 200   PlayField16[si] = 0x2BB;
 201   si = si - 1;
 202   PlayField16[si] = 0x1811;
 203   return subSnikSnakTurnLeft;
 204
 205 loc_g_7681: // pointing down
 206   ax = PlayField16[si + FieldWidth];
 207   if (ax == 0) // below is empty -> go down
 208     goto loc_g_7697;
 209
 210   if (LowByte(ax) == fiMurphy) // below is murphy -> explode
 211     goto locMayExplode760A;
 212
 213   return subSnikSnakTurnLeft;
 214
 215 loc_g_7697: // below is empty -> go down
 216   PlayField16[si] = 0x3BB;
 217   si = si + FieldWidth;
 218   PlayField16[si] = 0x2011;
 219   return subSnikSnakTurnLeft;
 220
 221 loc_g_76A7: // pointing Right
 222   ax = PlayField16[si + 1];
 223   if (ax == 0) // right is empty -> go there
 224     goto loc_g_76BD;
 225
 226   if (LowByte(ax) == fiMurphy) // right is murphy -> explode
 227     goto locMayExplode760A;
 228
 229   return subSnikSnakTurnLeft;
 230
 231 loc_g_76BD: // right is empty -> go there
 232   PlayField16[si] = 0x4BB;
 233   si = si + 1;
 234   PlayField16[si] = 0x2811;
 235
 236   return subSnikSnakTurnLeft;
 237 } // subSnikSnakTurnLeft
 238
 239 static int subSnikSnakTurnRight(int si, int bx)
 240 {
 241   static int subSnikSnakTurnRight;
 242
 243   int ax, ah, bl, dx, X, Y;
 244
 245   ax = (TimerVar & 3);
 246   if (ax != 0)
 247   {
 248     if (ax == 3)
 249       goto loc_g_771F;
 250
 251     return subSnikSnakTurnRight;
 252   } // loc_g_76DB:
 253
 254   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 255   X = GetStretchX(si);
 256   Y = GetStretchY(si);
 257   StretchedSprites.BltEx(X, Y, aniSnikSnak[0x10 - bx]);
 258   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 259   bx = ((bx + 1) & 0x7) | 8;
 260   MovHighByte(&PlayField16[si], bx);
 261   return subSnikSnakTurnRight;
 262
 263 locMayExplode7707:
 264   ah = HighByte(ax);
 265   if (ah == 0x1B)
 266     return subSnikSnakTurnRight;
 267
 268   if (ah == 0x19)
 269     return subSnikSnakTurnRight;
 270
 271   if (ah == 0x18)
 272     return subSnikSnakTurnRight;
 273
 274   if (ah == 0x1A)
 275     return subSnikSnakTurnRight;
 276
 277   ExplodeFieldSP(si); // Explode
 278   return subSnikSnakTurnRight;
 279
 280 loc_g_771F:
 281   bl = HighByte(PlayField16[si]);
 282   if (bl == 0x8)
 283     goto loc_g_7738;
 284
 285   if (bl == 0xA)
 286     goto loc_g_77A4;
 287
 288   if (bl == 0xC)
 289     goto loc_g_777E;
 290
 291   if (bl == 0xE)
 292     goto loc_g_775B;
 293
 294   return subSnikSnakTurnRight;
 295
 296 loc_g_7738: // pointing up
 297   ax = PlayField16[si - FieldWidth];
 298   if (ax == 0) // above is empty -> go up
 299     goto loc_g_774B;
 300
 301   if (LowByte(ax) == fiMurphy) // above is murphy -> explode
 302     goto locMayExplode7707;
 303
 304   return subSnikSnakTurnRight;
 305
 306 loc_g_774B: // above is empty -> go up
 307   PlayField16[si] = 0x1BB;
 308   si = si - FieldWidth;
 309   PlayField16[si] = 0x1011;
 310   return subSnikSnakTurnRight;
 311
 312 loc_g_775B: // pointing left
 313   ax = PlayField16[si - 1];
 314   if (ax == 0) // left is empty -> go there
 315     goto loc_g_776E;
 316
 317   if (LowByte(ax) == fiMurphy) // left is murphy -> explode
 318     goto locMayExplode7707;
 319
 320   return subSnikSnakTurnRight;
 321
 322 loc_g_776E: // left is empty -> go there
 323   PlayField16[si] = 0x2BB;
 324   si = si - 1;
 325   PlayField16[si] = 0x1811;
 326   return subSnikSnakTurnRight;
 327
 328 loc_g_777E: // pointing down
 329   ax = PlayField16[si + FieldWidth];
 330   if (ax == 0) // below is empty -> go down
 331     goto loc_g_7794;
 332
 333   if (LowByte(ax) == fiMurphy) // below is murphy -> explode
 334     goto locMayExplode7707;
 335
 336   return subSnikSnakTurnRight;
 337
 338 loc_g_7794: // below is empty -> go down
 339   PlayField16[si] = 0x3BB;
 340   si = si + FieldWidth;
 341   PlayField16[si] = 0x2011;
 342   return subSnikSnakTurnRight;
 343
 344 loc_g_77A4: // pointing Right
 345   ax = PlayField16[si + 1];
 346   if (ax == 0) // right is empty -> go there
 347     goto loc_g_77BA;
 348
 349   if (LowByte(ax) == fiMurphy) // right is murphy -> explode
 350     goto locMayExplode7707;
 351
 352   return subSnikSnakTurnRight;
 353
 354 loc_g_77BA: // right is empty -> go there
 355   PlayField16[si] = 0x4BB;
 356   si = si + 1;
 357   PlayField16[si] = 0x2811;
 358
 359   return subSnikSnakTurnRight;
 360 } // subSnikSnakTurnRight
 361
 362 static int subSnikSnakFromBelow(int si, int bx)
 363 {
 364   static int subSnikSnakFromBelow;
 365
 366   int ax, ah, bl, dx, X, Y;
 367
 368   bx = bx - 0xF;  // get and increment sequence#
 369   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 370   X = GetStretchX(si);
 371   Y = GetStretchY(si + FieldWidth);
 372   StretchedSprites.BltEx(X, Y, 0);
 373   StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniSnikSnakUp + bx);
 374   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 375   bl = LowByte(bx);
 376   if (bl == 7 && LowByte(PlayField16[si + FieldWidth]) != fiExplosion)
 377   {
 378     PlayField16[si + FieldWidth] = 0; // sniknak left that field
 379   }
 380
 381   if (bl < 8) // sniksnak still goes up
 382   {
 383     bl = bl + 0x10;
 384     MovHighByte(&PlayField16[si], bl);
 385     return subSnikSnakFromBelow;
 386   } // loc_g_7813
 387
 388   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
 389   ax = PlayField16[si - 1]; // check left field
 390   if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
 391   {
 392     MovHighByte(&PlayField16[si], 1); // start to turn left
 393     return subSnikSnakFromBelow;
 394   } // loc_g_7826: and 'loc_g_7833:
 395
 396   ax = PlayField16[si - FieldWidth]; // cannot turn left -> check above
 397   if (ax == 0) // check if empty
 398   {
 399     PlayField16[si] = 0x1BB; // mark as "sniksnak leaving"
 400     si = si - FieldWidth; // go up!
 401     PlayField16[si] = 0x1011;
 402     return subSnikSnakFromBelow;
 403   } // loc_g_784A:
 404
 405   if (LowByte(ax) == fiMurphy) // check for murphy above
 406   {
 407     ExplodeFieldSP(si); // Explode
 408     return subSnikSnakFromBelow;
 409   } // loc_g_7855:
 410
 411   ax = PlayField16[si + 1]; // check right field
 412   if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
 413   {
 414     MovHighByte(&PlayField16[si], 9); // start to turn right
 415     return subSnikSnakFromBelow;
 416   } // loc_g_7862: and 'loc_g_786F:
 417
 418   // else: no way to go, start turning around
 419   MovHighByte(&PlayField16[si], 1);
 420
 421   return subSnikSnakFromBelow;
 422 } // subSnikSnakFromBelow
 423
 424 static int subSnikSnakFromRight(int si, int bx)
 425 {
 426   static int subSnikSnakFromRight;
 427
 428   int ax, ah, bl, dx, X, Y;
 429
 430   bx = bx - 0x17;  // get and increment sequence#
 431   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 432   X = GetStretchX(si + 1);
 433   Y = GetStretchY(si);
 434   StretchedSprites.BltEx(X, Y, 0);
 435   StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniSnikSnakLeft + bx);
 436   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 437   bl = LowByte(bx);
 438   if (bl == 7 && LowByte(PlayField16[si + 1]) != fiExplosion)
 439   {
 440     PlayField16[si + 1] = 0; // sniknak left that field
 441   } // loc_g_78AC:
 442
 443   if (bl < 8) // sniksnak still goes left
 444   {
 445     bl = bl + 0x18;
 446     MovHighByte(&PlayField16[si], bl);
 447     return subSnikSnakFromRight;
 448   } // loc_g_78B9:
 449
 450   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
 451   ax = PlayField16[si + FieldWidth]; // check below
 452   if (ax == 0 || LowByte(ax) == fiMurphy) // empty or murphy?
 453   {
 454     MovHighByte(&PlayField16[si], 3); // yes -> turn left down
 455     return subSnikSnakFromRight;
 456   } // loc_g_78CC: and 'loc_g_78D9:
 457
 458   ax = PlayField16[si - 1]; // check left, etc ... see the comments on subSnikSnakFromBelow()
 459   if (ax == 0)
 460   {
 461     PlayField16[si] = 0x2BB;
 462     si = si - 1;                // 1 field left
 463     PlayField16[si] = 0x1811;
 464     return subSnikSnakFromRight;
 465   } // loc_g_78F0:
 466
 467   if (LowByte(ax) == fiMurphy)
 468   {
 469     ExplodeFieldSP(si);      // Explode
 470     return subSnikSnakFromRight;
 471   } // loc_g_78FB:
 472
 473   ax = PlayField16[si - FieldWidth]; // check above
 474   if (ax == 0 || LowByte(ax) == fiMurphy)
 475   {
 476     MovHighByte(&PlayField16[si], 0xF);
 477     return subSnikSnakFromRight;
 478   } // loc_g_7908:loc_g_7915:
 479
 480   MovHighByte(&PlayField16[si], 3);
 481
 482   return subSnikSnakFromRight;
 483 } // subSnikSnakFromRight
 484
 485 static int subSnikSnakFromAbove(int si, int bx)
 486 {
 487   static int subSnikSnakFromAbove;
 488
 489   int ax, ah, bl, dx, X, Y;
 490
 491   bx = bx - 0x1F;  // get and increment sequence#
 492   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 493   X = GetStretchX(si);
 494   Y = GetStretchY(si - FieldWidth);
 495   StretchedSprites.BltEx(X, Y, 0);
 496   StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniSnikSnakDown + bx);
 497   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 498   bl = LowByte(bx);
 499   if (bl == 7 && LowByte(PlayField16[si - FieldWidth]) != fiExplosion)
 500   {
 501     PlayField16[si - FieldWidth] = 0; // sniknak left that field
 502   }
 503
 504   if (bl < 8) // sniksnak still goes down
 505   {
 506     bl = bl + 0x20;
 507     MovHighByte(&PlayField16[si], bl);
 508     return subSnikSnakFromAbove;
 509   } // loc_g_7813
 510
 511   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
 512   ax = PlayField16[si + 1]; // check right
 513   if (ax == 0 || LowByte(ax) == fiMurphy)
 514   {
 515     MovHighByte(&PlayField16[si], 5);
 516     return subSnikSnakFromAbove;
 517   } // loc_g_7986:
 518
 519   ax = PlayField16[si + FieldWidth]; // check below
 520   if (ax == 0)
 521   {
 522     PlayField16[si] = 0x3BB;
 523     si = si + FieldWidth;                 // 1 field down
 524     PlayField16[si] = 0x2011;
 525     return subSnikSnakFromAbove;
 526   } // loc_g_799D:
 527
 528   if (LowByte(ax) == fiMurphy)
 529   {
 530     ExplodeFieldSP(si);        // Explode
 531     return subSnikSnakFromAbove;
 532   } // loc_g_79A8:
 533
 534   ax = PlayField16[si - 1]; // check left
 535   if (ax == 0 || LowByte(ax) == fiMurphy)
 536   {
 537     MovHighByte(&PlayField16[si], 0xD);
 538     return subSnikSnakFromAbove;
 539   } // loc_g_79C2:
 540
 541   MovHighByte(&PlayField16[si], 5);
 542
 543   return subSnikSnakFromAbove;
 544 } // subSnikSnakFromAbove
 545
 546 static int subSnikSnakFromLeft(int si, int bx)
 547 {
 548   static int subSnikSnakFromLeft;
 549
 550   int ax, ah, bl, dx, X, Y;
 551
 552   bx = bx - 0x27;  // get and increment sequence#
 553   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 554   X = GetStretchX(si - 1);
 555   Y = GetStretchY(si);
 556   StretchedSprites.BltEx(X, Y, 0);
 557   StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniSnikSnakRight + bx);
 558   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 559   bl = LowByte(bx);
 560   if (bl == 7 && LowByte(PlayField16[si - 1]) != fiExplosion)
 561   {
 562     PlayField16[si - 1] = 0; // sniknak left that field
 563   }
 564
 565   if (bl < 8) // sniksnak still goes right
 566   {
 567     bl = bl + 0x28;
 568     MovHighByte(&PlayField16[si], bl);
 569     return subSnikSnakFromLeft;
 570   } // loc_g_78B9:
 571
 572   PlayField16[si] = 0x11; // sequence#=8 -> arrived at the new field
 573   ax = PlayField16[si - FieldWidth]; // check above
 574   if (ax == 0 || LowByte(ax) == fiMurphy)
 575   {
 576     MovHighByte(&PlayField16[si], 7);
 577     return subSnikSnakFromLeft;
 578   } // loc_g_7A2D:
 579
 580   ax = PlayField16[si + 1]; // check right(straight on)
 581   if (ax == 0)
 582   {
 583     PlayField16[si] = 0x4BB;
 584     si = si + 1;                   // 1 field right
 585     PlayField16[si] = 0x2811;
 586     return subSnikSnakFromLeft;
 587   } // loc_g_7A44:
 588
 589   if (LowByte(ax) == fiMurphy)
 590   {
 591     ExplodeFieldSP(si);    // Explode
 592     return subSnikSnakFromLeft;
 593   } // loc_g_7A4F:
 594
 595   ax = PlayField16[si + FieldWidth]; // check below
 596   if (ax == 0 || LowByte(ax) == fiMurphy)
 597   {
 598     MovHighByte(&PlayField16[si], 0xB);
 599     return subSnikSnakFromLeft;
 600   } // loc_g_7A69:
 601
 602   MovHighByte(&PlayField16[si], 7);
 603
 604   return subSnikSnakFromLeft;
 605 } // subSnikSnakFromLeft
 606
 607 static int subDrawSnikSnakTurnLeft(int si, int bx)
 608 {
 609   static int subDrawSnikSnakTurnLeft;
 610
 611   int X, Y;
 612
 613   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 614   X = GetStretchX(si);
 615   Y = GetStretchY(si);
 616   StretchedSprites.BltEx(X, Y, aniSnikSnak[bx]);
 617   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 618
 619   return subDrawSnikSnakTurnLeft;
 620 }
 621
 622 static int subDrawSnikSnakTurnRight(int si, int bx)
 623 {
 624   static int subDrawSnikSnakTurnRight;
 625
 626   int X, Y;
 627
 628   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 629   X = GetStretchX(si);
 630   Y = GetStretchY(si);
 631   StretchedSprites.BltEx(X, Y, aniSnikSnak[0x10 - bx]);
 632   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 633
 634   return subDrawSnikSnakTurnRight;
 635 }
 636
 637 static int subDrawSnikSnakFromBelow(int si, int bx)
 638 {
 639   static int subDrawSnikSnakFromBelow;
 640
 641   int X, Y;
 642
 643   bx = bx - 0xF; // get and anti-increment sequence#
 644   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 645   X = GetStretchX(si);
 646   Y = GetStretchY(si + FieldWidth);
 647   StretchedSprites.BltEx(X, Y, 0);
 648   StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniSnikSnakUp + bx);
 649   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 650
 651   return subDrawSnikSnakFromBelow;
 652 }
 653
 654 static int subDrawSnikSnakFromRight(int si, int bx)
 655 {
 656   static int subDrawSnikSnakFromRight;
 657
 658   int X, Y;
 659
 660   bx = bx - 0x17; // get and increment sequence#
 661   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 662   X = GetStretchX(si + 1);
 663   Y = GetStretchY(si);
 664   StretchedSprites.BltEx(X, Y, 0);
 665   StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniSnikSnakLeft + bx);
 666   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 667
 668   return subDrawSnikSnakFromRight;
 669 }
 670
 671 static int subDrawSnikSnakFromAbove(int si, int bx)
 672 {
 673   static int subDrawSnikSnakFromAbove;
 674
 675   int X, Y;
 676
 677   bx = bx - 0x1F; // get and increment sequence#
 678   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 679   X = GetStretchX(si);
 680   Y = GetStretchY(si - FieldWidth);
 681   StretchedSprites.BltEx(X, Y, 0);
 682   StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniSnikSnakDown + bx);
 683   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 684
 685   return subDrawSnikSnakFromAbove;
 686 }
 687
 688 static int subDrawSnikSnakFromLeft(int si, int bx)
 689 {
 690   static int subDrawSnikSnakFromLeft;
 691
 692   int X, Y;
 693
 694   bx = bx - 0x27; // get and increment sequence#
 695   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 696   X = GetStretchX(si - 1);
 697   Y = GetStretchY(si);
 698   StretchedSprites.BltEx(X, Y, 0);
 699   StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniSnikSnakRight + bx);
 700   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
 701
 702   return subDrawSnikSnakFromLeft;
 703 }