rnd-20050103-1-src
[rocksndiamonds.git] / src / game_em / synchro_1.c
1 /* first part of synchro.
2  *
3  * game logic for players.
4  *
5  * large switch statement for tiles the player interacts with.
6  */
7
8 #include "tile.h"
9 #include "level.h"
10 #include "sample.h"
11 #include "display.h"
12
13
14 static void player(struct PLAYER *);
15 static int test(struct PLAYER *);
16 static void die(struct PLAYER *);
17
18 void synchro_1(void)
19 {
20  /* must test for death and actually kill separately */
21   char ply1_kill = test(&ply1);
22   char ply2_kill = test(&ply2);
23
24   if (ply1.alive && ply1_kill)
25     die(&ply1);
26   if (ply2.alive && ply2_kill)
27     die(&ply2);
28
29 #if 0
30   ply1.alive = 1; /* debugging */
31 #endif
32
33   ply1.oldx = ply1.x;
34   ply1.oldy = ply1.y;
35   ply1.anim = SPR_still;
36   ply2.oldx = ply2.x;
37   ply2.oldy = ply2.y;
38   ply2.anim = SPR_still;
39
40   if (Random & 256)
41   {
42     if (ply1.alive) player(&ply1);
43     if (ply2.alive) player(&ply2);
44   }
45   else
46   {
47     if (ply2.alive) player(&ply2);
48     if (ply1.alive) player(&ply1);
49   }
50
51   if (ply1.alive)
52   {
53     if (Cave[ply1.oldy][ply1.oldx] == Zplayer)
54     {
55       Cave[ply1.oldy][ply1.oldx] = Xblank;
56       Next[ply1.oldy][ply1.oldx] = Xblank;
57     }
58
59     if (Cave[ply1.y][ply1.x] == Xblank)
60     {
61       Cave[ply1.y][ply1.x] = Zplayer;
62       Next[ply1.y][ply1.x] = Zplayer;
63     }
64   }
65
66   if (ply2.alive)
67   {
68     if (Cave[ply2.oldy][ply2.oldx] == Zplayer)
69     {
70       Cave[ply2.oldy][ply2.oldx] = Xblank;
71       Next[ply2.oldy][ply2.oldx] = Xblank;
72     }
73
74     if (Cave[ply2.y][ply2.x] == Xblank)
75     {
76       Cave[ply2.y][ply2.x] = Zplayer;
77       Next[ply2.y][ply2.x] = Zplayer;
78     }
79   }
80 }
81
82 static int test(struct PLAYER *ply)
83 {
84   register unsigned int x = ply->x;
85   register unsigned int y = ply->y;
86
87   if (!ply->alive)
88     return 0;
89
90   if (lev.time_initial > 0 && lev.time == 0)
91     return 1;
92
93   switch(Cave[y-1][x])
94   {
95     case Xbug_n:
96     case Xbug_e:
97     case Xbug_s:
98     case Xbug_w:
99     case Xbug_gon:
100     case Xbug_goe:
101     case Xbug_gos:
102     case Xbug_gow:
103     case Xtank_n:
104     case Xtank_e:
105     case Xtank_s:
106     case Xtank_w:
107     case Xtank_gon:
108     case Xtank_goe:
109     case Xtank_gos:
110     case Xtank_gow:
111       return 1;
112   }
113
114   switch(Cave[y][x+1])
115   {
116     case Xbug_n:
117     case Xbug_e:
118     case Xbug_s:
119     case Xbug_w:
120     case Xbug_gon:
121     case Xbug_goe:
122     case Xbug_gos:
123     case Xbug_gow:
124     case Xtank_n:
125     case Xtank_e:
126     case Xtank_s:
127     case Xtank_w:
128     case Xtank_gon:
129     case Xtank_goe:
130     case Xtank_gos:
131     case Xtank_gow:
132       return 1;
133   }
134
135   switch(Cave[y+1][x])
136   {
137     case Xbug_n:
138     case Xbug_e:
139     case Xbug_s:
140     case Xbug_w:
141     case Xbug_gon:
142     case Xbug_goe:
143     case Xbug_gos:
144     case Xbug_gow:
145     case Xtank_n:
146     case Xtank_e:
147     case Xtank_s:
148     case Xtank_w:
149     case Xtank_gon:
150     case Xtank_goe:
151     case Xtank_gos:
152     case Xtank_gow:
153       return 1;
154   }
155
156   switch(Cave[y][x-1])
157   {
158     case Xbug_n:
159     case Xbug_e:
160     case Xbug_s:
161     case Xbug_w:
162     case Xbug_gon:
163     case Xbug_goe:
164     case Xbug_gos:
165     case Xbug_gow:
166     case Xtank_n:
167     case Xtank_e:
168     case Xtank_s:
169     case Xtank_w:
170     case Xtank_gon:
171     case Xtank_goe:
172     case Xtank_gos:
173     case Xtank_gow:
174       return 1;
175   }
176
177   switch(Cave[y][x])
178   {
179     case Xblank:
180     case Yacid_splash_eB:
181     case Yacid_splash_wB:
182     case Zplayer:
183     case Xdynamite_1:
184     case Xdynamite_2:
185     case Xdynamite_3:
186     case Xdynamite_4:
187       return 0;
188   }
189
190   return 1;
191 }
192
193 static void die(struct PLAYER *ply)
194 {
195   register unsigned int x = ply->x;
196   register unsigned int y = ply->y;
197
198   ply->alive = 0;
199
200   switch(Cave[y-1][x])
201   {
202     case Xbug_n:
203     case Xbug_e:
204     case Xbug_s:
205     case Xbug_w:
206     case Xbug_gon:
207     case Xbug_goe:
208     case Xbug_gos:
209     case Xbug_gow:
210       Cave[y-1][x] = Xboom_bug;
211 #if 0
212       play_element_sound(x, y, SAMPLE_boom, Zplayer);
213 #endif
214       break;
215
216     case Xtank_n:
217     case Xtank_e:
218     case Xtank_s:
219     case Xtank_w:
220     case Xtank_gon:
221     case Xtank_goe:
222     case Xtank_gos:
223     case Xtank_gow:
224       Cave[y-1][x] = Xboom_bomb;
225 #if 0
226       play_element_sound(x, y, SAMPLE_boom, Zplayer);
227 #endif
228       break;
229   }
230
231   switch(Cave[y][x+1])
232   {
233     case Xbug_n:
234     case Xbug_e:
235     case Xbug_s:
236     case Xbug_w:
237     case Xbug_gon:
238     case Xbug_goe:
239     case Xbug_gos:
240     case Xbug_gow:
241       Cave[y][x+1] = Xboom_bug;
242 #if 0
243       play_element_sound(x, y, SAMPLE_boom, Zplayer);
244 #endif
245       break;
246
247     case Xtank_n:
248     case Xtank_e:
249     case Xtank_s:
250     case Xtank_w:
251     case Xtank_gon:
252     case Xtank_goe:
253     case Xtank_gos:
254     case Xtank_gow:
255       Cave[y][x+1] = Xboom_bomb;
256 #if 0
257       play_element_sound(x, y, SAMPLE_boom, Zplayer);
258 #endif
259       break;
260   }
261
262   switch(Cave[y+1][x])
263   {
264     case Xbug_n:
265     case Xbug_e:
266     case Xbug_s:
267     case Xbug_w:
268     case Xbug_gon:
269     case Xbug_goe:
270     case Xbug_gos:
271     case Xbug_gow:
272       Cave[y+1][x] = Xboom_bug;
273 #if 0
274       play_element_sound(x, y, SAMPLE_boom, Zplayer);
275 #endif
276       break;
277
278     case Xtank_n:
279     case Xtank_e:
280     case Xtank_s:
281     case Xtank_w:
282     case Xtank_gon:
283     case Xtank_goe:
284     case Xtank_gos:
285     case Xtank_gow:
286       Cave[y+1][x] = Xboom_bomb;
287 #if 0
288       play_element_sound(x, y, SAMPLE_boom, Zplayer);
289 #endif
290       break;
291   }
292
293   switch(Cave[y][x-1])
294   {
295     case Xbug_n:
296     case Xbug_e:
297     case Xbug_s:
298     case Xbug_w:
299     case Xbug_gon:
300     case Xbug_goe:
301     case Xbug_gos:
302     case Xbug_gow:
303       Cave[y][x-1] = Xboom_bug;
304 #if 0
305       play_element_sound(x, y, SAMPLE_boom, Zplayer);
306 #endif
307       break;
308
309     case Xtank_n:
310     case Xtank_e:
311     case Xtank_s:
312     case Xtank_w:
313     case Xtank_gon:
314     case Xtank_goe:
315     case Xtank_gos:
316     case Xtank_gow:
317       Cave[y][x-1] = Xboom_bomb;
318 #if 0
319       play_element_sound(x, y, SAMPLE_boom, Zplayer);
320 #endif
321       break;
322   }
323
324   switch(Cave[y][x])
325   {
326     case Xexit_1:
327     case Xexit_2:
328     case Xexit_3:
329       play_element_sound(x, y, SAMPLE_exit, Xexit_1);
330       break;
331
332     default:
333       play_element_sound(x, y, SAMPLE_die, Zplayer);
334       break;
335   }
336
337   Cave[y][x] = Xboom_1;
338   Boom[y][x] = Xblank;
339 }
340
341 static void player(struct PLAYER *ply)
342 {
343   register unsigned int x = ply->x;
344   register unsigned int y = ply->y;
345   unsigned int anim = 0;        /* initialized to make compilers happy */
346   int dx = 0, dy = 0;
347
348   if ((ply->joy_spin = !ply->joy_spin))
349   {
350     if (ply->joy_n)
351     {
352       y--;
353       dy = -1;
354       anim = 0;
355       /* north */
356     }
357     else if (ply->joy_e)
358     {
359       x++;
360       dx = 1;
361       anim = 1;
362       /* east */
363     }
364     else if (ply->joy_s)
365     {
366       y++;
367       dy = 1;
368       anim = 2;
369       /* south */
370     }
371     else if (ply->joy_w)
372     {
373       x--;
374       dx = -1;
375       anim = 3;
376       /* west */
377     }
378   }
379   else
380   {
381     if (ply->joy_w)
382     {
383       x--;
384       dx = -1;
385       anim = 3;
386       /* west */
387     }
388     else if (ply->joy_s)
389     {
390       y++;
391       dy = 1;
392       anim = 2;
393       /* south */
394     }
395     else if (ply->joy_e)
396     {
397       x++;
398       dx = 1;
399       anim = 1;
400       /* east */
401     }
402     else if (ply->joy_n)
403     {
404       y--;
405       dy = -1;
406       anim = 0;
407       /* north */
408     }
409   }
410
411   if (dx == 0 && dy == 0)
412   {
413     ply->joy_stick = 0;
414
415     if (ply->joy_fire)
416     {
417       if (++ply->dynamite_cnt == 5 && ply->dynamite)
418       {
419         Cave[y][x] = Xdynamite_1;
420         play_element_sound(x, y, SAMPLE_dynamite, Xdynamite_1);
421         ply->dynamite--;
422       }
423     }
424     else
425     {
426       ply->dynamite_cnt = 0;
427     }
428
429     Random += 7; /* bit more random if we dont move */
430
431     return;
432   }
433
434   ply->joy_stick = 1;
435   ply->joy_n = ply->joy_e = ply->joy_s = ply->joy_w = 0;
436   ply->dynamite_cnt = 0; /* reset dynamite timer if we move */
437
438   if (ply->joy_fire == 0)
439   {
440     int element = Cave[y][x];
441
442     switch(Cave[y][x])
443     {
444       /* fire is released */
445       case Xblank:
446       case Yacid_splash_eB:
447       case Yacid_splash_wB:
448         Cave[y][x] = Zplayer;
449         Next[y][x] = Zplayer;
450         play_element_sound(x, y, SAMPLE_blank, Xblank);
451         ply->anim = SPR_walk + anim;
452         ply->x = x;
453         ply->y = y;
454         break;
455
456       case Xboom_android:
457       case Xboom_1:
458       case Xbug_n:
459       case Xbug_e:
460       case Xbug_s:
461       case Xbug_w:
462       case Xbug_gon:
463       case Xbug_goe:
464       case Xbug_gos:
465       case Xbug_gow:
466       case Xtank_n:
467       case Xtank_e:
468       case Xtank_s:
469       case Xtank_w:
470       case Xtank_gon:
471       case Xtank_goe:
472       case Xtank_gos:
473       case Xtank_gow:
474       case Xacid_1:
475       case Xacid_2:
476       case Xacid_3:
477       case Xacid_4:
478       case Xacid_5:
479       case Xacid_6:
480       case Xacid_7:
481       case Xacid_8:
482         ply->anim = SPR_walk + anim;
483         ply->x = x;
484         ply->y = y;
485         break;
486
487       case Xgrass:
488         Cave[y][x] = (dy ? (dy < 0 ? Ygrass_nB : Ygrass_sB) :
489                       (dx > 0 ? Ygrass_eB : Ygrass_wB));
490         Next[y][x] = Zplayer;
491         play_element_sound(x, y, SAMPLE_dirt, Xgrass);
492         ply->anim = SPR_walk + anim;
493         ply->x = x;
494         ply->y = y;
495         break;
496
497       case Xdirt:
498         Cave[y][x] = (dy ? (dy < 0 ? Ydirt_nB : Ydirt_sB) :
499                       (dx > 0 ? Ydirt_eB : Ydirt_wB));
500         Next[y][x] = Zplayer;
501         play_element_sound(x, y, SAMPLE_dirt, Xdirt);
502         ply->anim = SPR_walk + anim;
503         ply->x = x;
504         ply->y = y;
505         break;
506
507       case Xdiamond:
508       case Xdiamond_pause:
509         Cave[y][x] = Ydiamond_eat;
510         Next[y][x] = Zplayer;
511         play_element_sound(x, y, SAMPLE_collect, element);
512         lev.score += lev.diamond_score;
513         lev.required = lev.required < 3 ? 0 : lev.required - 3;
514         ply->anim = SPR_walk + anim;
515         ply->x = x;
516         ply->y = y;
517         break;
518
519       case Xemerald:
520       case Xemerald_pause:
521         Cave[y][x] = Yemerald_eat;
522         Next[y][x] = Zplayer;
523         play_element_sound(x, y, SAMPLE_collect, element);
524         lev.score += lev.emerald_score;
525         lev.required = lev.required < 1 ? 0 : lev.required - 1;
526         ply->anim = SPR_walk + anim;
527         ply->x = x;
528         ply->y = y;
529         break;
530
531       case Xdynamite:
532         Cave[y][x] = Ydynamite_eat;
533         Next[y][x] = Zplayer;
534         play_element_sound(x, y, SAMPLE_collect, element);
535         lev.score += lev.dynamite_score;
536         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
537         ply->anim = SPR_walk + anim;
538         ply->x = x;
539         ply->y = y;
540         break;
541
542       case Xkey_1:
543         ply->keys |= 0x01;
544         Cave[y][x] = Ykey_1_eat;
545         goto key_walk;
546
547       case Xkey_2:
548         ply->keys |= 0x02;
549         Cave[y][x] = Ykey_2_eat;
550         goto key_walk;
551
552       case Xkey_3:
553         ply->keys |= 0x04;
554         Cave[y][x] = Ykey_3_eat;
555         goto key_walk;
556
557       case Xkey_4:
558         ply->keys |= 0x08;
559         Cave[y][x] = Ykey_4_eat;
560         goto key_walk;
561
562       case Xkey_5:
563         ply->keys |= 0x10;
564         Cave[y][x] = Ykey_5_eat;
565         goto key_walk;
566
567       case Xkey_6:
568         ply->keys |= 0x20;
569         Cave[y][x] = Ykey_6_eat;
570         goto key_walk;
571
572       case Xkey_7:
573         ply->keys |= 0x40;
574         Cave[y][x] = Ykey_7_eat;
575         goto key_walk;
576
577       case Xkey_8:
578         ply->keys |= 0x80;
579         Cave[y][x] = Ykey_8_eat;
580         goto key_walk;
581
582       key_walk:
583
584         Next[y][x] = Zplayer;
585         play_element_sound(x, y, SAMPLE_collect, element);
586         lev.score += lev.key_score;
587         ply->anim = SPR_walk + anim;
588         ply->x = x;
589         ply->y = y;
590         break;
591
592       case Xlenses:
593         Cave[y][x] = Ylenses_eat;
594         Next[y][x] = Zplayer;
595         play_element_sound(x, y, SAMPLE_collect, element);
596         lev.score += lev.lenses_score;
597         lev.lenses_cnt = lev.lenses_time;
598         ply->anim = SPR_walk + anim;
599         ply->x = x;
600         ply->y = y;
601         break;
602
603       case Xmagnify:
604         Cave[y][x] = Ymagnify_eat;
605         Next[y][x] = Zplayer;
606         play_element_sound(x, y, SAMPLE_collect, element);
607         lev.score += lev.magnify_score;
608         lev.magnify_cnt = lev.magnify_time;
609         ply->anim = SPR_walk + anim;
610         ply->x = x;
611         ply->y = y;
612         break;
613
614       case Xstone:
615         if (dy)
616           break;
617
618         switch(Cave[y][x+dx])
619         {
620           case Xacid_1:
621           case Xacid_2:
622           case Xacid_3:
623           case Xacid_4:
624           case Xacid_5:
625           case Xacid_6:
626           case Xacid_7:
627           case Xacid_8:
628             if (Cave[y-1][x+dx+1] == Xblank)
629               Cave[y-1][x+dx+1] = Yacid_splash_eB;
630             if (Cave[y-1][x+dx-1] == Xblank)
631               Cave[y-1][x+dx-1] = Yacid_splash_wB;
632             play_sound(x, y, SAMPLE_acid);
633             goto stone_walk;
634
635           case Xblank:
636           case Yacid_splash_eB:
637           case Yacid_splash_wB:
638             Cave[y][x+dx] = dx > 0 ? Ystone_e : Ystone_w;
639             Next[y][x+dx] = Xstone_pause;
640
641           stone_walk:
642
643             Cave[y][x] = dx > 0 ? Ystone_eB : Ystone_wB;
644             Next[y][x] = Zplayer;
645             play_element_sound(x, y, SAMPLE_roll, Xstone);
646             ply->x = x;
647         }
648
649         ply->anim = SPR_push + anim;
650         break;
651
652       case Xbomb:
653         if (dy)
654           break;
655
656         switch(Cave[y][x+dx])
657         {
658           case Xacid_1:
659           case Xacid_2:
660           case Xacid_3:
661           case Xacid_4:
662           case Xacid_5:
663           case Xacid_6:
664           case Xacid_7:
665           case Xacid_8:
666             if (Cave[y-1][x+dx+1] == Xblank)
667               Cave[y-1][x+dx+1] = Yacid_splash_eB;
668             if (Cave[y-1][x+dx-1] == Xblank)
669               Cave[y-1][x+dx-1] = Yacid_splash_wB;
670             play_sound(x, y, SAMPLE_acid);
671             goto bomb_walk;
672
673           case Xblank:
674           case Yacid_splash_eB:
675           case Yacid_splash_wB:
676             Cave[y][x+dx] = dx > 0 ? Ybomb_e : Ybomb_w;
677             Next[y][x+dx] = Xbomb_pause;
678
679           bomb_walk:
680
681             Cave[y][x] = dx > 0 ? Ybomb_eB : Ybomb_wB;
682             Next[y][x] = Zplayer;
683             play_element_sound(x, y, SAMPLE_roll, Xbomb);
684             ply->x = x;
685         }
686
687         ply->anim = SPR_push + anim;
688         break;
689
690       case Xnut:
691         if (dy)
692           break;
693
694         switch(Cave[y][x+dx])
695         {
696           case Xacid_1:
697           case Xacid_2:
698           case Xacid_3:
699           case Xacid_4:
700           case Xacid_5:
701           case Xacid_6:
702           case Xacid_7:
703           case Xacid_8:
704             if (Cave[y-1][x+dx+1] == Xblank)
705               Cave[y-1][x+dx+1] = Yacid_splash_eB;
706             if (Cave[y-1][x+dx-1] == Xblank)
707               Cave[y-1][x+dx-1] = Yacid_splash_wB;
708             play_sound(x, y, SAMPLE_acid);
709             goto nut_walk;
710
711           case Xblank:
712           case Yacid_splash_eB:
713           case Yacid_splash_wB:
714             Cave[y][x+dx] = dx > 0 ? Ynut_e : Ynut_w;
715             Next[y][x+dx] = Xnut_pause;
716
717           nut_walk:
718
719             Cave[y][x] = dx > 0 ? Ynut_eB : Ynut_wB;
720             Next[y][x] = Zplayer;
721             play_element_sound(x, y, SAMPLE_roll, Xnut);
722             ply->x = x;
723         }
724
725         ply->anim = SPR_push + anim;
726         break;
727
728       case Xspring:
729         if (dy)
730           break;
731
732         switch(Cave[y][x+dx])
733         {
734           case Xalien:
735           case Xalien_pause:
736             Cave[y][x] = dx > 0 ? Yspring_kill_eB : Yspring_kill_wB;
737             Cave[y][x+dx] = dx > 0 ? Yspring_kill_e : Yspring_kill_w;
738             Next[y][x] = Zplayer;
739             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
740             play_element_sound(x, y, SAMPLE_slurp, Xalien);
741             lev.score += lev.slurp_score;
742             ply->x = x;
743             break;
744
745           case Xacid_1:
746           case Xacid_2:
747           case Xacid_3:
748           case Xacid_4:
749           case Xacid_5:
750           case Xacid_6:
751           case Xacid_7:
752           case Xacid_8:
753             if (Cave[y-1][x+dx+1] == Xblank)
754               Cave[y-1][x+dx+1] = Yacid_splash_eB;
755             if (Cave[y-1][x+dx-1] == Xblank)
756               Cave[y-1][x+dx-1] = Yacid_splash_wB;
757             play_sound(x, y, SAMPLE_acid);
758             goto spring_walk;
759
760           case Xblank:
761           case Yacid_splash_eB:
762           case Yacid_splash_wB:
763             Cave[y][x+dx] = dx > 0 ? Yspring_e : Yspring_w;
764             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
765
766           spring_walk:
767             Cave[y][x] = dx > 0 ? Yspring_eB : Yspring_wB;
768             Next[y][x] = Zplayer;
769             play_element_sound(x, y, SAMPLE_roll, Xspring);
770             ply->x = x;
771         }
772
773         ply->anim = SPR_push + anim;
774         break;
775
776       case Xspring_pause:
777       case Xstone_pause:
778       case Xbomb_pause:
779       case Xnut_pause:
780       case Xsand_stonein_1:
781       case Xsand_stonein_2:
782       case Xsand_stonein_3:
783       case Xsand_stonein_4:
784         if (dy)
785           break;
786
787         ply->anim = SPR_push + anim;
788         break;
789
790       case Xballoon:
791         switch(Cave[y+dy][x+dx])
792         {
793           case Xacid_1:
794           case Xacid_2:
795           case Xacid_3:
796           case Xacid_4:
797           case Xacid_5:
798           case Xacid_6:
799           case Xacid_7:
800           case Xacid_8:
801             if (Cave[y+dy-1][x+dx+1] == Xblank)
802               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
803             if (Cave[y+dy-1][x+dx-1] == Xblank)
804               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
805             play_sound(x, y, SAMPLE_acid);
806             goto balloon_walk;
807
808           case Xblank:
809           case Yacid_splash_eB:
810           case Yacid_splash_wB:
811             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yballoon_n : Yballoon_s) :
812                                 (dx > 0 ? Yballoon_e : Yballoon_w));
813             Next[y+dy][x+dx] = Xballoon;
814
815           balloon_walk:
816             Cave[y][x] = (dy ? (dy < 0 ? Yballoon_nB : Yballoon_sB) :
817                           (dx > 0 ? Yballoon_eB : Yballoon_wB));
818             Next[y][x] = Zplayer;
819             play_element_sound(x, y, SAMPLE_push, Xballoon);
820             ply->x = x;
821             ply->y = y;
822         }
823
824         ply->anim = SPR_push + anim;
825         break;
826
827       case Xandroid:
828       case Xandroid_1_n:
829       case Xandroid_2_n:
830       case Xandroid_1_e:
831       case Xandroid_2_e:
832       case Xandroid_1_s:
833       case Xandroid_2_s:
834       case Xandroid_1_w:
835       case Xandroid_2_w:
836         switch(Cave[y+dy][x+dx])
837         {
838           case Xacid_1:
839           case Xacid_2:
840           case Xacid_3:
841           case Xacid_4:
842           case Xacid_5:
843           case Xacid_6:
844           case Xacid_7:
845           case Xacid_8:
846             if (Cave[y+dy-1][x+dx+1] == Xblank)
847               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
848             if (Cave[y+dy-1][x+dx-1] == Xblank)
849               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
850             play_sound(x, y, SAMPLE_acid);
851             goto android_walk;
852
853           case Xblank:
854           case Yacid_splash_eB:
855           case Yacid_splash_wB:
856             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yandroid_n : Yandroid_s) :
857                                 (dx > 0 ? Yandroid_e : Yandroid_w));
858             Next[y+dy][x+dx] = (dy ? (dy < 0 ? Xandroid_2_n : Xandroid_2_s) :
859                                 (dx > 0 ? Xandroid_2_e : Xandroid_2_w));
860
861           android_walk:
862             Cave[y][x] = (dy ? (dy < 0 ? Yandroid_nB : Yandroid_sB) :
863                           (dx > 0 ? Yandroid_eB : Yandroid_wB));
864             Next[y][x] = Zplayer;
865             play_element_sound(x, y, SAMPLE_push, Xandroid);
866             ply->x = x;
867             ply->y = y;
868         }
869
870         ply->anim = SPR_push + anim;
871         break;
872
873       case Xdoor_1:
874       case Xfake_door_1:
875         if (ply->keys & 0x01)
876           goto door_walk;
877         else
878           break;
879
880       case Xdoor_2:
881       case Xfake_door_2:
882         if (ply->keys & 0x02)
883           goto door_walk;
884         else
885           break;
886
887       case Xdoor_3:
888       case Xfake_door_3:
889         if (ply->keys & 0x04)
890           goto door_walk;
891         else
892           break;
893
894       case Xdoor_4:
895       case Xfake_door_4:
896         if (ply->keys & 0x08)
897           goto door_walk;
898         else
899           break;
900
901       case Xdoor_5:
902       case Xfake_door_5:
903         if (ply->keys & 0x10)
904           goto door_walk;
905         else
906           break;
907
908       case Xdoor_6:
909       case Xfake_door_6:
910         if (ply->keys & 0x20)
911           goto door_walk;
912         else
913           break;
914
915       case Xdoor_7:
916       case Xfake_door_7:
917         if (ply->keys & 0x40)
918           goto door_walk;
919         else
920           break;
921
922       case Xdoor_8:
923       case Xfake_door_8:
924         if (ply->keys & 0x80)
925           goto door_walk;
926         else
927           break;
928
929       door_walk:
930         if (!tab_blank[Cave[y+dy][x+dx]])
931           break;
932
933         Cave[y+dy][x+dx] = Zplayer;
934         Next[y+dy][x+dx] = Zplayer;
935         play_element_sound(x, y, SAMPLE_door, element);
936         ply->anim = SPR_walk + anim;
937         ply->x = x + dx;
938         ply->y = y + dy;
939         break;
940
941       case Xwheel:
942         play_element_sound(x, y, SAMPLE_press, element);
943         lev.wheel_cnt = lev.wheel_time;
944         lev.wheel_x = x;
945         lev.wheel_y = y;
946         break;
947
948       case Xwind_n:
949         lev.wind_direction = 0;
950         goto wind_walk;
951
952       case Xwind_e:
953         lev.wind_direction = 1;
954         goto wind_walk;
955
956       case Xwind_s:
957         lev.wind_direction = 2;
958         goto wind_walk;
959
960       case Xwind_w:
961         lev.wind_direction = 3;
962         goto wind_walk;
963
964       case Xwind_nesw:
965         lev.wind_direction = dy ? (dy < 0 ? 0 : 2) : (dx > 0 ? 1 : 3);
966         goto wind_walk;
967
968       wind_walk:
969         play_element_sound(x, y, SAMPLE_press, element);
970         lev.wind_cnt = lev.wind_time;
971         break;
972
973       case Xwind_stop:
974         play_element_sound(x, y, SAMPLE_press, element);
975         lev.wind_cnt = 0;
976         break;
977
978       case Xswitch:
979         play_element_sound(x, y, SAMPLE_press, element);
980         lev.ball_cnt = lev.ball_time;
981         lev.ball_state = !lev.ball_state;
982         break;
983
984       case Xplant:
985         Cave[y][x] = Yplant;
986         Next[y][x] = Xplant;
987         play_element_sound(x, y, SAMPLE_blank, Xplant);
988         ply->anim = SPR_walk + anim;
989         ply->x = x;
990         ply->y = y;
991         break;
992
993       case Xexit_1:
994       case Xexit_2:
995       case Xexit_3:
996         play_element_sound(x, y, SAMPLE_exit, Xexit_1);
997
998         if (--lev.home == 0 && lev.time_initial > 0)    /* game won */
999           lev.score += lev.time * lev.exit_score / 100;
1000
1001         ply->anim = SPR_walk + anim;
1002         ply->x = x;
1003         ply->y = y;
1004
1005         break;
1006     }
1007   }
1008   else
1009   {
1010     int element = Cave[y][x];
1011
1012     switch(Cave[y][x])
1013     {
1014       /* fire is pressed */
1015
1016       case Xgrass:
1017         Cave[y][x] = Ygrass_eat;
1018         Next[y][x] = Xblank;
1019         play_element_sound(x, y, SAMPLE_dirt, element);
1020         ply->anim = SPR_spray + anim;
1021         break;
1022
1023       case Xdirt:
1024         Cave[y][x] = Ydirt_eat;
1025         Next[y][x] = Xblank;
1026         play_element_sound(x, y, SAMPLE_dirt, element);
1027         ply->anim = SPR_spray + anim;
1028         break;
1029
1030       case Xdiamond:
1031       case Xdiamond_pause:
1032         Cave[y][x] = Ydiamond_eat;
1033         Next[y][x] = Xblank;
1034         play_element_sound(x, y, SAMPLE_collect, element);
1035         lev.score += lev.diamond_score;
1036         lev.required = lev.required < 3 ? 0 : lev.required - 3;
1037         ply->anim = SPR_walk + anim;
1038         break;
1039
1040       case Xemerald:
1041       case Xemerald_pause:
1042         Cave[y][x] = Yemerald_eat;
1043         Next[y][x] = Xblank;
1044         play_element_sound(x, y, SAMPLE_collect, element);
1045         lev.score += lev.emerald_score;
1046         lev.required = lev.required < 1 ? 0 : lev.required - 1;
1047         ply->anim = SPR_walk + anim;
1048         break;
1049
1050       case Xdynamite:
1051         Cave[y][x] = Ydynamite_eat;
1052         Next[y][x] = Xblank;
1053         play_element_sound(x, y, SAMPLE_collect, element);
1054         lev.score += lev.dynamite_score;
1055         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
1056         ply->anim = SPR_walk + anim;
1057         break;
1058
1059       case Xkey_1:
1060         ply->keys |= 0x01;
1061         Cave[y][x] = Ykey_1_eat;
1062         goto key_shoot;
1063
1064       case Xkey_2:
1065         ply->keys |= 0x02;
1066         Cave[y][x] = Ykey_2_eat;
1067         goto key_shoot;
1068
1069       case Xkey_3:
1070         ply->keys |= 0x04;
1071         Cave[y][x] = Ykey_3_eat;
1072         goto key_shoot;
1073
1074       case Xkey_4:
1075         ply->keys |= 0x08;
1076         Cave[y][x] = Ykey_4_eat;
1077         goto key_shoot;
1078
1079       case Xkey_5:
1080         ply->keys |= 0x10;
1081         Cave[y][x] = Ykey_5_eat;
1082         goto key_shoot;
1083
1084       case Xkey_6:
1085         ply->keys |= 0x20;
1086         Cave[y][x] = Ykey_6_eat;
1087         goto key_shoot;
1088
1089       case Xkey_7:
1090         ply->keys |= 0x40;
1091         Cave[y][x] = Ykey_7_eat;
1092         goto key_shoot;
1093
1094       case Xkey_8:
1095         ply->keys |= 0x80;
1096         Cave[y][x] = Ykey_8_eat;
1097         goto key_shoot;
1098
1099       key_shoot:
1100         Next[y][x] = Xblank;
1101         play_element_sound(x, y, SAMPLE_collect, element);
1102         lev.score += lev.key_score;
1103         ply->anim = SPR_walk + anim;
1104         break;
1105
1106       case Xlenses:
1107         Cave[y][x] = Ylenses_eat;
1108         Next[y][x] = Xblank;
1109         play_element_sound(x, y, SAMPLE_collect, element);
1110         lev.score += lev.lenses_score;
1111         lev.lenses_cnt = lev.lenses_time;
1112         ply->anim = SPR_walk + anim;
1113         break;
1114
1115       case Xmagnify:
1116         Cave[y][x] = Ymagnify_eat;
1117         Next[y][x] = Xblank;
1118         play_element_sound(x, y, SAMPLE_collect, element);
1119         lev.score += lev.magnify_score;
1120         lev.magnify_cnt = lev.magnify_time;
1121         ply->anim = SPR_walk + anim;
1122         break;
1123     }
1124   }
1125 }