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