1 // ----------------------------------------------------------------------------
3 // ----------------------------------------------------------------------------
7 // static char *VB_Name = "modElectron";
10 // ==========================================================================
12 // Animate/move Electrons
13 // ==========================================================================
15 int subAnimateElectrons(int si)
17 int subAnimateElectrons;
21 if (SnikSnaksElectronsFrozen == 1)
22 return subAnimateElectrons;
24 if (LowByte(PlayField16[si]) != fiElectron)
25 return subAnimateElectrons;
27 bx = HighByte(PlayField16[si]);
32 subElectronTurnLeft(si, bx); // turning, bx=0 -> point N, bx = 1 -> point NW etc.
36 subElectronTurnRight(si, bx); // turn right
40 subElectronFromBelow(si, bx); // access si from below
44 subElectronFromRight(si, bx); // access si from right
48 subElectronFromAbove(si, bx); // access si from above
52 subElectronFromLeft(si, bx); // access si from left
56 return subAnimateElectrons;
57 } // subAnimateElectrons
59 int subDrawAnimatedElectrons(int si)
61 int subDrawAnimatedElectrons;
65 // If SnikSnaksElectronsFrozen = 1 Then Exit Function
66 if (LowByte(PlayField16[si]) != fiElectron)
67 return subDrawAnimatedElectrons;
69 bx = HighByte(PlayField16[si]);
74 subDrawElectronTurnLeft(si, bx); // turning, bx=0 -> point N, bx = 1 -> point NW etc.
78 subDrawElectronTurnRight(si, bx); // turn right
82 subDrawElectronFromBelow(si, bx); // access si from below
86 subDrawElectronFromRight(si, bx); // access si from right
90 subDrawElectronFromAbove(si, bx); // access si from above
94 subDrawElectronFromLeft(si, bx); // access si from left
98 return subDrawAnimatedElectrons;
99 } // subDrawAnimatedElectrons
101 int subElectronTurnLeft(int si, int bx)
103 int subElectronTurnLeft;
105 // int ax, ah, bl, dx, X, Y;
114 return subElectronTurnLeft;
117 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
120 StretchedSprites.BltEx(X, Y, aniElectron[bx]);
121 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
123 MovHighByte(&PlayField16[si], bx);
124 return subElectronTurnLeft;
127 bl = HighByte(PlayField16[si]);
140 return subElectronTurnLeft;
142 loc_g_7AE6: // pointing up
143 ax = PlayField16[si - FieldWidth];
144 if (ax == 0) // above is empty -> go up
147 if (LowByte(ax) == fiMurphy) // above is murphy -> explode
150 return subElectronTurnLeft;
152 loc_g_7AF5: // above is empty -> go up
153 PlayField16[si] = 0x1BB;
154 si = si - FieldWidth; // 1 field up
155 PlayField16[si] = 0x1018;
156 return subElectronTurnLeft;
158 loc_g_7B05: // pointing left
159 ax = PlayField16[si - 1];
160 if (ax == 0) // left is empty -> go there
163 if (LowByte(ax) == fiMurphy) // left is murphy -> explode
166 return subElectronTurnLeft;
168 loc_g_7B14: // left is empty -> go there
169 PlayField16[si] = 0x2BB;
170 si = si - 1; // 1 field left
171 PlayField16[si] = 0x1818;
172 return subElectronTurnLeft;
174 loc_g_7B24: // pointing down
175 ax = PlayField16[si + FieldWidth];
176 if (ax == 0) // below is empty -> go down
179 if (LowByte(ax) == fiMurphy) // below is murphy -> explode
182 return subElectronTurnLeft;
184 loc_g_7B33: // below is empty -> go down
185 PlayField16[si] = 0x3BB;
186 si = si + FieldWidth; // 1 field down
187 PlayField16[si] = 0x2018;
188 return subElectronTurnLeft;
190 loc_g_7B43: // pointing Right
191 ax = PlayField16[si + 1];
192 if (ax == 0) // right is empty -> go there
195 if (LowByte(ax) == fiMurphy) // right is murphy -> explode
198 return subElectronTurnLeft;
200 loc_g_7B55: // right is empty -> go there
201 PlayField16[si] = 0x4BB;
202 si = si + 1; // 1 field right
203 PlayField16[si] = 0x2818;
205 return subElectronTurnLeft;
206 } // subElectronTurnLeft
208 int subElectronTurnRight(int si, int bx)
210 int subElectronTurnRight;
212 // int ax, ah, bl, dx, X, Y;
221 return subElectronTurnRight;
224 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
227 StretchedSprites.BltEx(X, Y, aniElectron[0x10 - bx]);
228 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
229 bx = ((bx + 1) & 0x7) | 8;
230 MovHighByte(&PlayField16[si], bx);
231 return subElectronTurnRight;
234 bl = HighByte(PlayField16[si]);
247 return subElectronTurnRight;
249 loc_g_7BBC: // pointing up
250 ax = PlayField16[si - FieldWidth];
251 if (ax == 0) // above is empty -> go up
254 if (LowByte(ax) == fiMurphy) // above is murphy -> explode
257 return subElectronTurnRight;
259 loc_g_7BCB: // above is empty -> go up
260 PlayField16[si] = 0x1BB;
261 si = si - FieldWidth; // 1 field up
262 PlayField16[si] = 0x1018;
263 return subElectronTurnRight;
265 loc_g_7BDB: // pointing left
266 ax = PlayField16[si - 1];
267 if (ax == 0) // left is empty -> go there
270 if (LowByte(ax) == fiMurphy) // left is murphy -> explode
273 return subElectronTurnRight;
275 loc_g_7BEA: // left is empty -> go there
276 PlayField16[si] = 0x2BB;
277 si = si - 1; // 1 field left
278 PlayField16[si] = 0x1818;
279 return subElectronTurnRight;
281 loc_g_7BFA: // pointing down
282 ax = PlayField16[si + FieldWidth];
283 if (ax == 0) // below is empty -> go down
286 if (LowByte(ax) == fiMurphy) // below is murphy -> explode
289 return subElectronTurnRight;
291 loc_g_7C09: // below is empty -> go down
292 PlayField16[si] = 0x3BB;
293 si = si + FieldWidth; // 1 field down
294 PlayField16[si] = 0x2018;
295 return subElectronTurnRight;
297 loc_g_7C19: // pointing Right
298 ax = PlayField16[si + 1];
299 if (ax == 0) // right is empty -> go there
302 if (LowByte(ax) == fiMurphy) // right is murphy -> explode
305 return subElectronTurnRight;
307 loc_g_7C2B: // right is empty -> go there
308 PlayField16[si] = 0x4BB;
309 si = si + 1; // 1 field right
310 PlayField16[si] = 0x2818;
312 return subElectronTurnRight;
313 } // subElectronTurnRight
315 int subElectronFromBelow(int si, int bx)
317 int subElectronFromBelow;
319 // int ax, ah, bl, dx, X, Y;
322 bx = bx - 0xF; // get and increment sequence#
323 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
325 Y = GetStretchY(si + FieldWidth);
326 StretchedSprites.BltEx(X, Y, 0);
327 StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniElectron[bx]);
328 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
330 if (bl == 7 && LowByte(PlayField16[si + FieldWidth]) != fiExplosion)
332 PlayField16[si + FieldWidth] = 0; // electron left that field
335 if (bl < 8) // electron still goes up
338 MovHighByte(&PlayField16[si], bl);
339 return subElectronFromBelow;
342 PlayField16[si] = 0x18; // sequence#=8 -> arrived at the new field
343 ax = PlayField16[si - 1]; // check left field
344 if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
346 MovHighByte(&PlayField16[si], 1); // start to turn left
347 return subElectronFromBelow;
350 ax = PlayField16[si - FieldWidth]; // cannot turn left -> check above
351 if (ax == 0) // check if empty
353 PlayField16[si] = 0x1BB; // mark as "electron leaving"
354 si = si - FieldWidth; // go up!
355 PlayField16[si] = 0x1018;
356 return subElectronFromBelow;
359 if (LowByte(ax) == fiMurphy) // check for murphy above
361 ExplodeFieldSP(si); // Explode
362 return subElectronFromBelow;
365 ax = PlayField16[si + 1]; // check right field
366 if (ax == 0 || LowByte(ax) == fiMurphy) // check for empty or murphy
368 MovHighByte(&PlayField16[si], 9); // start to turn right
369 return subElectronFromBelow;
372 // else: no way to go, start turning around
373 MovHighByte(&PlayField16[si], 1);
375 return subElectronFromBelow;
376 } // subElectronFromBelow
378 int subElectronFromRight(int si, int bx)
380 int subElectronFromRight;
382 // int ax, ah, bl, dx, X, Y;
385 bx = bx - 0x17; // get and increment sequence#
386 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
387 X = GetStretchX(si + 1);
389 StretchedSprites.BltEx(X, Y, 0);
390 StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniElectron[bx]);
391 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
393 if (bl == 7 && LowByte(PlayField16[si + 1]) != fiExplosion)
395 PlayField16[si + 1] = 0; // electron left that field
398 if (bl < 8) // sniksnak still goes left
401 MovHighByte(&PlayField16[si], bl);
402 return subElectronFromRight;
405 PlayField16[si] = 0x18; // sequence#=8 -> arrived at the new field
406 ax = PlayField16[si + FieldWidth]; // check below
407 if (ax == 0 || LowByte(ax) == fiMurphy) // empty or murphy?
409 MovHighByte(&PlayField16[si], 3); // yes -> turn left down
410 return subElectronFromRight;
413 ax = PlayField16[si - 1]; // check left, etc ... see the comments on subElectronFromBelow()
416 PlayField16[si] = 0x2BB;
417 si = si - 1; // 1 field left
418 PlayField16[si] = 0x1818;
419 return subElectronFromRight;
422 if (LowByte(ax) == fiMurphy)
424 ExplodeFieldSP(si); // Explode
425 return subElectronFromRight;
428 ax = PlayField16[si - FieldWidth]; // check above
429 if (ax == 0 || LowByte(ax) == fiMurphy)
431 MovHighByte(&PlayField16[si], 0xF);
432 return subElectronFromRight;
435 MovHighByte(&PlayField16[si], 3);
437 return subElectronFromRight;
438 } // subElectronFromRight
440 int subElectronFromAbove(int si, int bx)
442 int subElectronFromAbove;
444 // int ax, ah, bl, dx, X, Y;
447 bx = bx - 0x1F; // get and increment sequence#
448 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
450 Y = GetStretchY(si - FieldWidth);
451 StretchedSprites.BltEx(X, Y, 0);
452 StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniElectron[bx]);
453 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
455 if (bl == 7 && LowByte(PlayField16[si - FieldWidth]) != fiExplosion)
457 PlayField16[si - FieldWidth] = 0; // electron left that field
460 if (bl < 8) // electron still goes down
463 MovHighByte(&PlayField16[si], bl);
464 return subElectronFromAbove;
467 PlayField16[si] = 0x18; // sequence#=8 -> arrived at the new field
468 ax = PlayField16[si + 1]; // check right
469 if (ax == 0 || LowByte(ax) == fiMurphy)
471 MovHighByte(&PlayField16[si], 5);
472 return subElectronFromAbove;
475 ax = PlayField16[si + FieldWidth]; // check below
478 PlayField16[si] = 0x3BB;
479 si = si + FieldWidth; // 1 field down
480 PlayField16[si] = 0x2018;
481 return subElectronFromAbove;
484 if (LowByte(ax) == fiMurphy)
486 ExplodeFieldSP(si); // Explode
487 return subElectronFromAbove;
490 ax = PlayField16[si - 1]; // check left
491 if (ax == 0 || LowByte(ax) == fiMurphy)
493 MovHighByte(&PlayField16[si], 0xD);
494 return subElectronFromAbove;
497 MovHighByte(&PlayField16[si], 5);
499 return subElectronFromAbove;
500 } // subElectronFromAbove
502 int subElectronFromLeft(int si, int bx)
504 int subElectronFromLeft;
506 // int ax, ah, bl, dx, X, Y;
509 bx = bx - 0x27; // get and increment sequence#
510 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
511 X = GetStretchX(si - 1);
513 StretchedSprites.BltEx(X, Y, 0);
514 StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniElectron[bx]);
515 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
517 if (bl == 7 && LowByte(PlayField16[si - 1]) != fiExplosion)
519 PlayField16[si - 1] = 0; // electron left that field
522 if (bl < 8) // electron still goes right
525 MovHighByte(&PlayField16[si], bl);
526 return subElectronFromLeft;
529 PlayField16[si] = 0x18; // sequence#=8 -> arrived at the new field
530 ax = PlayField16[si - FieldWidth]; // check above
531 if (ax == 0 || LowByte(ax) == fiMurphy)
533 MovHighByte(&PlayField16[si], 7);
534 return subElectronFromLeft;
537 ax = PlayField16[si + 1]; // check right(straight on)
540 PlayField16[si] = 0x4BB;
541 si = si + 1; // 1 field right
542 PlayField16[si] = 0x2818;
543 return subElectronFromLeft;
546 if (LowByte(ax) == fiMurphy)
548 ExplodeFieldSP(si); // Explode
549 return subElectronFromLeft;
552 ax = PlayField16[si + FieldWidth]; // check below
553 if (ax == 0 || LowByte(ax) == fiMurphy)
555 MovHighByte(&PlayField16[si], 0xB);
556 return subElectronFromLeft;
559 MovHighByte(&PlayField16[si], 7);
561 return subElectronFromLeft;
562 } // subElectronFromLeft
564 int subDrawElectronTurnLeft(int si, int bx)
566 int subDrawElectronTurnLeft;
570 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
573 StretchedSprites.BltEx(X, Y, aniElectron[bx]);
574 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
576 return subDrawElectronTurnLeft;
579 int subDrawElectronTurnRight(int si, int bx)
581 int subDrawElectronTurnRight;
585 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
588 StretchedSprites.BltEx(X, Y, aniElectron[0x10 - bx]);
589 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
591 return subDrawElectronTurnRight;
594 int subDrawElectronFromBelow(int si, int bx)
596 int subDrawElectronFromBelow;
600 bx = bx - 0xF; // get and increment sequence#
601 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
603 Y = GetStretchY(si + FieldWidth);
604 StretchedSprites.BltEx(X, Y, 0);
605 StretchedSprites.BltEx(X, Y - bx * TwoPixels, aniElectron[bx]);
606 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
608 return subDrawElectronFromBelow;
611 int subDrawElectronFromRight(int si, int bx)
613 int subDrawElectronFromRight;
617 bx = bx - 0x17; // get and increment sequence#
618 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
619 X = GetStretchX(si + 1);
621 StretchedSprites.BltEx(X, Y, 0);
622 StretchedSprites.BltEx(X - bx * TwoPixels, Y, aniElectron[bx]);
623 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
625 return subDrawElectronFromRight;
628 int subDrawElectronFromAbove(int si, int bx)
630 int subDrawElectronFromAbove;
634 bx = bx - 0x1F; // get and increment sequence#
635 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
637 Y = GetStretchY(si - FieldWidth);
638 StretchedSprites.BltEx(X, Y, 0);
639 StretchedSprites.BltEx(X, Y + bx * TwoPixels, aniElectron[bx]);
640 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
642 return subDrawElectronFromAbove;
645 int subDrawElectronFromLeft(int si, int bx)
647 int subDrawElectronFromLeft;
651 bx = bx - 0x27; // get and increment sequence#
652 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
653 X = GetStretchX(si - 1);
655 StretchedSprites.BltEx(X, Y, 0);
656 StretchedSprites.BltEx(X + bx * TwoPixels, Y, aniElectron[bx]);
657 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
659 return subDrawElectronFromLeft;