src/game_sp/Electrons.c

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