rnd-20100326-2-src
[rocksndiamonds.git] / src / game_sp / Zonk.c
1 // ----------------------------------------------------------------------------
2 // Zonk.c
3 // ----------------------------------------------------------------------------
4
5 #include "Zonk.h"
6
7 // static char *VB_Name = "modZonk";
8 // --- Option Explicit
9
10 // ==========================================================================
11 //                              SUBROUTINE
12 // Animate Zonks (falling)
13 // ==========================================================================
14
15 int subAnimateZonks(int si)
16 {
17   int subAnimateZonks;
18
19   int tFld;
20
21   // PseudoRegisters:
22   // int ax, bx, cx, dx, di, X, Y;
23   int ax, bx, dx, X, Y;
24   // int ah, bh, ch, dh, al, bl, cl, dl;
25   int al, bl;
26
27   tFld = PlayField16[si];
28   if ((tFld & 0xFF) != fiZonk)
29     return subAnimateZonks;
30
31   if (tFld == fiZonk)
32   {
33     if (FreezeZonks == 2) // Do Zonks fall? (debug)
34       return subAnimateZonks;
35
36     ax = PlayField16[si + FieldWidth]; // select case playfield16(si+60)
37     if (ax == 0)
38       goto loc_g_0D64;
39
40     if (ax == fiZonk)
41       goto loc_g_0D35;
42
43     if (ax == fiInfotron)
44       goto loc_g_0D35;
45
46     if (ax == fiRAM)
47       goto loc_g_0D35;
48
49     return subAnimateZonks;
50
51 loc_g_0D35: //        Case fiZonk, fiInfotron, fiRAM
52     ax = PlayField16[si + FieldWidth - 1];
53     if (ax == 0 || ax == 0x8888 || ax == 0xAAAA)
54       goto loc_g_0D6B;
55
56 loc_g_0D4C:
57     ax = PlayField16[si + FieldWidth + 1];
58     if (ax == 0 || ax == 0x8888 || ax == 0xAAAA)
59       goto loc_g_0D81;
60
61     return subAnimateZonks;
62
63 loc_g_0D64: //       Case fiSpace
64     MovHighByte(&PlayField16[si], 0x40);
65     goto loc_g_0DA5;
66
67 loc_g_0D6B: // roll left?
68     if (PlayField16[si - 1] == 0)
69       goto loc_g_0D74;
70
71     goto loc_g_0D4C;
72
73 loc_g_0D74:
74     MovHighByte(&PlayField16[si], 0x50);
75     PlayField16[si - 1] = 0x8888;
76     goto loc_g_0DA5;
77
78 loc_g_0D81: // roll right?
79     if (PlayField16[si + 1] == 0)
80       goto loc_g_0D98;
81
82     if (PlayField16[si + 1] != 0x9999) // wow right is different from left!
83       return subAnimateZonks;
84
85     if (LowByte(PlayField16[si - FieldWidth + 1]) != 1)
86       return subAnimateZonks;
87
88 loc_g_0D98:
89     MovHighByte(&PlayField16[si], 0x60);
90     PlayField16[si + 1] = 0x8888;
91   } // tFld = fiZonk
92
93 loc_g_0DA5:
94   // from now on the zonk is definitely moving,
95   // maybe the sequence is in an advanced frame
96   // or just beeing initialized due to the code above
97   bl = HighByte(PlayField16[si]);
98   bx = 0;
99   MovLowByte(&bx, bl);
100   al = bl & 0xF0;
101   if (al == 0x10) // zonk comes falling from above
102     goto loc_g_0DE8;
103
104   if (al == 0x20) // zonk comes rolling from right to left
105     goto loc_g_0F83;
106
107   if (al == 0x30) // zonk comes rolling from left to right
108     goto loc_g_0FE8;
109
110   if (FreezeZonks == 2)
111     return subAnimateZonks;
112
113   if (al == 0x40) // zonk falls straight down
114     goto loc_g_104D;
115
116   if (al == 0x50) // zonk rolls left
117     goto loc_g_107B;
118
119   if (al == 0x60) // zonk rolls right
120     goto loc_g_10E9;
121
122   if (al == 0x70) // intermediate state
123     goto loc_g_1157;
124
125   return subAnimateZonks;
126
127 loc_g_0DE8: // zonk comes falling from above
128   //      To Do: draw zonk falling from above
129   //      according to position in (bl And &H07)
130   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
131   X = GetStretchX(si);
132   Y = GetStretchY(si - FieldWidth);
133   dx = bl & 0x7;
134   DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
135   DDSpriteBuffer_BltImg(X, Y + TwoPixels * (dx + 1), aniZonk, dx);
136   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
137
138   bl = HighByte(PlayField16[si]) + 1;
139   if (bl == 0x16)
140   {
141     MovHighByte(&PlayField16[si], bl);
142     subCleanUpForZonksAbove(si - FieldWidth);
143     return subAnimateZonks;
144   } // loc_g_0E2B:
145
146   if (bl < 0x18)
147   {
148     MovHighByte(&PlayField16[si], bl);
149     return subAnimateZonks;
150   } // loc_g_0E35:
151
152   MovHighByte(&PlayField16[si], 0); // zonk arrived at the field
153   if ((FreezeZonks & 0xFF) == 2)
154     return subAnimateZonks;
155
156   // loc_g_0E42:     // now check if the zonk may go on falling somehow
157   ax = PlayField16[si + FieldWidth];
158   if (ax == 0) // below is empty!-> go on falling 'loc_g_0E4C:
159     goto loc_g_0EDD;
160
161   if (ax == 0x9999) // below is only temporarily used ' loc_g_0E57:
162     goto loc_g_0EDD;
163
164   if ((ax & 0xFF) == fiMurphy) // Murphy dies 'loc_g_0E61:
165     goto loc_g_0F14;
166
167   if ((ax & 0xFF) == fiSnikSnak) // SnikSnak dies 'loc_g_0E6B:
168     goto loc_g_0F6E;
169
170   if (ax == 0x2BB) // loc_g_0E76:
171     goto loc_g_0F36;
172
173   if (ax == 0x4BB) // loc_g_0E81:
174     goto loc_g_0F52;
175
176   if ((ax & 0xFF) == fiElectron) // Electron cracked! 'loc_g_0E8B:
177     goto loc_g_0F6E;
178
179   if (ax == fiOrangeDisk) // OrangeDisk explodes 'loc_g_0E95:
180     goto loc_g_0F75;
181
182 #if 1
183   // play the zonk sound, 'cause zonk hits something "hard"
184   subSoundFX(si, fiZonk, actImpact);
185 #else
186   subSoundFXZonk(); // play the zonk sound,'cause zonk hits something "hard"
187 #endif
188
189   if (! (ax == fiZonk || ax == fiInfotron || ax == fiRAM))
190     return subAnimateZonks;
191
192   // loc_g_0EAE: ' Zonk rolls somewhere
193   ax = PlayField16[si + FieldWidth - 1];
194   if (ax == 0 || ax == 0x8888 || ax == 0xAAAA) // may roll left
195     goto loc_g_0EEA;
196
197   ax = PlayField16[si + FieldWidth + 1];
198   if (ax == 0 || ax == 0x8888 || ax == 0xAAAA) // may roll right
199     goto loc_g_0F00;
200
201   return subAnimateZonks;
202
203 loc_g_0EDD:     // go on falling down?
204   PlayField16[si] = 0x7001; // go into intermediate waitstate
205   PlayField16[si + FieldWidth] = 0x9999; // mark as "zonk waiting to access"
206   return subAnimateZonks;
207
208 loc_g_0EEA:     // test if zonk may roll left
209   // This if(if true) jumps up far above
210   // to the according rountine for fixed zonks!
211   if (PlayField16[si - 1] != 0) // Remarkable!!! ' loc_g_0EF4:
212     goto loc_g_0D4C;
213
214   MovHighByte(&PlayField16[si], 0x50); // zonk rolls left
215   PlayField16[si - 1] = 0x8888; // mark as zonk accessing?
216   return subAnimateZonks;
217
218 loc_g_0F00:     // test if zonk may roll right
219   if (PlayField16[si + 1] != 0) // loc_g_0F08:
220     return subAnimateZonks;
221
222   MovHighByte(&PlayField16[si], 0x60); // zonk rolls right
223   PlayField16[si + 1] = 0x8888; // mark as zonk accessing?
224   return subAnimateZonks;
225
226 loc_g_0F14:     // Murphy dies, but not in any case
227   bl = HighByte(PlayField16[si + FieldWidth]);
228   if (bl == 0xE || bl == 0xF || bl == 0x28)
229     return subAnimateZonks;
230
231   if (bl == 0x29 || bl == 0x25 || bl == 0x26)
232     return subAnimateZonks;
233
234 loc_g_0F36:     // ??
235   ax = LowByte(PlayField16[si + FieldWidth - 1]);
236   if (ax == fiElectron) // loc_g_0F43:
237     PlayField16[si + FieldWidth] = fiElectron;
238
239   if (ax != 0x1F)
240     PlayField16[si + FieldWidth - 1] = 0;
241
242   goto loc_g_0F6E;
243
244 loc_g_0F52:     // ??
245   ax = LowByte(PlayField16[si + FieldWidth + 1]);
246   if (ax == fiElectron) // loc_g_0F5F:
247     PlayField16[si + FieldWidth] = fiElectron;
248
249   if (ax != 0x1F)
250     PlayField16[si + FieldWidth + 1] = 0;
251
252   goto loc_g_0F6E;
253
254 loc_g_0F6E:     // someone dies/explodes
255   si = si + FieldWidth;                 // 1 field down
256   ExplodeFieldSP(si);               // Explode
257   return subAnimateZonks;
258
259 loc_g_0F75:     // OrangeDisk explodes next cycle
260   si = si + FieldWidth;                 // 1 field down
261   PlayField8[si] = fiHardWare;
262   return subAnimateZonks;
263
264 loc_g_0F83: // zonk comes rolling from right to left
265   //  To Do: draw zonk rolling from right
266   //  according to position in (bl And &H07)
267   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
268   X = GetStretchX(si + 1);
269   Y = GetStretchY(si);
270   dx = (bl & 0x7) + 1;
271   DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
272   DDSpriteBuffer_BltImg(X - (TwoPixels * dx), Y, aniZonkRollLeft, dx - 1);
273   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
274
275   bl = HighByte(PlayField16[si]) + 1; // get and increment sequence#
276   if (bl == 0x24)
277     PlayField16[si + 1] = 0xAAAA;
278
279   if (bl == 0x26)
280   {
281     MovHighByte(&PlayField16[si], bl);
282     subCleanUpForZonksAbove(si + 1);
283   }
284   else if (bl < 0x28)
285   {
286     MovHighByte(&PlayField16[si], bl);
287   }
288   else
289   {
290     PlayField16[si] = 0xFFFF;
291     si = si + FieldWidth;                 // 1 field down
292     PlayField16[si] = 0x1001; // convert rolling zonk to a falling zonk
293   }
294
295   return subAnimateZonks;
296
297 loc_g_0FE8: // zonk comes rolling from left to right
298   //  To Do: draw zonk rolling from left
299   //  according to position in (bl And &H07)
300   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
301   X = GetStretchX(si - 1);
302   Y = GetStretchY(si);
303   dx = (bl & 0x7) + 1;
304   DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
305   DDSpriteBuffer_BltImg(X + (TwoPixels * dx), Y, aniZonkRollRight, dx - 1);
306   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
307
308   bl = HighByte(PlayField16[si]) + 1;
309   if (bl == 0x34)
310     PlayField16[si - 1] = 0xAAAA;
311
312   if (bl == 0x36)
313   {
314     MovHighByte(&PlayField16[si], bl);
315     subCleanUpForZonksAbove(si - 1);
316   }
317   else if (bl < 0x38)
318   {
319     MovHighByte(&PlayField16[si], bl);
320   }
321   else
322   {
323     PlayField16[si] = 0xFFFF;
324     si = si + FieldWidth;                   // 1 field down
325     PlayField16[si] = 0x1001; // convert rolling zonk to a falling zonk
326   }
327
328   return subAnimateZonks;
329
330 loc_g_104D: // zonk falls straight down
331   bl = bl + 1;
332   if (bl < 0x42)
333   {
334     MovHighByte(&PlayField16[si], bl);
335   }
336   else if (PlayField16[si + FieldWidth] != 0)
337   {
338     bl = bl - 1; // stay waiting
339     MovHighByte(&PlayField16[si], bl);
340   }
341   else
342   {
343     PlayField16[si] = 0xFFFF; // mark as "zonk leaving"
344     si = si + FieldWidth;                 // 1 field down
345     PlayField16[si] = 0x1001; // go falling
346   }
347
348   return subAnimateZonks;
349
350 loc_g_107B: // zonk rolls left
351   //  To Do: draw zonk rolling to left
352   //  according to position in (bl And &H0F)
353   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
354   X = GetStretchX(si);
355   Y = GetStretchY(si);
356   dx = (bl & 0xF) + 1;
357   DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
358   DDSpriteBuffer_BltImg(X - (TwoPixels * dx), Y, aniZonkRollLeft, dx - 1);
359   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
360
361   bl = HighByte(PlayField16[si]) + 1; // retrieve and increment sequence#
362   if (bl < 0x52)
363   {
364     MovHighByte(&PlayField16[si], bl);
365     return subAnimateZonks;
366   }
367
368   if (PlayField16[si + FieldWidth - 1] != 0)
369     goto loc_g_10E2;
370
371   if (PlayField16[si - 1] != 0)
372   {
373     if (PlayField16[si - 1] != 0x8888)
374       goto loc_g_10E2;
375   } // loc_g_10C8:
376
377   PlayField16[si] = 0xFFFF;
378   si = si - 1;                   // 1 field left
379   PlayField16[si] = 0x2201;
380   PlayField16[si + FieldWidth] = 0xFFFF;
381   return subAnimateZonks;
382
383 loc_g_10E2: // stay waiting
384   bl = bl - 1;
385   MovHighByte(&PlayField16[si], bl);
386   return subAnimateZonks;
387
388 loc_g_10E9: // zonk rolls right
389   //  To Do: draw zonk rolling to right
390   //  according to position in (bl And &H07)
391   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
392   X = GetStretchX(si);
393   Y = GetStretchY(si);
394   dx = (bl & 0x7) + 1;
395   DDSpriteBuffer_BltImg(X, Y, aniSpace, 0);
396   DDSpriteBuffer_BltImg(X + (TwoPixels * dx), Y, aniZonkRollRight, dx - 1);
397   // +++++++++++++++++++++++++++++++++++++++++++++++++++++
398
399   bl = HighByte(PlayField16[si]) + 1;
400   if (bl < 0x62)
401   {
402     MovHighByte(&PlayField16[si], bl);
403     return subAnimateZonks;
404   }
405
406   if (PlayField16[si + FieldWidth + 1] != 0)
407     goto loc_g_1150;
408
409   if (PlayField16[si + 1] != 0)
410   {
411     if (PlayField16[si + 1] != 0x8888)
412       goto loc_g_1150;
413   }
414
415   PlayField16[si] = 0xFFFF;
416   si = si + 1;
417   PlayField16[si] = 0x3201;
418   PlayField16[si + FieldWidth] = 0xFFFF;
419   return subAnimateZonks;
420
421 loc_g_1150: // stay waiting
422   bl = bl - 1;
423   MovHighByte(&PlayField16[si], bl);
424   return subAnimateZonks;
425
426 loc_g_1157: // intermediate state
427   ax = PlayField16[si + FieldWidth];
428   if (ax == 0 || ax == 0x9999)
429   {
430     PlayField16[si] = 0xFFFF;
431     si = si + FieldWidth;                 // 1 field down
432     PlayField16[si] = 0x1001; // start falling down
433     goto loc_g_0DE8;
434   }
435
436   return subAnimateZonks;
437 } // subAnimateZonks endp
438
439 int subCleanUpForZonksAbove(int si)
440 {
441   int subCleanUpForZonksAbove;
442
443   int ax;
444
445   if (LowByte(PlayField16[si]) != fiExplosion)
446     PlayField16[si] = 0;
447
448   if (PlayField16[si - FieldWidth] != 0)
449   {
450     if (PlayField16[si - FieldWidth] != 0x9999)
451       return subCleanUpForZonksAbove;
452
453     if (LowByte(PlayField16[si - 2 * FieldWidth]) != fiInfotron)
454       return subCleanUpForZonksAbove;
455   } // loc_g_1674:
456
457   if (PlayField16[si - FieldWidth - 1] != fiZonk)
458   {
459     if (PlayField16[si - FieldWidth + 1] != fiZonk)
460       return subCleanUpForZonksAbove;
461
462     goto loc_g_16A7;
463   }
464
465   ax = PlayField16[si - 1];
466   if (ax == fiZonk || ax == fiInfotron || ax == fiRAM)
467   {
468     PlayField16[si - FieldWidth - 1] = 0x6001;
469     PlayField16[si - FieldWidth] = 0x8888;
470     return subCleanUpForZonksAbove;
471   }
472
473   if (PlayField16[si - FieldWidth + 1] != fiZonk)
474     return subCleanUpForZonksAbove;
475
476 loc_g_16A7:
477   ax = PlayField16[si + 1];
478   if (ax == fiZonk || ax == fiInfotron || ax == fiRAM)
479   {
480     PlayField16[si - FieldWidth + 1] = 0x5001;
481     PlayField16[si - FieldWidth] = 0x8888;
482   }
483
484   return subCleanUpForZonksAbove;
485 } // subCleanUpForZonksAbove