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