src/game_sp/Electrons.c

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