fixed (reversed) setting hot spot for pointer-style global animations
[rocksndiamonds.git] / src / anim.c
1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  http://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // anim.c
10 // ============================================================================
11
12 #include "libgame/libgame.h"
13
14 #include "anim.h"
15 #include "main.h"
16 #include "tools.h"
17 #include "files.h"
18 #include "events.h"
19 #include "screens.h"
20
21
22 #define DEBUG_ANIM_DELAY                0
23 #define DEBUG_ANIM_EVENTS               0
24
25
26 // values for global toon animation definition
27 #define NUM_GLOBAL_TOON_ANIMS           1
28 #define NUM_GLOBAL_TOON_PARTS           MAX_NUM_TOONS
29
30 // values for global animation definition (including toons)
31 #define NUM_GLOBAL_ANIMS_AND_TOONS      (NUM_GLOBAL_ANIMS +             \
32                                          NUM_GLOBAL_TOON_ANIMS)
33 #define NUM_GLOBAL_ANIM_PARTS_AND_TOONS MAX(NUM_GLOBAL_ANIM_PARTS_ALL,  \
34                                             NUM_GLOBAL_TOON_PARTS)
35
36 #define ANIM_CLASS_BIT_TITLE_INITIAL    0
37 #define ANIM_CLASS_BIT_TITLE            1
38 #define ANIM_CLASS_BIT_MAIN             2
39 #define ANIM_CLASS_BIT_SCORES           3
40 #define ANIM_CLASS_BIT_SUBMENU          4
41 #define ANIM_CLASS_BIT_MENU             5
42 #define ANIM_CLASS_BIT_TOONS            6
43 #define ANIM_CLASS_BIT_NO_TITLE         7
44
45 #define NUM_ANIM_CLASSES                8
46
47 #define ANIM_CLASS_NONE                 0
48 #define ANIM_CLASS_TITLE_INITIAL        (1 << ANIM_CLASS_BIT_TITLE_INITIAL)
49 #define ANIM_CLASS_TITLE                (1 << ANIM_CLASS_BIT_TITLE)
50 #define ANIM_CLASS_MAIN                 (1 << ANIM_CLASS_BIT_MAIN)
51 #define ANIM_CLASS_SCORES               (1 << ANIM_CLASS_BIT_SCORES)
52 #define ANIM_CLASS_SUBMENU              (1 << ANIM_CLASS_BIT_SUBMENU)
53 #define ANIM_CLASS_MENU                 (1 << ANIM_CLASS_BIT_MENU)
54 #define ANIM_CLASS_TOONS                (1 << ANIM_CLASS_BIT_TOONS)
55 #define ANIM_CLASS_NO_TITLE             (1 << ANIM_CLASS_BIT_NO_TITLE)
56
57 #define ANIM_CLASS_TOONS_SCORES         (ANIM_CLASS_TOONS       |       \
58                                          ANIM_CLASS_SCORES      |       \
59                                          ANIM_CLASS_NO_TITLE)
60
61 #define ANIM_CLASS_TOONS_MENU_MAIN      (ANIM_CLASS_TOONS       |       \
62                                          ANIM_CLASS_MENU        |       \
63                                          ANIM_CLASS_MAIN        |       \
64                                          ANIM_CLASS_NO_TITLE)
65
66 #define ANIM_CLASS_TOONS_MENU_SUBMENU   (ANIM_CLASS_TOONS       |       \
67                                          ANIM_CLASS_MENU        |       \
68                                          ANIM_CLASS_SUBMENU     |       \
69                                          ANIM_CLASS_NO_TITLE)
70
71 // values for global animation states
72 #define ANIM_STATE_INACTIVE             0
73 #define ANIM_STATE_RESTART              (1 << 0)
74 #define ANIM_STATE_WAITING              (1 << 1)
75 #define ANIM_STATE_RUNNING              (1 << 2)
76
77 // values for global animation control
78 #define ANIM_NO_ACTION                  0
79 #define ANIM_START                      1
80 #define ANIM_CONTINUE                   2
81 #define ANIM_STOP                       3
82
83
84 struct GlobalAnimPartControlInfo
85 {
86   int old_nr;           // position before mapping animation parts linearly
87   int old_anim_nr;      // position before mapping animations linearly
88
89   int nr;
90   int anim_nr;
91   int mode_nr;
92
93   boolean is_base;      // animation part is base/main/default animation part
94
95   int sound;
96   int music;
97   int graphic;
98
99   struct GraphicInfo graphic_info;
100   struct GraphicInfo control_info;
101
102   int viewport_x;
103   int viewport_y;
104   int viewport_width;
105   int viewport_height;
106
107   int x, y;
108   int step_xoffset, step_yoffset;
109
110   unsigned int initial_anim_sync_frame;
111   unsigned int step_delay, step_delay_value;
112
113   int init_delay_counter;
114   int anim_delay_counter;
115   int post_delay_counter;
116
117   boolean init_event_state;
118   boolean anim_event_state;
119
120   boolean triggered;
121   boolean clickable;
122   boolean clicked;
123
124   int drawing_stage;
125
126   int state;
127   int last_anim_status;
128 };
129
130 struct GlobalAnimMainControlInfo
131 {
132   struct GlobalAnimPartControlInfo base;
133   struct GlobalAnimPartControlInfo part[NUM_GLOBAL_ANIM_PARTS_AND_TOONS];
134
135   int nr;
136   int mode_nr;
137
138   struct GraphicInfo control_info;
139
140   int num_parts;        // number of animation parts, but without base part
141   int num_parts_all;    // number of animation parts, including base part
142   int part_counter;
143   int active_part_nr;
144
145   boolean has_base;     // animation has base/main/default animation part
146
147   int last_x, last_y;
148
149   int init_delay_counter;
150
151   int state;
152
153   int last_state, last_active_part_nr;
154 };
155
156 struct GlobalAnimControlInfo
157 {
158   struct GlobalAnimMainControlInfo anim[NUM_GLOBAL_ANIMS_AND_TOONS];
159
160   int nr;
161   int num_anims;
162 };
163
164 struct GameModeAnimClass
165 {
166   int game_mode;
167   int class;
168 } game_mode_anim_classes_list[] =
169 {
170   { GAME_MODE_TITLE_INITIAL_1,          ANIM_CLASS_TITLE_INITIAL        },
171   { GAME_MODE_TITLE_INITIAL_2,          ANIM_CLASS_TITLE_INITIAL        },
172   { GAME_MODE_TITLE_INITIAL_3,          ANIM_CLASS_TITLE_INITIAL        },
173   { GAME_MODE_TITLE_INITIAL_4,          ANIM_CLASS_TITLE_INITIAL        },
174   { GAME_MODE_TITLE_INITIAL_5,          ANIM_CLASS_TITLE_INITIAL        },
175   { GAME_MODE_TITLE_1,                  ANIM_CLASS_TITLE                },
176   { GAME_MODE_TITLE_2,                  ANIM_CLASS_TITLE                },
177   { GAME_MODE_TITLE_3,                  ANIM_CLASS_TITLE                },
178   { GAME_MODE_TITLE_4,                  ANIM_CLASS_TITLE                },
179   { GAME_MODE_TITLE_5,                  ANIM_CLASS_TITLE                },
180   { GAME_MODE_LEVELS,                   ANIM_CLASS_TOONS_MENU_SUBMENU   },
181   { GAME_MODE_LEVELNR,                  ANIM_CLASS_TOONS_MENU_SUBMENU   },
182   { GAME_MODE_INFO,                     ANIM_CLASS_TOONS_MENU_SUBMENU   },
183   { GAME_MODE_SETUP,                    ANIM_CLASS_TOONS_MENU_SUBMENU   },
184   { GAME_MODE_PSEUDO_MAINONLY,          ANIM_CLASS_TOONS_MENU_MAIN      },
185   { GAME_MODE_PSEUDO_TYPENAME,          ANIM_CLASS_TOONS_MENU_MAIN      },
186   { GAME_MODE_PSEUDO_SCORESOLD,         ANIM_CLASS_TOONS_SCORES         },
187   { GAME_MODE_PSEUDO_SCORESNEW,         ANIM_CLASS_TOONS_SCORES         },
188   { GAME_MODE_EDITOR,                   ANIM_CLASS_NO_TITLE             },
189   { GAME_MODE_PLAYING,                  ANIM_CLASS_NO_TITLE             },
190
191   { -1,                                 -1                              }
192 };
193
194 struct AnimClassGameMode
195 {
196   int class_bit;
197   int game_mode;
198 } anim_class_game_modes_list[] =
199 {
200   { ANIM_CLASS_BIT_TITLE_INITIAL,       GAME_MODE_TITLE_INITIAL         },
201   { ANIM_CLASS_BIT_TITLE,               GAME_MODE_TITLE                 },
202   { ANIM_CLASS_BIT_MAIN,                GAME_MODE_MAIN                  },
203   { ANIM_CLASS_BIT_SCORES,              GAME_MODE_SCORES                },
204   { ANIM_CLASS_BIT_SUBMENU,             GAME_MODE_PSEUDO_SUBMENU        },
205   { ANIM_CLASS_BIT_MENU,                GAME_MODE_PSEUDO_MENU           },
206   { ANIM_CLASS_BIT_TOONS,               GAME_MODE_PSEUDO_TOONS          },
207   { ANIM_CLASS_BIT_NO_TITLE,            GAME_MODE_PSEUDO_NO_TITLE       },
208
209   { -1,                                 -1                              }
210 };
211
212 // forward declaration for internal use
213 static void DoGlobalAnim_DelayAction(struct GlobalAnimPartControlInfo *, int);
214 static boolean DoGlobalAnim_EventAction(struct GlobalAnimPartControlInfo *);
215 static void HandleGlobalAnim(int, int);
216 static void DoAnimationExt(void);
217 static void ResetGlobalAnim_Clickable(void);
218 static void ResetGlobalAnim_Clicked(void);
219
220 static struct GlobalAnimControlInfo global_anim_ctrl[NUM_GAME_MODES];
221
222 static unsigned int anim_sync_frame = 0;
223
224 static int game_mode_anim_classes[NUM_GAME_MODES];
225 static int anim_class_game_modes[NUM_ANIM_CLASSES];
226
227 static int anim_status_last_before_fading = GAME_MODE_DEFAULT;
228 static int anim_status_last = GAME_MODE_DEFAULT;
229 static int anim_classes_last = ANIM_CLASS_NONE;
230
231 static boolean drawing_to_fading_buffer = FALSE;
232
233 static boolean handle_click = FALSE;
234
235
236 // ============================================================================
237 // generic animation frame calculation
238 // ============================================================================
239
240 int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
241                       int sync_frame)
242 {
243   int frame = 0;
244
245   sync_frame += start_frame * delay;
246
247   if (mode & ANIM_LOOP)                 // looping animation
248   {
249     frame = (sync_frame % (delay * num_frames)) / delay;
250   }
251   else if (mode & ANIM_LINEAR)          // linear (non-looping) animation
252   {
253     frame = sync_frame / delay;
254
255     if (frame > num_frames - 1)
256       frame = num_frames - 1;
257   }
258   else if (mode & ANIM_PINGPONG)        // oscillate (border frames once)
259   {
260     int max_anim_frames = (num_frames > 1 ? 2 * num_frames - 2 : 1);
261
262     frame = (sync_frame % (delay * max_anim_frames)) / delay;
263     frame = (frame < num_frames ? frame : max_anim_frames - frame);
264   }
265   else if (mode & ANIM_PINGPONG2)       // oscillate (border frames twice)
266   {
267     int max_anim_frames = 2 * num_frames;
268
269     frame = (sync_frame % (delay * max_anim_frames)) / delay;
270     frame = (frame < num_frames ? frame : max_anim_frames - frame - 1);
271   }
272   else if (mode & ANIM_RANDOM)          // play frames in random order
273   {
274     // note: expect different frames for the same delay cycle!
275
276     if (gfx.anim_random_frame < 0)
277       frame = GetSimpleRandom(num_frames);
278     else
279       frame = gfx.anim_random_frame % num_frames;
280   }
281   else if (mode & (ANIM_CE_VALUE | ANIM_CE_SCORE | ANIM_CE_DELAY))
282   {
283     frame = sync_frame % num_frames;
284   }
285
286   if (mode & ANIM_REVERSE)              // use reverse animation direction
287     frame = num_frames - frame - 1;
288
289   return frame;
290 }
291
292
293 // ============================================================================
294 // global animation functions
295 // ============================================================================
296
297 static int getGlobalAnimationPart(struct GlobalAnimMainControlInfo *anim)
298 {
299   struct GraphicInfo *c = &anim->control_info;
300   int last_anim_random_frame = gfx.anim_random_frame;
301   int part_nr;
302
303   gfx.anim_random_frame = -1;   // (use simple, ad-hoc random numbers)
304
305   part_nr = getAnimationFrame(anim->num_parts, 1,
306                               c->anim_mode, c->anim_start_frame,
307                               anim->part_counter);
308
309   gfx.anim_random_frame = last_anim_random_frame;
310
311   return part_nr;
312 }
313
314 static int compareGlobalAnimPartControlInfo(const void *obj1, const void *obj2)
315 {
316   const struct GlobalAnimPartControlInfo *o1 =
317     (struct GlobalAnimPartControlInfo *)obj1;
318   const struct GlobalAnimPartControlInfo *o2 =
319     (struct GlobalAnimPartControlInfo *)obj2;
320   int compare_result;
321
322   if (o1->control_info.draw_order != o2->control_info.draw_order)
323     compare_result = o1->control_info.draw_order - o2->control_info.draw_order;
324   else
325     compare_result = o1->nr - o2->nr;
326
327   return compare_result;
328 }
329
330 static int compareGlobalAnimMainControlInfo(const void *obj1, const void *obj2)
331 {
332   const struct GlobalAnimMainControlInfo *o1 =
333     (struct GlobalAnimMainControlInfo *)obj1;
334   const struct GlobalAnimMainControlInfo *o2 =
335     (struct GlobalAnimMainControlInfo *)obj2;
336   int compare_result;
337
338   if (o1->control_info.draw_order != o2->control_info.draw_order)
339     compare_result = o1->control_info.draw_order - o2->control_info.draw_order;
340   else
341     compare_result = o1->nr - o2->nr;
342
343   return compare_result;
344 }
345
346 static void InitToonControls(void)
347 {
348   int mode_nr_toons = GAME_MODE_PSEUDO_TOONS;
349   struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr_toons];
350   struct GlobalAnimMainControlInfo *anim = &ctrl->anim[ctrl->num_anims];
351   int mode_nr, anim_nr, part_nr;
352   int control = IMG_INTERNAL_GLOBAL_TOON_DEFAULT;
353   int num_toons = MAX_NUM_TOONS;
354   int i;
355
356   if (global.num_toons >= 0 && global.num_toons < MAX_NUM_TOONS)
357     num_toons = global.num_toons;
358
359   mode_nr = mode_nr_toons;
360   anim_nr = ctrl->num_anims;
361
362   anim->nr = anim_nr;
363   anim->mode_nr = mode_nr;
364   anim->control_info = graphic_info[control];
365
366   anim->num_parts = 0;
367   anim->num_parts_all = 0;
368   anim->part_counter = 0;
369   anim->active_part_nr = 0;
370
371   anim->has_base = FALSE;
372
373   anim->last_x = POS_OFFSCREEN;
374   anim->last_y = POS_OFFSCREEN;
375
376   anim->init_delay_counter = 0;
377
378   anim->state = ANIM_STATE_INACTIVE;
379
380   part_nr = 0;
381
382   for (i = 0; i < num_toons; i++)
383   {
384     struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
385     int sound = SND_UNDEFINED;
386     int music = MUS_UNDEFINED;
387     int graphic = IMG_TOON_1 + i;
388     int control = graphic;
389
390     part->nr = part_nr;
391     part->anim_nr = anim_nr;
392     part->mode_nr = mode_nr;
393
394     part->is_base = FALSE;
395
396     part->sound = sound;
397     part->music = music;
398     part->graphic = graphic;
399
400     part->graphic_info = graphic_info[graphic];
401     part->control_info = graphic_info[control];
402
403     part->graphic_info.anim_delay *= part->graphic_info.step_delay;
404
405     part->control_info.init_delay_fixed = 0;
406     part->control_info.init_delay_random = 150;
407
408     part->control_info.x = ARG_UNDEFINED_VALUE;
409     part->control_info.y = ARG_UNDEFINED_VALUE;
410
411     part->initial_anim_sync_frame = 0;
412
413     part->step_delay = 0;
414     part->step_delay_value = graphic_info[control].step_delay;
415
416     part->state = ANIM_STATE_INACTIVE;
417     part->last_anim_status = -1;
418
419     anim->num_parts++;
420     anim->num_parts_all++;
421
422     part_nr++;
423   }
424
425   ctrl->num_anims++;
426 }
427
428 static void InitGlobalAnimControls(void)
429 {
430   int i, m, a, p;
431   int mode_nr, anim_nr, part_nr;
432   int sound, music, graphic, control;
433
434   anim_sync_frame = 0;
435
436   for (m = 0; m < NUM_GAME_MODES; m++)
437   {
438     mode_nr = m;
439
440     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
441
442     ctrl->nr = mode_nr;
443     ctrl->num_anims = 0;
444
445     anim_nr = 0;
446
447     for (a = 0; a < NUM_GLOBAL_ANIMS; a++)
448     {
449       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
450       int ctrl_id = GLOBAL_ANIM_ID_CONTROL_FIRST + a;
451
452       control = global_anim_info[ctrl_id].graphic[GLOBAL_ANIM_ID_PART_BASE][m];
453
454       // if no base animation parameters defined, use default values
455       if (control == IMG_UNDEFINED)
456         control = IMG_INTERNAL_GLOBAL_ANIM_DEFAULT;
457
458       anim->nr = anim_nr;
459       anim->mode_nr = mode_nr;
460       anim->control_info = graphic_info[control];
461
462       anim->num_parts = 0;
463       anim->num_parts_all = 0;
464       anim->part_counter = 0;
465       anim->active_part_nr = 0;
466
467       anim->has_base = FALSE;
468
469       anim->last_x = POS_OFFSCREEN;
470       anim->last_y = POS_OFFSCREEN;
471
472       anim->init_delay_counter = 0;
473
474       anim->state = ANIM_STATE_INACTIVE;
475
476       part_nr = 0;
477
478       for (p = 0; p < NUM_GLOBAL_ANIM_PARTS_ALL; p++)
479       {
480         struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
481
482         sound   = global_anim_info[a].sound[p][m];
483         music   = global_anim_info[a].music[p][m];
484         graphic = global_anim_info[a].graphic[p][m];
485         control = global_anim_info[ctrl_id].graphic[p][m];
486
487         if (graphic == IMG_UNDEFINED || graphic_info[graphic].bitmap == NULL ||
488             control == IMG_UNDEFINED)
489           continue;
490
491 #if 0
492         printf("::: mode == %d, anim = %d, part = %d [%d, %d, %d] [%d]\n",
493                m, a, p, mode_nr, anim_nr, part_nr, control);
494 #endif
495
496 #if 0
497         printf("::: mode == %d, anim = %d, part = %d [%d, %d, %d] [%d]\n",
498                m, a, p, mode_nr, anim_nr, part_nr, sound);
499 #endif
500
501         part->old_nr = p;
502         part->old_anim_nr = a;
503
504         part->nr = part_nr;
505         part->anim_nr = anim_nr;
506         part->mode_nr = mode_nr;
507
508         part->sound = sound;
509         part->music = music;
510         part->graphic = graphic;
511
512         part->graphic_info = graphic_info[graphic];
513         part->control_info = graphic_info[control];
514
515         part->initial_anim_sync_frame = 0;
516
517         part->step_delay = 0;
518         part->step_delay_value = graphic_info[control].step_delay;
519
520         part->state = ANIM_STATE_INACTIVE;
521         part->last_anim_status = -1;
522
523         anim->num_parts_all++;
524
525         if (p < GLOBAL_ANIM_ID_PART_BASE)
526         {
527           part->is_base = FALSE;
528
529           anim->num_parts++;
530           part_nr++;
531         }
532         else
533         {
534           part->is_base = TRUE;
535
536           anim->base = *part;
537           anim->has_base = TRUE;
538         }
539
540         // apply special settings for pointer-style animations
541         if (part->control_info.class == get_hash_from_key("pointer"))
542         {
543           // force animation to be on top (must set anim and part control)
544           if (anim->control_info.draw_order == 0)
545             anim->control_info.draw_order = 1000000;
546           if (part->control_info.draw_order == 0)
547             part->control_info.draw_order = 1000000;
548
549           // force animation to pass-through clicks (must set part control)
550           if (part->control_info.style == STYLE_DEFAULT)
551             part->control_info.style |= STYLE_PASSTHROUGH;
552         }
553       }
554
555       if (anim->num_parts > 0 || anim->has_base)
556       {
557         ctrl->num_anims++;
558         anim_nr++;
559       }
560     }
561   }
562
563   InitToonControls();
564
565   // sort all animations according to draw_order and animation number
566   for (m = 0; m < NUM_GAME_MODES; m++)
567   {
568     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[m];
569
570     // sort all main animations for this game mode
571     qsort(ctrl->anim, ctrl->num_anims,
572           sizeof(struct GlobalAnimMainControlInfo),
573           compareGlobalAnimMainControlInfo);
574
575     for (a = 0; a < ctrl->num_anims; a++)
576     {
577       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[a];
578
579       // sort all animation parts for this main animation
580       qsort(anim->part, anim->num_parts,
581             sizeof(struct GlobalAnimPartControlInfo),
582             compareGlobalAnimPartControlInfo);
583     }
584   }
585
586   for (i = 0; i < NUM_GAME_MODES; i++)
587     game_mode_anim_classes[i] = ANIM_CLASS_NONE;
588   for (i = 0; game_mode_anim_classes_list[i].game_mode != -1; i++)
589     game_mode_anim_classes[game_mode_anim_classes_list[i].game_mode] =
590       game_mode_anim_classes_list[i].class;
591
592   for (i = 0; i < NUM_ANIM_CLASSES; i++)
593     anim_class_game_modes[i] = GAME_MODE_DEFAULT;
594   for (i = 0; anim_class_game_modes_list[i].game_mode != -1; i++)
595     anim_class_game_modes[anim_class_game_modes_list[i].class_bit] =
596       anim_class_game_modes_list[i].game_mode;
597
598   anim_status_last_before_fading = GAME_MODE_LOADING;
599   anim_status_last = GAME_MODE_LOADING;
600   anim_classes_last = ANIM_CLASS_NONE;
601 }
602
603 void InitGlobalAnimations(void)
604 {
605   InitGlobalAnimControls();
606 }
607
608 static void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
609 {
610   Bitmap *fade_bitmap =
611     (drawing_target == DRAW_TO_FADE_SOURCE ? gfx.fade_bitmap_source :
612      drawing_target == DRAW_TO_FADE_TARGET ? gfx.fade_bitmap_target : NULL);
613   int game_mode_anim_action[NUM_GAME_MODES];
614   int mode_nr;
615
616   if (!setup.toons)
617     return;
618
619   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_1 &&
620       drawing_target == DRAW_TO_SCREEN)
621     DoAnimationExt();
622
623   // always start with reliable default values (no animation actions)
624   for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
625     game_mode_anim_action[mode_nr] = ANIM_NO_ACTION;
626
627   if (global.anim_status != anim_status_last)
628   {
629     boolean before_fading = (global.anim_status == GAME_MODE_PSEUDO_FADING);
630     boolean after_fading  = (anim_status_last   == GAME_MODE_PSEUDO_FADING);
631     int anim_classes_next = game_mode_anim_classes[global.anim_status_next];
632     int i;
633
634     if (drawing_target == DRAW_TO_FADE_TARGET)
635       after_fading = TRUE;
636
637     // special case: changing from/to this screen is done without fading
638     if (global.anim_status == GAME_MODE_PSEUDO_TYPENAME ||
639         anim_status_last   == GAME_MODE_PSEUDO_TYPENAME)
640       after_fading = TRUE;
641
642     // ---------- part 1 ------------------------------------------------------
643     // start or stop global animations by change of game mode
644     // (special handling of animations for "current screen" and "all screens")
645
646     if (global.anim_status_next != anim_status_last_before_fading)
647     {
648       // stop animations for last screen before fading to new screen
649       game_mode_anim_action[anim_status_last] = ANIM_STOP;
650
651       // start animations for current screen after fading to new screen
652       game_mode_anim_action[global.anim_status] = ANIM_START;
653     }
654
655     // start animations for all screens after loading new artwork set
656     if (anim_status_last == GAME_MODE_LOADING)
657       game_mode_anim_action[GAME_MODE_DEFAULT] = ANIM_START;
658
659     // ---------- part 2 ------------------------------------------------------
660     // start or stop global animations by change of animation class
661     // (generic handling of animations for "class of screens")
662
663     for (i = 0; i < NUM_ANIM_CLASSES; i++)
664     {
665       int anim_class_check = (1 << i);
666       int anim_class_game_mode = anim_class_game_modes[i];
667       int anim_class_last = anim_classes_last & anim_class_check;
668       int anim_class_next = anim_classes_next & anim_class_check;
669
670       // stop animations for changed screen class before fading to new screen
671       if (before_fading && anim_class_last && !anim_class_next)
672         game_mode_anim_action[anim_class_game_mode] = ANIM_STOP;
673
674       // start animations for changed screen class after fading to new screen
675       if (after_fading && !anim_class_last && anim_class_next)
676         game_mode_anim_action[anim_class_game_mode] = ANIM_START;
677     }
678
679     if (drawing_target == DRAW_TO_SCREEN)
680     {
681       if (after_fading)
682       {
683         anim_classes_last = anim_classes_next;
684         anim_status_last_before_fading = global.anim_status;
685       }
686
687       anim_status_last = global.anim_status;
688
689       // start or stop animations determined to be started or stopped above
690       for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
691         if (game_mode_anim_action[mode_nr] != ANIM_NO_ACTION)
692           HandleGlobalAnim(game_mode_anim_action[mode_nr], mode_nr);
693     }
694     else if (drawing_target == DRAW_TO_FADE_TARGET)
695     {
696       drawing_to_fading_buffer = TRUE;
697
698       // start animations determined to be (temporary) started above
699       for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
700         if (game_mode_anim_action[mode_nr] == ANIM_START)
701           HandleGlobalAnim(ANIM_START, mode_nr);
702     }
703   }
704
705   if (global.anim_status == GAME_MODE_LOADING)
706     return;
707
708   for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
709   {
710     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
711     int anim_nr;
712
713     // when preparing source fading buffer, only draw animations to be stopped
714     if (drawing_target == DRAW_TO_FADE_SOURCE &&
715         game_mode_anim_action[mode_nr] != ANIM_STOP)
716       continue;
717
718     // when preparing target fading buffer, only draw animations to be started
719     if (drawing_target == DRAW_TO_FADE_TARGET &&
720         game_mode_anim_action[mode_nr] != ANIM_START)
721       continue;
722
723 #if 0
724     if (mode_nr != GFX_SPECIAL_ARG_DEFAULT &&
725         mode_nr != game_status)
726       continue;
727 #endif
728
729     for (anim_nr = 0; anim_nr < ctrl->num_anims; anim_nr++)
730     {
731       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
732       struct GraphicInfo *c = &anim->control_info;
733       int part_first, part_last;
734       int part_nr;
735
736       if (!(anim->state & ANIM_STATE_RUNNING))
737         continue;
738
739       part_first = part_last = anim->active_part_nr;
740
741       if (c->anim_mode & ANIM_ALL || anim->num_parts == 0)
742       {
743         int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);
744
745         part_first = 0;
746         part_last = num_parts - 1;
747       }
748
749       for (part_nr = part_first; part_nr <= part_last; part_nr++)
750       {
751         struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
752         struct GraphicInfo *g = &part->graphic_info;
753         Bitmap *src_bitmap;
754         int src_x, src_y;
755         int width  = g->width;
756         int height = g->height;
757         int dst_x = part->x;
758         int dst_y = part->y;
759         int cut_x = 0;
760         int cut_y = 0;
761         int sync_frame;
762         int frame;
763         void (*blit_bitmap)(Bitmap *, Bitmap *, int, int, int, int, int, int) =
764           (g->draw_masked ? BlitBitmapMasked : BlitBitmap);
765         void (*blit_screen)(Bitmap *, int, int, int, int, int, int) =
766           (g->draw_masked ? BlitToScreenMasked : BlitToScreen);
767
768         if (!(part->state & ANIM_STATE_RUNNING))
769           continue;
770
771         if (part->drawing_stage != drawing_stage)
772           continue;
773
774         if (part->x < 0)
775         {
776           dst_x = 0;
777           width += part->x;
778           cut_x = -part->x;
779         }
780         else if (part->x > part->viewport_width - g->width)
781           width -= (part->x - (part->viewport_width - g->width));
782
783         if (part->y < 0)
784         {
785           dst_y = 0;
786           height += part->y;
787           cut_y = -part->y;
788         }
789         else if (part->y > part->viewport_height - g->height)
790           height -= (part->y - (part->viewport_height - g->height));
791
792         if (width <= 0 || height <= 0)
793           continue;
794
795         dst_x += part->viewport_x;
796         dst_y += part->viewport_y;
797
798         sync_frame = anim_sync_frame - part->initial_anim_sync_frame;
799         frame = getAnimationFrame(g->anim_frames, g->anim_delay,
800                                   g->anim_mode, g->anim_start_frame,
801                                   sync_frame);
802
803         getFixedGraphicSource(part->graphic, frame, &src_bitmap,
804                               &src_x, &src_y);
805
806         src_x += cut_x;
807         src_y += cut_y;
808
809         if (drawing_target == DRAW_TO_SCREEN)
810           blit_screen(src_bitmap, src_x, src_y, width, height,
811                       dst_x, dst_y);
812         else
813           blit_bitmap(src_bitmap, fade_bitmap, src_x, src_y, width, height,
814                       dst_x, dst_y);
815       }
816     }
817   }
818
819   if (drawing_target == DRAW_TO_FADE_TARGET)
820   {
821     // stop animations determined to be (temporary) started above
822     for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
823       if (game_mode_anim_action[mode_nr] == ANIM_START)
824         HandleGlobalAnim(ANIM_STOP, mode_nr);
825
826     drawing_to_fading_buffer = FALSE;
827   }
828 }
829
830 void DrawGlobalAnimations(int drawing_target, int drawing_stage)
831 {
832   int last_cursor_mode_override = gfx.cursor_mode_override;
833
834   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_1)
835   {
836     ResetGlobalAnim_Clickable();
837
838     gfx.cursor_mode_override = CURSOR_UNDEFINED;
839   }
840
841   DrawGlobalAnimationsExt(drawing_target, drawing_stage);
842
843   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_2)
844   {
845     ResetGlobalAnim_Clicked();
846   }
847
848   if (gfx.cursor_mode_override != last_cursor_mode_override)
849     SetMouseCursor(gfx.cursor_mode);
850 }
851
852 static boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
853 {
854   int viewport_x;
855   int viewport_y;
856   int viewport_width;
857   int viewport_height;
858   boolean changed = FALSE;
859
860   if (part->last_anim_status == global.anim_status &&
861       part->control_info.class != get_hash_from_key("pointer"))
862     return FALSE;
863
864   part->last_anim_status = global.anim_status;
865
866   part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_1;
867
868   if (part->control_info.class == get_hash_from_key("window") ||
869       part->control_info.class == get_hash_from_key("border"))
870   {
871     viewport_x = 0;
872     viewport_y = 0;
873     viewport_width  = WIN_XSIZE;
874     viewport_height = WIN_YSIZE;
875
876     part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_2;
877   }
878   else if (part->control_info.class == get_hash_from_key("pointer"))
879   {
880     int mx = MIN(MAX(0, gfx.mouse_x), WIN_XSIZE - 1);
881     int my = MIN(MAX(0, gfx.mouse_y), WIN_YSIZE - 1);
882
883     viewport_x = mx - part->control_info.x;
884     viewport_y = my - part->control_info.y;
885     viewport_width  = part->graphic_info.width;
886     viewport_height = part->graphic_info.height;
887
888     part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_2;
889
890     // do not use global animation mouse pointer when reloading artwork
891     if (global.anim_status != GAME_MODE_LOADING)
892       gfx.cursor_mode_override = CURSOR_NONE;
893   }
894   else if (part->control_info.class == get_hash_from_key("door_1"))
895   {
896     viewport_x = DX;
897     viewport_y = DY;
898     viewport_width  = DXSIZE;
899     viewport_height = DYSIZE;
900   }
901   else if (part->control_info.class == get_hash_from_key("door_2"))
902   {
903     if (part->mode_nr == GAME_MODE_EDITOR)
904     {
905       viewport_x = EX;
906       viewport_y = EY;
907       viewport_width  = EXSIZE;
908       viewport_height = EYSIZE;
909     }
910     else
911     {
912       viewport_x = VX;
913       viewport_y = VY;
914       viewport_width  = VXSIZE;
915       viewport_height = VYSIZE;
916     }
917   }
918   else          // default: "playfield"
919   {
920     viewport_x = REAL_SX;
921     viewport_y = REAL_SY;
922     viewport_width  = FULL_SXSIZE;
923     viewport_height = FULL_SYSIZE;
924   }
925
926   if (viewport_x != part->viewport_x ||
927       viewport_y != part->viewport_y ||
928       viewport_width  != part->viewport_width ||
929       viewport_height != part->viewport_height)
930   {
931     part->viewport_x = viewport_x;
932     part->viewport_y = viewport_y;
933     part->viewport_width  = viewport_width;
934     part->viewport_height = viewport_height;
935
936     changed = TRUE;
937   }
938
939   return changed;
940 }
941
942 static void PlayGlobalAnimSound(struct GlobalAnimPartControlInfo *part)
943 {
944   int sound = part->sound;
945
946   if (sound == SND_UNDEFINED)
947     return;
948
949   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
950       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
951     return;
952
953   // !!! TODO: ADD STEREO POSITION FOR MOVING ANIMATIONS !!!
954   if (IS_LOOP_SOUND(sound))
955     PlaySoundLoop(sound);
956   else
957     PlaySound(sound);
958
959 #if 0
960   printf("::: PLAY SOUND %d.%d.%d: %d\n",
961          part->anim_nr, part->nr, part->mode_nr, sound);
962 #endif
963 }
964
965 static void StopGlobalAnimSound(struct GlobalAnimPartControlInfo *part)
966 {
967   int sound = part->sound;
968
969   if (sound == SND_UNDEFINED)
970     return;
971
972   StopSound(sound);
973
974 #if 0
975   printf("::: STOP SOUND %d.%d.%d: %d\n",
976          part->anim_nr, part->nr, part->mode_nr, sound);
977 #endif
978 }
979
980 static void PlayGlobalAnimMusic(struct GlobalAnimPartControlInfo *part)
981 {
982   int music = part->music;
983
984   if (music == MUS_UNDEFINED)
985     return;
986
987   if (!setup.sound_music)
988     return;
989
990   if (IS_LOOP_MUSIC(music))
991     PlayMusicLoop(music);
992   else
993     PlayMusic(music);
994
995 #if 0
996   printf("::: PLAY MUSIC %d.%d.%d: %d\n",
997          part->anim_nr, part->nr, part->mode_nr, music);
998 #endif
999 }
1000
1001 static void StopGlobalAnimMusic(struct GlobalAnimPartControlInfo *part)
1002 {
1003   int music = part->music;
1004
1005   if (music == MUS_UNDEFINED)
1006     return;
1007
1008   StopMusic();
1009
1010 #if 0
1011   printf("::: STOP MUSIC %d.%d.%d: %d\n",
1012          part->anim_nr, part->nr, part->mode_nr, music);
1013 #endif
1014 }
1015
1016 static void PlayGlobalAnimSoundAndMusic(struct GlobalAnimPartControlInfo *part)
1017 {
1018   // when drawing animations to fading buffer, do not play sounds or music
1019   if (drawing_to_fading_buffer)
1020     return;
1021
1022   PlayGlobalAnimSound(part);
1023   PlayGlobalAnimMusic(part);
1024 }
1025
1026 static void StopGlobalAnimSoundAndMusic(struct GlobalAnimPartControlInfo *part)
1027 {
1028   StopGlobalAnimSound(part);
1029   StopGlobalAnimMusic(part);
1030 }
1031
1032 static void PlayGlobalAnimSoundIfLoop(struct GlobalAnimPartControlInfo *part)
1033 {
1034   // when drawing animations to fading buffer, do not play sounds
1035   if (drawing_to_fading_buffer)
1036     return;
1037
1038   // loop sounds only expire when playing
1039   if (game_status != GAME_MODE_PLAYING)
1040     return;
1041
1042   // check if any sound is defined for this animation part
1043   if (part->sound == SND_UNDEFINED)
1044     return;
1045
1046   // normal (non-loop) sounds do not expire when playing
1047   if (!IS_LOOP_SOUND(part->sound))
1048     return;
1049
1050   // prevent expiring loop sounds when playing
1051   PlayGlobalAnimSound(part);
1052 }
1053
1054 static boolean checkGlobalAnimEvent(int anim_event, int mask)
1055 {
1056   int mask_anim_only = mask & ~ANIM_EVENT_PART_MASK;
1057
1058   if (mask & ANIM_EVENT_ANY)
1059     return (anim_event & ANIM_EVENT_ANY);
1060   else if (mask & ANIM_EVENT_SELF)
1061     return (anim_event & ANIM_EVENT_SELF);
1062   else if (mask & ANIM_EVENT_UNCLICK_ANY)
1063     return (anim_event & ANIM_EVENT_UNCLICK_ANY);
1064   else
1065     return (anim_event == mask ||
1066             anim_event == mask_anim_only);
1067 }
1068
1069 static boolean isClickablePart(struct GlobalAnimPartControlInfo *part, int mask)
1070 {
1071   struct GraphicInfo *c = &part->control_info;
1072   int num_init_events = GetGlobalAnimEventValueCount(c->init_event);
1073   int num_anim_events = GetGlobalAnimEventValueCount(c->anim_event);
1074   int i;
1075
1076   for (i = 0; i < num_init_events; i++)
1077   {
1078     int init_event = GetGlobalAnimEventValue(c->init_event, i);
1079
1080     if (checkGlobalAnimEvent(init_event, mask))
1081       return TRUE;
1082   }
1083
1084   for (i = 0; i < num_anim_events; i++)
1085   {
1086     int anim_event = GetGlobalAnimEventValue(c->anim_event, i);
1087
1088     if (checkGlobalAnimEvent(anim_event, mask))
1089       return TRUE;
1090   }
1091
1092   return FALSE;
1093 }
1094
1095 static boolean isClickedPart(struct GlobalAnimPartControlInfo *part,
1096                              int mx, int my, boolean clicked)
1097 {
1098   struct GraphicInfo *g = &part->graphic_info;
1099   int part_x = part->viewport_x + part->x;
1100   int part_y = part->viewport_y + part->y;
1101   int part_width  = g->width;
1102   int part_height = g->height;
1103
1104   // check if mouse click was detected at all
1105   if (!clicked)
1106     return FALSE;
1107
1108   // check if mouse click is inside the animation part's viewport
1109   if (mx <  part->viewport_x ||
1110       mx >= part->viewport_x + part->viewport_width ||
1111       my <  part->viewport_y ||
1112       my >= part->viewport_y + part->viewport_height)
1113     return FALSE;
1114
1115   // check if mouse click is inside the animation part's graphic
1116   if (mx <  part_x ||
1117       mx >= part_x + part_width ||
1118       my <  part_y ||
1119       my >= part_y + part_height)
1120     return FALSE;
1121
1122   return TRUE;
1123 }
1124
1125 static boolean clickConsumed(struct GlobalAnimPartControlInfo *part)
1126 {
1127   return (part->control_info.style & STYLE_PASSTHROUGH ? FALSE : TRUE);
1128 }
1129
1130 static void InitGlobalAnim_Triggered(struct GlobalAnimPartControlInfo *part,
1131                                      boolean *anything_clicked,
1132                                      boolean *any_event_action,
1133                                      int event_value, char *info_text)
1134 {
1135   struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[part->mode_nr];
1136
1137   int gic_anim_nr = part->old_anim_nr + 1;      // X as in "anim_X"
1138   int gic_part_nr = part->old_nr + 1;           // Y as in "part_Y"
1139   int mask = event_value | (gic_anim_nr << ANIM_EVENT_ANIM_BIT);
1140
1141   if (!part->is_base)
1142     mask |= gic_part_nr << ANIM_EVENT_PART_BIT;
1143
1144   int anim2_nr;
1145
1146   for (anim2_nr = 0; anim2_nr < ctrl->num_anims; anim2_nr++)
1147   {
1148     struct GlobalAnimMainControlInfo *anim2 = &ctrl->anim[anim2_nr];
1149     int part2_nr;
1150
1151     for (part2_nr = 0; part2_nr < anim2->num_parts_all; part2_nr++)
1152     {
1153       struct GlobalAnimPartControlInfo *part2 = &anim2->part[part2_nr];
1154
1155       if (part2->state != ANIM_STATE_RUNNING)
1156         continue;
1157
1158       if (isClickablePart(part2, mask))
1159       {
1160         part2->triggered = TRUE;
1161         *anything_clicked = clickConsumed(part);        // click was on "part"!
1162
1163 #if DEBUG_ANIM_EVENTS
1164         printf("::: => %d.%d TRIGGERED BY %s OF %d.%d\n",
1165                part2->old_anim_nr + 1, part2->old_nr + 1, info_text,
1166                part->old_anim_nr + 1, part->old_nr + 1);
1167 #endif
1168 #if 0
1169         printf("::: %d.%d TRIGGER CLICKED [%d]\n", anim2_nr, part2_nr,
1170                part2->control_info.anim_event_action);
1171 #endif
1172
1173         // after executing event action, ignore any further actions
1174         if (!*any_event_action && DoGlobalAnim_EventAction(part2))
1175           *any_event_action = TRUE;
1176       }
1177
1178 #if 0
1179       struct GraphicInfo *c = &part2->control_info;
1180
1181       printf("::: - %d.%d: 0x%08x, 0x%08x [0x%08x]",
1182              anim2_nr, part2_nr, c->init_event, c->anim_event, mask);
1183
1184       if (isClickablePart(part2, mask))
1185         printf(" <--- TRIGGERED BY %d.%d",
1186                anim_nr, part_nr);
1187
1188       printf("\n");
1189 #endif
1190     }
1191   }
1192 }
1193
1194 static void HandleGlobalAnimDelay(struct GlobalAnimPartControlInfo *part,
1195                                   int delay_type, char *info_text)
1196 {
1197 #if DEBUG_ANIM_DELAY
1198   printf("::: %d.%d %s\n", part->old_anim_nr + 1, part->old_nr + 1, info_text);
1199 #endif
1200
1201   DoGlobalAnim_DelayAction(part, delay_type);
1202 }
1203
1204 static void HandleGlobalAnimEvent(struct GlobalAnimPartControlInfo *part,
1205                                   int event_value, char *info_text)
1206 {
1207 #if DEBUG_ANIM_EVENTS
1208   printf("::: %d.%d %s\n", part->old_anim_nr + 1, part->old_nr + 1, info_text);
1209 #endif
1210
1211   boolean anything_clicked = FALSE;
1212   boolean any_event_action = FALSE;
1213
1214   // check if this event is defined to trigger other animations
1215   InitGlobalAnim_Triggered(part, &anything_clicked, &any_event_action,
1216                            event_value, info_text);
1217 }
1218
1219 static int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part,
1220                                  int state)
1221 {
1222   if (handle_click && !part->clicked)
1223     return state;
1224
1225   struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[part->mode_nr];
1226   struct GlobalAnimMainControlInfo *anim = &ctrl->anim[part->anim_nr];
1227   struct GraphicInfo *g = &part->graphic_info;
1228   struct GraphicInfo *c = &part->control_info;
1229   boolean viewport_changed = SetGlobalAnimPart_Viewport(part);
1230
1231   if (viewport_changed)
1232     state |= ANIM_STATE_RESTART;
1233
1234   if (state & ANIM_STATE_RESTART)
1235   {
1236     // when drawing animations to fading buffer, only start fixed animations
1237     if (drawing_to_fading_buffer && (c->x == ARG_UNDEFINED_VALUE ||
1238                                      c->y == ARG_UNDEFINED_VALUE))
1239       return ANIM_STATE_INACTIVE;
1240
1241     ResetDelayCounterExt(&part->step_delay, anim_sync_frame);
1242
1243     part->init_delay_counter =
1244       (c->init_delay_fixed + GetSimpleRandom(c->init_delay_random));
1245
1246     part->anim_delay_counter =
1247       (c->anim_delay_fixed + GetSimpleRandom(c->anim_delay_random));
1248
1249     part->post_delay_counter = 0;
1250
1251     part->init_event_state = (c->init_event != ANIM_EVENT_UNDEFINED);
1252     part->anim_event_state = (c->anim_event != ANIM_EVENT_UNDEFINED);
1253
1254     part->initial_anim_sync_frame =
1255       (g->anim_global_sync ? 0 : anim_sync_frame + part->init_delay_counter);
1256
1257     if (c->direction & MV_HORIZONTAL)
1258     {
1259       int pos_bottom = part->viewport_height - g->height;
1260
1261       if (c->position == POS_TOP)
1262         part->y = 0;
1263       else if (c->position == POS_UPPER)
1264         part->y = GetSimpleRandom(pos_bottom / 2);
1265       else if (c->position == POS_MIDDLE)
1266         part->y = pos_bottom / 2;
1267       else if (c->position == POS_LOWER)
1268         part->y = pos_bottom / 2 + GetSimpleRandom(pos_bottom / 2);
1269       else if (c->position == POS_BOTTOM)
1270         part->y = pos_bottom;
1271       else
1272         part->y = GetSimpleRandom(pos_bottom);
1273
1274       if (c->direction == MV_RIGHT)
1275       {
1276         part->step_xoffset = c->step_offset;
1277         part->x = -g->width + part->step_xoffset;
1278       }
1279       else
1280       {
1281         part->step_xoffset = -c->step_offset;
1282         part->x = part->viewport_width + part->step_xoffset;
1283       }
1284
1285       part->step_yoffset = 0;
1286     }
1287     else if (c->direction & MV_VERTICAL)
1288     {
1289       int pos_right = part->viewport_width - g->width;
1290
1291       if (c->position == POS_LEFT)
1292         part->x = 0;
1293       else if (c->position == POS_RIGHT)
1294         part->x = pos_right;
1295       else
1296         part->x = GetSimpleRandom(pos_right);
1297
1298       if (c->direction == MV_DOWN)
1299       {
1300         part->step_yoffset = c->step_offset;
1301         part->y = -g->height + part->step_yoffset;
1302       }
1303       else
1304       {
1305         part->step_yoffset = -c->step_offset;
1306         part->y = part->viewport_height + part->step_yoffset;
1307       }
1308
1309       part->step_xoffset = 0;
1310     }
1311     else
1312     {
1313       part->x = 0;
1314       part->y = 0;
1315
1316       part->step_xoffset = 0;
1317       part->step_yoffset = 0;
1318     }
1319
1320     if (part->control_info.class != get_hash_from_key("pointer"))
1321     {
1322       if (c->x != ARG_UNDEFINED_VALUE)
1323         part->x = c->x;
1324       if (c->y != ARG_UNDEFINED_VALUE)
1325         part->y = c->y;
1326     }
1327
1328     if (c->position == POS_LAST &&
1329         anim->last_x > -g->width  && anim->last_x < part->viewport_width &&
1330         anim->last_y > -g->height && anim->last_y < part->viewport_height)
1331     {
1332       part->x = anim->last_x;
1333       part->y = anim->last_y;
1334     }
1335
1336     if (c->step_xoffset != ARG_UNDEFINED_VALUE)
1337       part->step_xoffset = c->step_xoffset;
1338     if (c->step_yoffset != ARG_UNDEFINED_VALUE)
1339       part->step_yoffset = c->step_yoffset;
1340
1341     if (part->init_delay_counter == 0 &&
1342         !part->init_event_state)
1343     {
1344       PlayGlobalAnimSoundAndMusic(part);
1345
1346       HandleGlobalAnimDelay(part, ANIM_DELAY_INIT,  "START [INIT_DELAY]");
1347       HandleGlobalAnimEvent(part, ANIM_EVENT_START, "START [ANIM]");
1348     }
1349     else
1350     {
1351       HandleGlobalAnimEvent(part, ANIM_EVENT_INIT, "START [INIT_DELAY/EVENT]");
1352     }
1353   }
1354
1355   if (part->clicked &&
1356       part->init_event_state)
1357   {
1358     if (part->initial_anim_sync_frame > 0)
1359       part->initial_anim_sync_frame -= part->init_delay_counter - 1;
1360
1361     part->init_delay_counter = 1;
1362     part->init_event_state = FALSE;
1363
1364     part->clicked = FALSE;
1365   }
1366
1367   if (part->clicked &&
1368       part->anim_event_state)
1369   {
1370     part->anim_delay_counter = 1;
1371     part->anim_event_state = FALSE;
1372
1373     part->clicked = FALSE;
1374   }
1375
1376   if (part->init_delay_counter > 0)
1377   {
1378     part->init_delay_counter--;
1379
1380     if (part->init_delay_counter == 0)
1381     {
1382       part->init_event_state = FALSE;
1383
1384       PlayGlobalAnimSoundAndMusic(part);
1385
1386       HandleGlobalAnimDelay(part, ANIM_DELAY_INIT,  "START [INIT_DELAY]");
1387       HandleGlobalAnimEvent(part, ANIM_EVENT_START, "START [ANIM]");
1388     }
1389
1390     return ANIM_STATE_WAITING;
1391   }
1392
1393   if (part->init_event_state)
1394     return ANIM_STATE_WAITING;
1395
1396   // animation part is now running/visible and therefore clickable
1397   part->clickable = TRUE;
1398
1399   // check if moving animation has left the visible screen area
1400   if ((part->x <= -g->width              && part->step_xoffset <= 0) ||
1401       (part->x >=  part->viewport_width  && part->step_xoffset >= 0) ||
1402       (part->y <= -g->height             && part->step_yoffset <= 0) ||
1403       (part->y >=  part->viewport_height && part->step_yoffset >= 0))
1404   {
1405     // do not wait for "anim" events for off-screen animations
1406     part->anim_event_state = FALSE;
1407
1408     // do not stop animation before "anim" or "post" counter are finished
1409     if (part->anim_delay_counter == 0 &&
1410         part->post_delay_counter == 0)
1411     {
1412       StopGlobalAnimSoundAndMusic(part);
1413
1414       HandleGlobalAnimEvent(part, ANIM_EVENT_END, "END [ANIM/OFF-SCREEN]");
1415
1416       part->post_delay_counter =
1417         (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
1418
1419       if (part->post_delay_counter > 0)
1420         return ANIM_STATE_RUNNING;
1421
1422       // drawing last frame not needed here -- animation not visible anymore
1423       return ANIM_STATE_RESTART;
1424     }
1425   }
1426
1427   if (part->anim_delay_counter > 0)
1428   {
1429     part->anim_delay_counter--;
1430
1431     if (part->anim_delay_counter == 0)
1432     {
1433       part->anim_event_state = FALSE;
1434
1435       StopGlobalAnimSoundAndMusic(part);
1436
1437       HandleGlobalAnimDelay(part, ANIM_DELAY_ANIM, "END [ANIM_DELAY]");
1438       HandleGlobalAnimEvent(part, ANIM_EVENT_END,  "END [ANIM_DELAY/EVENT]");
1439
1440       part->post_delay_counter =
1441         (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
1442
1443       if (part->post_delay_counter > 0)
1444         return ANIM_STATE_RUNNING;
1445
1446       // additional state "RUNNING" required to not skip drawing last frame
1447       return ANIM_STATE_RESTART | ANIM_STATE_RUNNING;
1448     }
1449   }
1450
1451   if (part->post_delay_counter > 0)
1452   {
1453     part->post_delay_counter--;
1454
1455     if (part->post_delay_counter == 0)
1456     {
1457       HandleGlobalAnimDelay(part, ANIM_DELAY_POST, "END [POST_DELAY]");
1458       HandleGlobalAnimEvent(part, ANIM_EVENT_POST, "END [POST_DELAY]");
1459
1460       return ANIM_STATE_RESTART;
1461     }
1462
1463     return ANIM_STATE_WAITING;
1464   }
1465
1466   // special case to prevent expiring loop sounds when playing
1467   PlayGlobalAnimSoundIfLoop(part);
1468
1469   if (!DelayReachedExt(&part->step_delay, part->step_delay_value,
1470                        anim_sync_frame))
1471     return ANIM_STATE_RUNNING;
1472
1473 #if 0
1474   {
1475     static unsigned int last_counter = -1;
1476     unsigned int counter = Counter();
1477
1478     printf("::: NEXT ANIM PART [%d, %d]\n",
1479            anim_sync_frame, counter - last_counter);
1480
1481     last_counter = counter;
1482   }
1483 #endif
1484
1485   part->x += part->step_xoffset;
1486   part->y += part->step_yoffset;
1487
1488   anim->last_x = part->x;
1489   anim->last_y = part->y;
1490
1491   return ANIM_STATE_RUNNING;
1492 }
1493
1494 static void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim,
1495                                   int action)
1496 {
1497   struct GlobalAnimPartControlInfo *part;
1498   struct GraphicInfo *c = &anim->control_info;
1499   int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);
1500   int state, active_part_nr;
1501   int i;
1502
1503 #if 0
1504   printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
1505          anim->mode_nr, anim->nr, anim->num_parts);
1506   printf("::: %d, %d, %d\n", global.num_toons, setup.toons, num_toons);
1507 #endif
1508
1509 #if 0
1510   printf("::: %s(%d): %d, %d, %d [%d]\n",
1511          (action == ANIM_START ? "ANIM_START" :
1512           action == ANIM_CONTINUE ? "ANIM_CONTINUE" :
1513           action == ANIM_STOP ? "ANIM_STOP" : "(should not happen)"),
1514          anim->nr,
1515          anim->state & ANIM_STATE_RESTART,
1516          anim->state & ANIM_STATE_WAITING,
1517          anim->state & ANIM_STATE_RUNNING,
1518          anim->num_parts);
1519 #endif
1520
1521   switch (action)
1522   {
1523     case ANIM_START:
1524       anim->state = anim->last_state = ANIM_STATE_RESTART;
1525       anim->active_part_nr = anim->last_active_part_nr = 0;
1526       anim->part_counter = 0;
1527
1528       break;
1529
1530     case ANIM_CONTINUE:
1531       if (anim->state == ANIM_STATE_INACTIVE)
1532         return;
1533
1534       anim->state = anim->last_state;
1535       anim->active_part_nr = anim->last_active_part_nr;
1536
1537       break;
1538
1539     case ANIM_STOP:
1540       anim->state = ANIM_STATE_INACTIVE;
1541
1542       for (i = 0; i < num_parts; i++)
1543         StopGlobalAnimSoundAndMusic(&anim->part[i]);
1544
1545       return;
1546
1547     default:
1548       break;
1549   }
1550
1551   if (c->anim_mode & ANIM_ALL || anim->num_parts == 0)
1552   {
1553 #if 0
1554     printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
1555            anim->mode_nr, anim->nr, num_parts);
1556 #endif
1557
1558     for (i = 0; i < num_parts; i++)
1559     {
1560       part = &anim->part[i];
1561
1562       switch (action)
1563       {
1564         case ANIM_START:
1565           anim->state = ANIM_STATE_RUNNING;
1566           part->state = ANIM_STATE_RESTART;
1567
1568           break;
1569
1570         case ANIM_CONTINUE:
1571           if (part->state == ANIM_STATE_INACTIVE)
1572             continue;
1573
1574           break;
1575
1576         case ANIM_STOP:
1577           part->state = ANIM_STATE_INACTIVE;
1578
1579           continue;
1580
1581         default:
1582           break;
1583       }
1584
1585       part->state = HandleGlobalAnim_Part(part, part->state);
1586
1587       // when animation mode is "once", stop after animation was played once
1588       if (c->anim_mode & ANIM_ONCE &&
1589           part->state & ANIM_STATE_RESTART)
1590         part->state = ANIM_STATE_INACTIVE;
1591     }
1592
1593     anim->last_state = anim->state;
1594     anim->last_active_part_nr = anim->active_part_nr;
1595
1596     return;
1597   }
1598
1599   if (anim->state & ANIM_STATE_RESTART)         // directly after restart
1600     anim->active_part_nr = getGlobalAnimationPart(anim);
1601
1602   part = &anim->part[anim->active_part_nr];
1603
1604   // first set all animation parts to "inactive", ...
1605   for (i = 0; i < num_parts; i++)
1606     anim->part[i].state = ANIM_STATE_INACTIVE;
1607
1608   // ... then set current animation parts to "running"
1609   part->state = ANIM_STATE_RUNNING;
1610
1611   anim->state = HandleGlobalAnim_Part(part, anim->state);
1612
1613   if (anim->state & ANIM_STATE_RESTART)
1614     anim->part_counter++;
1615
1616   // when animation mode is "once", stop after all animations were played once
1617   if (c->anim_mode & ANIM_ONCE &&
1618       anim->part_counter == anim->num_parts)
1619     anim->state = ANIM_STATE_INACTIVE;
1620
1621   state = anim->state;
1622   active_part_nr = anim->active_part_nr;
1623
1624   // while the animation parts are pausing (waiting or inactive), play the base
1625   // (main) animation; this corresponds to the "boring player animation" logic
1626   // (!!! KLUDGE WARNING: I THINK THIS IS A MESS THAT SHOULD BE CLEANED UP !!!)
1627   if (anim->has_base)
1628   {
1629     if (anim->state == ANIM_STATE_WAITING ||
1630         anim->state == ANIM_STATE_INACTIVE)
1631     {
1632       anim->active_part_nr = anim->num_parts;   // part nr of base animation
1633       part = &anim->part[anim->active_part_nr];
1634
1635       if (anim->state != anim->last_state)
1636         part->state = ANIM_STATE_RESTART;
1637
1638       anim->state = ANIM_STATE_RUNNING;
1639       part->state = HandleGlobalAnim_Part(part, part->state);
1640     }
1641   }
1642
1643   anim->last_state = state;
1644   anim->last_active_part_nr = active_part_nr;
1645 }
1646
1647 static void HandleGlobalAnim_Mode(struct GlobalAnimControlInfo *ctrl, int action)
1648 {
1649   int i;
1650
1651 #if 0
1652   printf("::: HandleGlobalAnim_Mode: %d => %d\n",
1653          ctrl->nr, ctrl->num_anims);
1654 #endif
1655
1656   for (i = 0; i < ctrl->num_anims; i++)
1657     HandleGlobalAnim_Main(&ctrl->anim[i], action);
1658 }
1659
1660 static void HandleGlobalAnim(int action, int game_mode)
1661 {
1662 #if 0
1663   printf("::: HandleGlobalAnim [mode == %d]\n", game_status);
1664 #endif
1665
1666   HandleGlobalAnim_Mode(&global_anim_ctrl[game_mode], action);
1667 }
1668
1669 static void DoAnimationExt(void)
1670 {
1671   int i;
1672
1673 #if 0
1674   printf("::: DoAnimation [%d, %d]\n", anim_sync_frame, Counter());
1675 #endif
1676
1677   // global animations now synchronized with frame delay of screen update
1678   anim_sync_frame++;
1679
1680   for (i = 0; i < NUM_GAME_MODES; i++)
1681     HandleGlobalAnim(ANIM_CONTINUE, i);
1682
1683 #if 0
1684   // force screen redraw in next frame to continue drawing global animations
1685   redraw_mask = REDRAW_ALL;
1686 #endif
1687 }
1688
1689 static void DoGlobalAnim_DelayAction(struct GlobalAnimPartControlInfo *part,
1690                                      int delay_type)
1691 {
1692   int delay_action =
1693     (delay_type == ANIM_DELAY_INIT ? part->control_info.init_delay_action :
1694      delay_type == ANIM_DELAY_ANIM ? part->control_info.anim_delay_action :
1695      delay_type == ANIM_DELAY_POST ? part->control_info.post_delay_action :
1696      ANIM_DELAY_ACTION_NONE);
1697
1698   if (delay_action == ANIM_DELAY_ACTION_NONE)
1699     return;
1700
1701   PushUserEvent(USEREVENT_ANIM_DELAY_ACTION, delay_action, 0);
1702 }
1703
1704 static boolean DoGlobalAnim_EventAction(struct GlobalAnimPartControlInfo *part)
1705 {
1706   int event_action = (part->init_event_state ?
1707                       part->control_info.init_event_action :
1708                       part->control_info.anim_event_action);
1709
1710   if (event_action == ANIM_EVENT_ACTION_NONE)
1711     return FALSE;
1712
1713   PushUserEvent(USEREVENT_ANIM_EVENT_ACTION, event_action, 0);
1714
1715   // check if further actions are allowed to be executed
1716   if (part->control_info.style & STYLE_MULTIPLE_ACTIONS)
1717     return FALSE;
1718
1719   return TRUE;
1720 }
1721
1722 static void InitGlobalAnim_Clickable(void)
1723 {
1724   int mode_nr;
1725
1726   for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
1727   {
1728     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
1729     int anim_nr;
1730
1731     for (anim_nr = 0; anim_nr < ctrl->num_anims; anim_nr++)
1732     {
1733       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
1734       int part_nr;
1735
1736       for (part_nr = 0; part_nr < anim->num_parts_all; part_nr++)
1737       {
1738         struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
1739
1740         if (part->triggered)
1741           part->clicked = TRUE;
1742
1743         part->triggered = FALSE;
1744         part->clickable = FALSE;
1745       }
1746     }
1747   }
1748 }
1749
1750 #define ANIM_CLICKED_RESET      0
1751 #define ANIM_CLICKED_PRESSED    1
1752 #define ANIM_CLICKED_RELEASED   2
1753
1754 static boolean InitGlobalAnim_Clicked(int mx, int my, int clicked_event)
1755 {
1756   boolean anything_clicked = FALSE;
1757   boolean any_part_clicked = FALSE;
1758   boolean any_event_action = FALSE;
1759   int mode_nr;
1760
1761   // check game modes in reverse draw order (to stop when clicked)
1762   for (mode_nr = NUM_GAME_MODES - 1; mode_nr >= 0; mode_nr--)
1763   {
1764     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
1765     int anim_nr;
1766
1767     // check animations in reverse draw order (to stop when clicked)
1768     for (anim_nr = ctrl->num_anims - 1; anim_nr >= 0; anim_nr--)
1769     {
1770       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
1771       int part_nr;
1772
1773       // check animation parts in reverse draw order (to stop when clicked)
1774       for (part_nr = anim->num_parts_all - 1; part_nr >= 0; part_nr--)
1775       {
1776         struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
1777
1778         if (clicked_event == ANIM_CLICKED_RESET)
1779         {
1780           part->clicked = FALSE;
1781
1782           continue;
1783         }
1784
1785         if (!part->clickable)
1786           continue;
1787
1788         if (part->state != ANIM_STATE_RUNNING)
1789           continue;
1790
1791         // always handle "any" click events (clicking anywhere on screen) ...
1792         if (clicked_event == ANIM_CLICKED_PRESSED &&
1793             isClickablePart(part, ANIM_EVENT_ANY))
1794         {
1795 #if DEBUG_ANIM_EVENTS
1796           printf("::: => %d.%d TRIGGERED BY ANY\n",
1797                  part->old_anim_nr + 1, part->old_nr + 1);
1798 #endif
1799
1800           part->clicked = TRUE;
1801           anything_clicked = clickConsumed(part);
1802         }
1803
1804         // always handle "unclick:any" events (releasing anywhere on screen) ...
1805         if (clicked_event == ANIM_CLICKED_RELEASED &&
1806             isClickablePart(part, ANIM_EVENT_UNCLICK_ANY))
1807         {
1808 #if DEBUG_ANIM_EVENTS
1809           printf("::: => %d.%d TRIGGERED BY UNCLICK:ANY\n",
1810                  part->old_anim_nr + 1, part->old_nr + 1);
1811 #endif
1812
1813           part->clicked = TRUE;
1814           anything_clicked = clickConsumed(part);
1815         }
1816
1817         // ... but only handle the first (topmost) clickable animation
1818         if (any_part_clicked)
1819           continue;
1820
1821         if (clicked_event == ANIM_CLICKED_PRESSED &&
1822             isClickedPart(part, mx, my, TRUE))
1823         {
1824 #if 0
1825           printf("::: %d.%d CLICKED [%d]\n", anim_nr, part_nr,
1826                  part->control_info.anim_event_action);
1827 #endif
1828
1829           // after executing event action, ignore any further actions
1830           if (!any_event_action && DoGlobalAnim_EventAction(part))
1831             any_event_action = TRUE;
1832
1833           // determine if mouse clicks should be blocked from other animations
1834           any_part_clicked = clickConsumed(part);
1835
1836           if (isClickablePart(part, ANIM_EVENT_SELF))
1837           {
1838 #if DEBUG_ANIM_EVENTS
1839             printf("::: => %d.%d TRIGGERED BY SELF\n",
1840                    part->old_anim_nr + 1, part->old_nr + 1);
1841 #endif
1842
1843             part->clicked = TRUE;
1844             anything_clicked = clickConsumed(part);
1845           }
1846
1847           // check if this click is defined to trigger other animations
1848           InitGlobalAnim_Triggered(part, &anything_clicked, &any_event_action,
1849                                    ANIM_EVENT_CLICK, "CLICK");
1850         }
1851       }
1852     }
1853   }
1854
1855   if (anything_clicked)
1856   {
1857     handle_click = TRUE;
1858
1859     HandleGlobalAnim(ANIM_CONTINUE, game_status);
1860
1861     handle_click = FALSE;
1862   }
1863
1864   return (anything_clicked || any_event_action);
1865 }
1866
1867 static void ResetGlobalAnim_Clickable(void)
1868 {
1869   InitGlobalAnim_Clickable();
1870 }
1871
1872 static void ResetGlobalAnim_Clicked(void)
1873 {
1874   InitGlobalAnim_Clicked(-1, -1, ANIM_CLICKED_RESET);
1875 }
1876
1877 boolean HandleGlobalAnimClicks(int mx, int my, int button, boolean force_click)
1878 {
1879   static boolean click_consumed = FALSE;
1880   static int last_button = 0;
1881   boolean press_event;
1882   boolean release_event;
1883   boolean click_consumed_current = click_consumed;
1884
1885   if (button != 0 && force_click)
1886     last_button = 0;
1887
1888   // check if button state has changed since last invocation
1889   press_event   = (button != 0 && last_button == 0);
1890   release_event = (button == 0 && last_button != 0);
1891   last_button = button;
1892
1893   if (press_event)
1894   {
1895     click_consumed = InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_PRESSED);
1896     click_consumed_current = click_consumed;
1897   }
1898
1899   if (release_event)
1900   {
1901     InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_RELEASED);
1902     click_consumed = FALSE;
1903   }
1904
1905   return click_consumed_current;
1906 }