added forcing pointer-style global animations to stay inside window area

[rocksndiamonds.git] / src / anim.c

diff --git a/src/anim.c b/src/anim.c
index 2ef7872558b841ff080a4ee6902b6e2b13d54096..8256ce7f60f5ec62fda3ebf49adb086a5450cc3b 100644 (file)
--- a/src/anim.c
+++ b/src/anim.c
@@ -14,13 +14,20 @@
 #include "anim.h"
 #include "main.h"
 #include "tools.h"
 #include "anim.h"
 #include "main.h"
 #include "tools.h"

+#include "files.h"
+#include "events.h"
+#include "screens.h"

 
 
 
 

-/* values for global toon animation definition */
+#define DEBUG_ANIM_DELAY               0
+#define DEBUG_ANIM_EVENTS              0
+
+
+// values for global toon animation definition

 #define NUM_GLOBAL_TOON_ANIMS          1
 #define NUM_GLOBAL_TOON_PARTS          MAX_NUM_TOONS
 
 #define NUM_GLOBAL_TOON_ANIMS          1
 #define NUM_GLOBAL_TOON_PARTS          MAX_NUM_TOONS
 

-/* values for global animation definition (including toons) */
+// values for global animation definition (including toons)

 #define NUM_GLOBAL_ANIMS_AND_TOONS     (NUM_GLOBAL_ANIMS +             \
                                         NUM_GLOBAL_TOON_ANIMS)
 #define NUM_GLOBAL_ANIM_PARTS_AND_TOONS        MAX(NUM_GLOBAL_ANIM_PARTS_ALL,  \
 #define NUM_GLOBAL_ANIMS_AND_TOONS     (NUM_GLOBAL_ANIMS +             \
                                         NUM_GLOBAL_TOON_ANIMS)
 #define NUM_GLOBAL_ANIM_PARTS_AND_TOONS        MAX(NUM_GLOBAL_ANIM_PARTS_ALL,  \


@@ -29,35 +36,45 @@
 #define ANIM_CLASS_BIT_TITLE_INITIAL   0
 #define ANIM_CLASS_BIT_TITLE           1
 #define ANIM_CLASS_BIT_MAIN            2
 #define ANIM_CLASS_BIT_TITLE_INITIAL   0
 #define ANIM_CLASS_BIT_TITLE           1
 #define ANIM_CLASS_BIT_MAIN            2

-#define ANIM_CLASS_BIT_SUBMENU         3
-#define ANIM_CLASS_BIT_MENU            4
-#define ANIM_CLASS_BIT_TOONS           5
+#define ANIM_CLASS_BIT_SCORES          3
+#define ANIM_CLASS_BIT_SUBMENU         4
+#define ANIM_CLASS_BIT_MENU            5
+#define ANIM_CLASS_BIT_TOONS           6
+#define ANIM_CLASS_BIT_NO_TITLE                7

 
 

-#define NUM_ANIM_CLASSES               6
+#define NUM_ANIM_CLASSES               8

 
 #define ANIM_CLASS_NONE                        0
 #define ANIM_CLASS_TITLE_INITIAL       (1 << ANIM_CLASS_BIT_TITLE_INITIAL)
 #define ANIM_CLASS_TITLE               (1 << ANIM_CLASS_BIT_TITLE)
 #define ANIM_CLASS_MAIN                        (1 << ANIM_CLASS_BIT_MAIN)
 
 #define ANIM_CLASS_NONE                        0
 #define ANIM_CLASS_TITLE_INITIAL       (1 << ANIM_CLASS_BIT_TITLE_INITIAL)
 #define ANIM_CLASS_TITLE               (1 << ANIM_CLASS_BIT_TITLE)
 #define ANIM_CLASS_MAIN                        (1 << ANIM_CLASS_BIT_MAIN)

+#define ANIM_CLASS_SCORES              (1 << ANIM_CLASS_BIT_SCORES)

 #define ANIM_CLASS_SUBMENU             (1 << ANIM_CLASS_BIT_SUBMENU)
 #define ANIM_CLASS_MENU                        (1 << ANIM_CLASS_BIT_MENU)
 #define ANIM_CLASS_TOONS               (1 << ANIM_CLASS_BIT_TOONS)
 #define ANIM_CLASS_SUBMENU             (1 << ANIM_CLASS_BIT_SUBMENU)
 #define ANIM_CLASS_MENU                        (1 << ANIM_CLASS_BIT_MENU)
 #define ANIM_CLASS_TOONS               (1 << ANIM_CLASS_BIT_TOONS)

+#define ANIM_CLASS_NO_TITLE            (1 << ANIM_CLASS_BIT_NO_TITLE)

 
 

-#define ANIM_CLASS_TOONS_MENU_MAIN     (ANIM_CLASS_TOONS |     \
-                                        ANIM_CLASS_MENU  |     \
-                                        ANIM_CLASS_MAIN)
+#define ANIM_CLASS_TOONS_SCORES                (ANIM_CLASS_TOONS       |       \
+                                        ANIM_CLASS_SCORES      |       \
+                                        ANIM_CLASS_NO_TITLE)

 
 

-#define ANIM_CLASS_TOONS_MENU_SUBMENU  (ANIM_CLASS_TOONS |     \
-                                        ANIM_CLASS_MENU  |     \
-                                        ANIM_CLASS_SUBMENU)
+#define ANIM_CLASS_TOONS_MENU_MAIN     (ANIM_CLASS_TOONS       |       \
+                                        ANIM_CLASS_MENU        |       \
+                                        ANIM_CLASS_MAIN        |       \
+                                        ANIM_CLASS_NO_TITLE)

 
 

-/* values for global animation states */
+#define ANIM_CLASS_TOONS_MENU_SUBMENU  (ANIM_CLASS_TOONS       |       \
+                                        ANIM_CLASS_MENU        |       \
+                                        ANIM_CLASS_SUBMENU     |       \
+                                        ANIM_CLASS_NO_TITLE)
+
+// values for global animation states

 #define ANIM_STATE_INACTIVE            0
 #define ANIM_STATE_RESTART             (1 << 0)
 #define ANIM_STATE_WAITING             (1 << 1)
 #define ANIM_STATE_RUNNING             (1 << 2)
 
 #define ANIM_STATE_INACTIVE            0
 #define ANIM_STATE_RESTART             (1 << 0)
 #define ANIM_STATE_WAITING             (1 << 1)
 #define ANIM_STATE_RUNNING             (1 << 2)
 

-/* values for global animation control */
+// values for global animation control

 #define ANIM_NO_ACTION                 0
 #define ANIM_START                     1
 #define ANIM_CONTINUE                  2
 #define ANIM_NO_ACTION                 0
 #define ANIM_START                     1
 #define ANIM_CONTINUE                  2


@@ -66,10 +83,15 @@
 
 struct GlobalAnimPartControlInfo
 {
 
 struct GlobalAnimPartControlInfo
 {

+  int old_nr;          // position before mapping animation parts linearly
+  int old_anim_nr;     // position before mapping animations linearly
+

   int nr;
   int anim_nr;
   int mode_nr;
 
   int nr;
   int anim_nr;
   int mode_nr;
 

+  boolean is_base;     // animation part is base/main/default animation part
+

   int sound;
   int music;
   int graphic;
   int sound;
   int music;
   int graphic;


@@ -95,6 +117,7 @@ struct GlobalAnimPartControlInfo
   boolean init_event_state;
   boolean anim_event_state;
 
   boolean init_event_state;
   boolean anim_event_state;
 

+  boolean triggered;

   boolean clickable;
   boolean clicked;
 
   boolean clickable;
   boolean clicked;
 


@@ -114,11 +137,14 @@ struct GlobalAnimMainControlInfo
 
   struct GraphicInfo control_info;
 
 
   struct GraphicInfo control_info;
 

-  int num_parts;
+  int num_parts;       // number of animation parts, but without base part
+  int num_parts_all;   // number of animation parts, including base part

   int part_counter;
   int active_part_nr;
 
   int part_counter;
   int active_part_nr;
 

-  boolean has_base;
+  boolean has_base;    // animation has base/main/default animation part
+
+  int last_x, last_y;

 
   int init_delay_counter;
 
 
   int init_delay_counter;
 


@@ -157,7 +183,10 @@ struct GameModeAnimClass
   { GAME_MODE_SETUP,                   ANIM_CLASS_TOONS_MENU_SUBMENU   },
   { GAME_MODE_PSEUDO_MAINONLY,         ANIM_CLASS_TOONS_MENU_MAIN      },
   { GAME_MODE_PSEUDO_TYPENAME,         ANIM_CLASS_TOONS_MENU_MAIN      },
   { GAME_MODE_SETUP,                   ANIM_CLASS_TOONS_MENU_SUBMENU   },
   { GAME_MODE_PSEUDO_MAINONLY,         ANIM_CLASS_TOONS_MENU_MAIN      },
   { GAME_MODE_PSEUDO_TYPENAME,         ANIM_CLASS_TOONS_MENU_MAIN      },

-  { GAME_MODE_SCORES,                  ANIM_CLASS_TOONS                },
+  { GAME_MODE_PSEUDO_SCORESOLD,                ANIM_CLASS_TOONS_SCORES         },
+  { GAME_MODE_PSEUDO_SCORESNEW,                ANIM_CLASS_TOONS_SCORES         },
+  { GAME_MODE_EDITOR,                  ANIM_CLASS_NO_TITLE             },
+  { GAME_MODE_PLAYING,                 ANIM_CLASS_NO_TITLE             },

 
   { -1,                                        -1                              }
 };
 
   { -1,                                        -1                              }
 };


@@ -171,18 +200,22 @@ struct AnimClassGameMode
   { ANIM_CLASS_BIT_TITLE_INITIAL,      GAME_MODE_TITLE_INITIAL         },
   { ANIM_CLASS_BIT_TITLE,              GAME_MODE_TITLE                 },
   { ANIM_CLASS_BIT_MAIN,               GAME_MODE_MAIN                  },
   { ANIM_CLASS_BIT_TITLE_INITIAL,      GAME_MODE_TITLE_INITIAL         },
   { ANIM_CLASS_BIT_TITLE,              GAME_MODE_TITLE                 },
   { ANIM_CLASS_BIT_MAIN,               GAME_MODE_MAIN                  },

+  { ANIM_CLASS_BIT_SCORES,             GAME_MODE_SCORES                },

   { ANIM_CLASS_BIT_SUBMENU,            GAME_MODE_PSEUDO_SUBMENU        },
   { ANIM_CLASS_BIT_MENU,               GAME_MODE_PSEUDO_MENU           },
   { ANIM_CLASS_BIT_TOONS,              GAME_MODE_PSEUDO_TOONS          },
   { ANIM_CLASS_BIT_SUBMENU,            GAME_MODE_PSEUDO_SUBMENU        },
   { ANIM_CLASS_BIT_MENU,               GAME_MODE_PSEUDO_MENU           },
   { ANIM_CLASS_BIT_TOONS,              GAME_MODE_PSEUDO_TOONS          },

+  { ANIM_CLASS_BIT_NO_TITLE,           GAME_MODE_PSEUDO_NO_TITLE       },

 
   { -1,                                        -1                              }
 };
 
 
   { -1,                                        -1                              }
 };
 

-/* forward declaration for internal use */
+// forward declaration for internal use
+static void DoGlobalAnim_DelayAction(struct GlobalAnimPartControlInfo *, int);
+static boolean DoGlobalAnim_EventAction(struct GlobalAnimPartControlInfo *);

 static void HandleGlobalAnim(int, int);
 static void DoAnimationExt(void);
 static void HandleGlobalAnim(int, int);
 static void DoAnimationExt(void);

-static void ResetGlobalAnim_Clickable();
-static void ResetGlobalAnim_Clicked();
+static void ResetGlobalAnim_Clickable(void);
+static void ResetGlobalAnim_Clicked(void);

 
 static struct GlobalAnimControlInfo global_anim_ctrl[NUM_GAME_MODES];
 
 
 static struct GlobalAnimControlInfo global_anim_ctrl[NUM_GAME_MODES];
 


@@ -191,15 +224,18 @@ static unsigned int anim_sync_frame = 0;
 static int game_mode_anim_classes[NUM_GAME_MODES];
 static int anim_class_game_modes[NUM_ANIM_CLASSES];
 
 static int game_mode_anim_classes[NUM_GAME_MODES];
 static int anim_class_game_modes[NUM_ANIM_CLASSES];
 

+static int anim_status_last_before_fading = GAME_MODE_DEFAULT;

 static int anim_status_last = GAME_MODE_DEFAULT;
 static int anim_classes_last = ANIM_CLASS_NONE;
 
 static boolean drawing_to_fading_buffer = FALSE;
 
 static int anim_status_last = GAME_MODE_DEFAULT;
 static int anim_classes_last = ANIM_CLASS_NONE;
 
 static boolean drawing_to_fading_buffer = FALSE;
 

+static boolean handle_click = FALSE;

 
 

-/* ========================================================================= */
-/* generic animation frame calculation                                       */
-/* ========================================================================= */
+
+// ============================================================================
+// generic animation frame calculation
+// ============================================================================

 
 int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
                      int sync_frame)
 
 int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
                      int sync_frame)


@@ -208,34 +244,34 @@ int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
 
   sync_frame += start_frame * delay;
 
 
   sync_frame += start_frame * delay;
 

-  if (mode & ANIM_LOOP)                        /* looping animation */
+  if (mode & ANIM_LOOP)                        // looping animation

   {
     frame = (sync_frame % (delay * num_frames)) / delay;
   }
   {
     frame = (sync_frame % (delay * num_frames)) / delay;
   }

-  else if (mode & ANIM_LINEAR)         /* linear (non-looping) animation */
+  else if (mode & ANIM_LINEAR)         // linear (non-looping) animation

   {
     frame = sync_frame / delay;
 
     if (frame > num_frames - 1)
       frame = num_frames - 1;
   }
   {
     frame = sync_frame / delay;
 
     if (frame > num_frames - 1)
       frame = num_frames - 1;
   }

-  else if (mode & ANIM_PINGPONG)       /* oscillate (border frames once) */
+  else if (mode & ANIM_PINGPONG)       // oscillate (border frames once)

   {
     int max_anim_frames = (num_frames > 1 ? 2 * num_frames - 2 : 1);
 
     frame = (sync_frame % (delay * max_anim_frames)) / delay;
     frame = (frame < num_frames ? frame : max_anim_frames - frame);
   }
   {
     int max_anim_frames = (num_frames > 1 ? 2 * num_frames - 2 : 1);
 
     frame = (sync_frame % (delay * max_anim_frames)) / delay;
     frame = (frame < num_frames ? frame : max_anim_frames - frame);
   }

-  else if (mode & ANIM_PINGPONG2)      /* oscillate (border frames twice) */
+  else if (mode & ANIM_PINGPONG2)      // oscillate (border frames twice)

   {
     int max_anim_frames = 2 * num_frames;
 
     frame = (sync_frame % (delay * max_anim_frames)) / delay;
     frame = (frame < num_frames ? frame : max_anim_frames - frame - 1);
   }
   {
     int max_anim_frames = 2 * num_frames;
 
     frame = (sync_frame % (delay * max_anim_frames)) / delay;
     frame = (frame < num_frames ? frame : max_anim_frames - frame - 1);
   }

-  else if (mode & ANIM_RANDOM)         /* play frames in random order */
+  else if (mode & ANIM_RANDOM)         // play frames in random order

   {
   {

-    /* note: expect different frames for the same delay cycle! */
+    // note: expect different frames for the same delay cycle!

 
     if (gfx.anim_random_frame < 0)
       frame = GetSimpleRandom(num_frames);
 
     if (gfx.anim_random_frame < 0)
       frame = GetSimpleRandom(num_frames);


@@ -247,16 +283,16 @@ int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
     frame = sync_frame % num_frames;
   }
 
     frame = sync_frame % num_frames;
   }
 

-  if (mode & ANIM_REVERSE)             /* use reverse animation direction */
+  if (mode & ANIM_REVERSE)             // use reverse animation direction

     frame = num_frames - frame - 1;
 
   return frame;
 }
 
 
     frame = num_frames - frame - 1;
 
   return frame;
 }
 
 

-/* ========================================================================= */
-/* global animation functions                                                */
-/* ========================================================================= */
+// ============================================================================
+// global animation functions
+// ============================================================================

 
 static int getGlobalAnimationPart(struct GlobalAnimMainControlInfo *anim)
 {
 
 static int getGlobalAnimationPart(struct GlobalAnimMainControlInfo *anim)
 {


@@ -307,7 +343,7 @@ static int compareGlobalAnimMainControlInfo(const void *obj1, const void *obj2)
   return compare_result;
 }
 
   return compare_result;
 }
 

-static void InitToonControls()
+static void InitToonControls(void)

 {
   int mode_nr_toons = GAME_MODE_PSEUDO_TOONS;
   struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr_toons];
 {
   int mode_nr_toons = GAME_MODE_PSEUDO_TOONS;
   struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr_toons];


@@ -328,11 +364,15 @@ static void InitToonControls()
   anim->control_info = graphic_info[control];
 
   anim->num_parts = 0;
   anim->control_info = graphic_info[control];
 
   anim->num_parts = 0;

+  anim->num_parts_all = 0;

   anim->part_counter = 0;
   anim->active_part_nr = 0;
 
   anim->has_base = FALSE;
 
   anim->part_counter = 0;
   anim->active_part_nr = 0;
 
   anim->has_base = FALSE;
 

+  anim->last_x = POS_OFFSCREEN;
+  anim->last_y = POS_OFFSCREEN;
+

   anim->init_delay_counter = 0;
 
   anim->state = ANIM_STATE_INACTIVE;
   anim->init_delay_counter = 0;
 
   anim->state = ANIM_STATE_INACTIVE;


@@ -350,9 +390,13 @@ static void InitToonControls()
     part->nr = part_nr;
     part->anim_nr = anim_nr;
     part->mode_nr = mode_nr;
     part->nr = part_nr;
     part->anim_nr = anim_nr;
     part->mode_nr = mode_nr;

+
+    part->is_base = FALSE;
+

     part->sound = sound;
     part->music = music;
     part->graphic = graphic;
     part->sound = sound;
     part->music = music;
     part->graphic = graphic;

+

     part->graphic_info = graphic_info[graphic];
     part->control_info = graphic_info[control];
 
     part->graphic_info = graphic_info[graphic];
     part->control_info = graphic_info[control];
 


@@ -373,13 +417,15 @@ static void InitToonControls()
     part->last_anim_status = -1;
 
     anim->num_parts++;
     part->last_anim_status = -1;
 
     anim->num_parts++;

+    anim->num_parts_all++;
+

     part_nr++;
   }
 
   ctrl->num_anims++;
 }
 
     part_nr++;
   }
 
   ctrl->num_anims++;
 }
 

-void InitGlobalAnimControls()
+static void InitGlobalAnimControls(void)

 {
   int i, m, a, p;
   int mode_nr, anim_nr, part_nr;
 {
   int i, m, a, p;
   int mode_nr, anim_nr, part_nr;


@@ -414,11 +460,15 @@ void InitGlobalAnimControls()
       anim->control_info = graphic_info[control];
 
       anim->num_parts = 0;
       anim->control_info = graphic_info[control];
 
       anim->num_parts = 0;

+      anim->num_parts_all = 0;

       anim->part_counter = 0;
       anim->active_part_nr = 0;
 
       anim->has_base = FALSE;
 
       anim->part_counter = 0;
       anim->active_part_nr = 0;
 
       anim->has_base = FALSE;
 

+      anim->last_x = POS_OFFSCREEN;
+      anim->last_y = POS_OFFSCREEN;
+

       anim->init_delay_counter = 0;
 
       anim->state = ANIM_STATE_INACTIVE;
       anim->init_delay_counter = 0;
 
       anim->state = ANIM_STATE_INACTIVE;


@@ -448,12 +498,17 @@ void InitGlobalAnimControls()
               m, a, p, mode_nr, anim_nr, part_nr, sound);
 #endif
 
               m, a, p, mode_nr, anim_nr, part_nr, sound);
 #endif
 

+       part->old_nr = p;
+       part->old_anim_nr = a;
+

        part->nr = part_nr;
        part->anim_nr = anim_nr;
        part->mode_nr = mode_nr;
        part->nr = part_nr;
        part->anim_nr = anim_nr;
        part->mode_nr = mode_nr;

+

        part->sound = sound;
        part->music = music;
        part->graphic = graphic;
        part->sound = sound;
        part->music = music;
        part->graphic = graphic;

+

        part->graphic_info = graphic_info[graphic];
        part->control_info = graphic_info[control];
 
        part->graphic_info = graphic_info[graphic];
        part->control_info = graphic_info[control];
 


@@ -465,13 +520,19 @@ void InitGlobalAnimControls()
        part->state = ANIM_STATE_INACTIVE;
        part->last_anim_status = -1;
 
        part->state = ANIM_STATE_INACTIVE;
        part->last_anim_status = -1;
 

+       anim->num_parts_all++;
+

        if (p < GLOBAL_ANIM_ID_PART_BASE)
        {
        if (p < GLOBAL_ANIM_ID_PART_BASE)
        {

+         part->is_base = FALSE;
+

          anim->num_parts++;
          part_nr++;
        }
        else
        {
          anim->num_parts++;
          part_nr++;
        }
        else
        {

+         part->is_base = TRUE;
+

          anim->base = *part;
          anim->has_base = TRUE;
        }
          anim->base = *part;
          anim->has_base = TRUE;
        }


@@ -487,12 +548,12 @@ void InitGlobalAnimControls()
 
   InitToonControls();
 
 
   InitToonControls();
 

-  /* sort all animations according to draw_order and animation number */
+  // sort all animations according to draw_order and animation number

   for (m = 0; m < NUM_GAME_MODES; m++)
   {
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[m];
 
   for (m = 0; m < NUM_GAME_MODES; m++)
   {
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[m];
 

-    /* sort all main animations for this game mode */
+    // sort all main animations for this game mode

     qsort(ctrl->anim, ctrl->num_anims,
          sizeof(struct GlobalAnimMainControlInfo),
          compareGlobalAnimMainControlInfo);
     qsort(ctrl->anim, ctrl->num_anims,
          sizeof(struct GlobalAnimMainControlInfo),
          compareGlobalAnimMainControlInfo);


@@ -501,7 +562,7 @@ void InitGlobalAnimControls()
     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[a];
 
     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[a];
 

-      /* sort all animation parts for this main animation */
+      // sort all animation parts for this main animation

       qsort(anim->part, anim->num_parts,
            sizeof(struct GlobalAnimPartControlInfo),
            compareGlobalAnimPartControlInfo);
       qsort(anim->part, anim->num_parts,
            sizeof(struct GlobalAnimPartControlInfo),
            compareGlobalAnimPartControlInfo);


@@ -520,16 +581,17 @@ void InitGlobalAnimControls()
     anim_class_game_modes[anim_class_game_modes_list[i].class_bit] =
       anim_class_game_modes_list[i].game_mode;
 
     anim_class_game_modes[anim_class_game_modes_list[i].class_bit] =
       anim_class_game_modes_list[i].game_mode;
 

+  anim_status_last_before_fading = GAME_MODE_LOADING;

   anim_status_last = GAME_MODE_LOADING;
   anim_classes_last = ANIM_CLASS_NONE;
 }
 
   anim_status_last = GAME_MODE_LOADING;
   anim_classes_last = ANIM_CLASS_NONE;
 }
 

-void InitGlobalAnimations()
+void InitGlobalAnimations(void)

 {
   InitGlobalAnimControls();
 }
 
 {
   InitGlobalAnimControls();
 }
 

-void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
+static void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)

 {
   Bitmap *fade_bitmap =
     (drawing_target == DRAW_TO_FADE_SOURCE ? gfx.fade_bitmap_source :
 {
   Bitmap *fade_bitmap =
     (drawing_target == DRAW_TO_FADE_SOURCE ? gfx.fade_bitmap_source :


@@ -558,15 +620,23 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
     if (drawing_target == DRAW_TO_FADE_TARGET)
       after_fading = TRUE;
 
     if (drawing_target == DRAW_TO_FADE_TARGET)
       after_fading = TRUE;
 

+    // special case: changing from/to this screen is done without fading
+    if (global.anim_status == GAME_MODE_PSEUDO_TYPENAME ||
+       anim_status_last   == GAME_MODE_PSEUDO_TYPENAME)
+      after_fading = TRUE;
+

     // ---------- part 1 ------------------------------------------------------
     // start or stop global animations by change of game mode
     // (special handling of animations for "current screen" and "all screens")
 
     // ---------- part 1 ------------------------------------------------------
     // start or stop global animations by change of game mode
     // (special handling of animations for "current screen" and "all screens")
 

-    // stop animations for last screen
-    game_mode_anim_action[anim_status_last] = ANIM_STOP;
+    if (global.anim_status_next != anim_status_last_before_fading)
+    {
+      // stop animations for last screen before fading to new screen
+      game_mode_anim_action[anim_status_last] = ANIM_STOP;

 
 

-    // start animations for current screen
-    game_mode_anim_action[global.anim_status] = ANIM_START;
+      // start animations for current screen after fading to new screen
+      game_mode_anim_action[global.anim_status] = ANIM_START;
+    }

 
     // start animations for all screens after loading new artwork set
     if (anim_status_last == GAME_MODE_LOADING)
 
     // start animations for all screens after loading new artwork set
     if (anim_status_last == GAME_MODE_LOADING)


@@ -595,7 +665,10 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
     if (drawing_target == DRAW_TO_SCREEN)
     {
       if (after_fading)
     if (drawing_target == DRAW_TO_SCREEN)
     {
       if (after_fading)

+      {

        anim_classes_last = anim_classes_next;
        anim_classes_last = anim_classes_next;

+       anim_status_last_before_fading = global.anim_status;
+      }

 
       anim_status_last = global.anim_status;
 
 
       anim_status_last = global.anim_status;
 


@@ -673,6 +746,10 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
        int cut_y = 0;
        int sync_frame;
        int frame;
        int cut_y = 0;
        int sync_frame;
        int frame;

+       void (*blit_bitmap)(Bitmap *, Bitmap *, int, int, int, int, int, int) =
+         (g->draw_masked ? BlitBitmapMasked : BlitBitmap);
+       void (*blit_screen)(Bitmap *, int, int, int, int, int, int) =
+         (g->draw_masked ? BlitToScreenMasked : BlitToScreen);

 
        if (!(part->state & ANIM_STATE_RUNNING))
          continue;
 
        if (!(part->state & ANIM_STATE_RUNNING))
          continue;


@@ -716,11 +793,11 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
        src_y += cut_y;
 
        if (drawing_target == DRAW_TO_SCREEN)
        src_y += cut_y;
 
        if (drawing_target == DRAW_TO_SCREEN)

-         BlitToScreenMasked(src_bitmap, src_x, src_y, width, height,
-                            dst_x, dst_y);
+         blit_screen(src_bitmap, src_x, src_y, width, height,
+                     dst_x, dst_y);

        else
        else

-         BlitBitmapMasked(src_bitmap, fade_bitmap, src_x, src_y, width, height,
-                          dst_x, dst_y);
+         blit_bitmap(src_bitmap, fade_bitmap, src_x, src_y, width, height,
+                     dst_x, dst_y);

       }
     }
   }
       }
     }
   }


@@ -738,16 +815,27 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
 
 void DrawGlobalAnimations(int drawing_target, int drawing_stage)
 {
 
 void DrawGlobalAnimations(int drawing_target, int drawing_stage)
 {

+  int last_cursor_mode_override = gfx.cursor_mode_override;
+

   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_1)
   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_1)

+  {

     ResetGlobalAnim_Clickable();
 
     ResetGlobalAnim_Clickable();
 

+    gfx.cursor_mode_override = CURSOR_UNDEFINED;
+  }
+

   DrawGlobalAnimationsExt(drawing_target, drawing_stage);
 
   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_2)
   DrawGlobalAnimationsExt(drawing_target, drawing_stage);
 
   if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_2)

+  {

     ResetGlobalAnim_Clicked();
     ResetGlobalAnim_Clicked();

+  }
+
+  if (gfx.cursor_mode_override != last_cursor_mode_override)
+    SetMouseCursor(gfx.cursor_mode);

 }
 
 }
 

-boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
+static boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)

 {
   int viewport_x;
   int viewport_y;
 {
   int viewport_x;
   int viewport_y;


@@ -755,7 +843,8 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
   int viewport_height;
   boolean changed = FALSE;
 
   int viewport_height;
   boolean changed = FALSE;
 

-  if (part->last_anim_status == global.anim_status)
+  if (part->last_anim_status == global.anim_status &&
+      part->control_info.class != get_hash_from_key("pointer"))

     return FALSE;
 
   part->last_anim_status = global.anim_status;
     return FALSE;
 
   part->last_anim_status = global.anim_status;


@@ -772,6 +861,20 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
 
     part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_2;
   }
 
     part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_2;
   }

+  else if (part->control_info.class == get_hash_from_key("pointer"))
+  {
+    int mx = MIN(MAX(0, gfx.mouse_x), WIN_XSIZE - 1);
+    int my = MIN(MAX(0, gfx.mouse_y), WIN_YSIZE - 1);
+
+    viewport_x = mx + part->control_info.x;
+    viewport_y = my + part->control_info.y;
+    viewport_width  = part->graphic_info.width;
+    viewport_height = part->graphic_info.height;
+
+    part->drawing_stage = DRAW_GLOBAL_ANIM_STAGE_2;
+
+    gfx.cursor_mode_override = CURSOR_NONE;
+  }

   else if (part->control_info.class == get_hash_from_key("door_1"))
   {
     viewport_x = DX;
   else if (part->control_info.class == get_hash_from_key("door_1"))
   {
     viewport_x = DX;


@@ -781,10 +884,20 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
   }
   else if (part->control_info.class == get_hash_from_key("door_2"))
   {
   }
   else if (part->control_info.class == get_hash_from_key("door_2"))
   {

-    viewport_x = VX;
-    viewport_y = VY;
-    viewport_width  = VXSIZE;
-    viewport_height = VYSIZE;
+    if (part->mode_nr == GAME_MODE_EDITOR)
+    {
+      viewport_x = EX;
+      viewport_y = EY;
+      viewport_width  = EXSIZE;
+      viewport_height = EYSIZE;
+    }
+    else
+    {
+      viewport_x = VX;
+      viewport_y = VY;
+      viewport_width  = VXSIZE;
+      viewport_height = VYSIZE;
+    }

   }
   else         // default: "playfield"
   {
   }
   else         // default: "playfield"
   {


@@ -858,7 +971,10 @@ static void PlayGlobalAnimMusic(struct GlobalAnimPartControlInfo *part)
   if (!setup.sound_music)
     return;
 
   if (!setup.sound_music)
     return;
 

-  PlayMusic(music);
+  if (IS_LOOP_MUSIC(music))
+    PlayMusicLoop(music);
+  else
+    PlayMusic(music);

 
 #if 0
   printf("::: PLAY MUSIC %d.%d.%d: %d\n",
 
 #if 0
   printf("::: PLAY MUSIC %d.%d.%d: %d\n",


@@ -897,12 +1013,67 @@ static void StopGlobalAnimSoundAndMusic(struct GlobalAnimPartControlInfo *part)
   StopGlobalAnimMusic(part);
 }
 
   StopGlobalAnimMusic(part);
 }
 

-static boolean isClickablePart(struct GlobalAnimPartControlInfo *part)
+static void PlayGlobalAnimSoundIfLoop(struct GlobalAnimPartControlInfo *part)
+{
+  // when drawing animations to fading buffer, do not play sounds
+  if (drawing_to_fading_buffer)
+    return;
+
+  // loop sounds only expire when playing
+  if (game_status != GAME_MODE_PLAYING)
+    return;
+
+  // check if any sound is defined for this animation part
+  if (part->sound == SND_UNDEFINED)
+    return;
+
+  // normal (non-loop) sounds do not expire when playing
+  if (!IS_LOOP_SOUND(part->sound))
+    return;
+
+  // prevent expiring loop sounds when playing
+  PlayGlobalAnimSound(part);
+}
+
+static boolean checkGlobalAnimEvent(int anim_event, int mask)
+{
+  int mask_anim_only = mask & ~ANIM_EVENT_PART_MASK;
+
+  if (mask & ANIM_EVENT_ANY)
+    return (anim_event & ANIM_EVENT_ANY);
+  else if (mask & ANIM_EVENT_SELF)
+    return (anim_event & ANIM_EVENT_SELF);
+  else if (mask & ANIM_EVENT_UNCLICK_ANY)
+    return (anim_event & ANIM_EVENT_UNCLICK_ANY);
+  else
+    return (anim_event == mask ||
+           anim_event == mask_anim_only);
+}
+
+static boolean isClickablePart(struct GlobalAnimPartControlInfo *part, int mask)

 {
   struct GraphicInfo *c = &part->control_info;
 {
   struct GraphicInfo *c = &part->control_info;

+  int num_init_events = GetGlobalAnimEventValueCount(c->init_event);
+  int num_anim_events = GetGlobalAnimEventValueCount(c->anim_event);
+  int i;
+
+  for (i = 0; i < num_init_events; i++)
+  {
+    int init_event = GetGlobalAnimEventValue(c->init_event, i);
+
+    if (checkGlobalAnimEvent(init_event, mask))
+      return TRUE;
+  }
+
+  for (i = 0; i < num_anim_events; i++)
+  {
+    int anim_event = GetGlobalAnimEventValue(c->anim_event, i);

 
 

-  return (c->init_event & ANIM_EVENT_CLICK ||
-         c->anim_event & ANIM_EVENT_CLICK);
+    if (checkGlobalAnimEvent(anim_event, mask))
+      return TRUE;
+  }
+
+  return FALSE;

 }
 
 static boolean isClickedPart(struct GlobalAnimPartControlInfo *part,
 }
 
 static boolean isClickedPart(struct GlobalAnimPartControlInfo *part,


@@ -935,8 +1106,108 @@ static boolean isClickedPart(struct GlobalAnimPartControlInfo *part,
   return TRUE;
 }
 
   return TRUE;
 }
 

-int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
+static boolean clickConsumed(struct GlobalAnimPartControlInfo *part)
+{
+  return (part->control_info.style & STYLE_PASSTHROUGH ? FALSE : TRUE);
+}
+
+static void InitGlobalAnim_Triggered(struct GlobalAnimPartControlInfo *part,
+                                    boolean *anything_clicked,
+                                    boolean *any_event_action,
+                                    int event_value, char *info_text)

 {
 {

+  struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[part->mode_nr];
+
+  int gic_anim_nr = part->old_anim_nr + 1;     // X as in "anim_X"
+  int gic_part_nr = part->old_nr + 1;          // Y as in "part_Y"
+  int mask = event_value | (gic_anim_nr << ANIM_EVENT_ANIM_BIT);
+
+  if (!part->is_base)
+    mask |= gic_part_nr << ANIM_EVENT_PART_BIT;
+
+  int anim2_nr;
+
+  for (anim2_nr = 0; anim2_nr < ctrl->num_anims; anim2_nr++)
+  {
+    struct GlobalAnimMainControlInfo *anim2 = &ctrl->anim[anim2_nr];
+    int part2_nr;
+
+    for (part2_nr = 0; part2_nr < anim2->num_parts_all; part2_nr++)
+    {
+      struct GlobalAnimPartControlInfo *part2 = &anim2->part[part2_nr];
+
+      if (part2->state != ANIM_STATE_RUNNING)
+       continue;
+
+      if (isClickablePart(part2, mask))
+      {
+       part2->triggered = TRUE;
+       *anything_clicked = clickConsumed(part);        // click was on "part"!
+
+#if DEBUG_ANIM_EVENTS
+       printf("::: => %d.%d TRIGGERED BY %s OF %d.%d\n",
+              part2->old_anim_nr + 1, part2->old_nr + 1, info_text,
+              part->old_anim_nr + 1, part->old_nr + 1);
+#endif
+#if 0
+       printf("::: %d.%d TRIGGER CLICKED [%d]\n", anim2_nr, part2_nr,
+              part2->control_info.anim_event_action);
+#endif
+
+       // after executing event action, ignore any further actions
+       if (!*any_event_action && DoGlobalAnim_EventAction(part2))
+         *any_event_action = TRUE;
+      }
+
+#if 0
+      struct GraphicInfo *c = &part2->control_info;
+
+      printf("::: - %d.%d: 0x%08x, 0x%08x [0x%08x]",
+            anim2_nr, part2_nr, c->init_event, c->anim_event, mask);
+
+      if (isClickablePart(part2, mask))
+       printf(" <--- TRIGGERED BY %d.%d",
+              anim_nr, part_nr);
+
+      printf("\n");
+#endif
+    }
+  }
+}
+
+static void HandleGlobalAnimDelay(struct GlobalAnimPartControlInfo *part,
+                                 int delay_type, char *info_text)
+{
+#if DEBUG_ANIM_DELAY
+  printf("::: %d.%d %s\n", part->old_anim_nr + 1, part->old_nr + 1, info_text);
+#endif
+
+  DoGlobalAnim_DelayAction(part, delay_type);
+}
+
+static void HandleGlobalAnimEvent(struct GlobalAnimPartControlInfo *part,
+                                 int event_value, char *info_text)
+{
+#if DEBUG_ANIM_EVENTS
+  printf("::: %d.%d %s\n", part->old_anim_nr + 1, part->old_nr + 1, info_text);
+#endif
+
+  boolean anything_clicked = FALSE;
+  boolean any_event_action = FALSE;
+
+  // check if this event is defined to trigger other animations
+  InitGlobalAnim_Triggered(part, &anything_clicked, &any_event_action,
+                          event_value, info_text);
+}
+
+static int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part,
+                                int state)
+{
+  if (handle_click && !part->clicked)
+    return state;
+
+  struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[part->mode_nr];
+  struct GlobalAnimMainControlInfo *anim = &ctrl->anim[part->anim_nr];

   struct GraphicInfo *g = &part->graphic_info;
   struct GraphicInfo *c = &part->control_info;
   boolean viewport_changed = SetGlobalAnimPart_Viewport(part);
   struct GraphicInfo *g = &part->graphic_info;
   struct GraphicInfo *c = &part->control_info;
   boolean viewport_changed = SetGlobalAnimPart_Viewport(part);


@@ -959,8 +1230,10 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     part->anim_delay_counter =
       (c->anim_delay_fixed + GetSimpleRandom(c->anim_delay_random));
 
     part->anim_delay_counter =
       (c->anim_delay_fixed + GetSimpleRandom(c->anim_delay_random));
 

-    part->init_event_state = c->init_event;
-    part->anim_event_state = c->anim_event;
+    part->post_delay_counter = 0;
+
+    part->init_event_state = (c->init_event != ANIM_EVENT_UNDEFINED);
+    part->anim_event_state = (c->anim_event != ANIM_EVENT_UNDEFINED);

 
     part->initial_anim_sync_frame =
       (g->anim_global_sync ? 0 : anim_sync_frame + part->init_delay_counter);
 
     part->initial_anim_sync_frame =
       (g->anim_global_sync ? 0 : anim_sync_frame + part->init_delay_counter);


@@ -1028,10 +1301,21 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
       part->step_yoffset = 0;
     }
 
       part->step_yoffset = 0;
     }
 

-    if (c->x != ARG_UNDEFINED_VALUE)
-      part->x = c->x;
-    if (c->y != ARG_UNDEFINED_VALUE)
-      part->y = c->y;
+    if (part->control_info.class != get_hash_from_key("pointer"))
+    {
+      if (c->x != ARG_UNDEFINED_VALUE)
+       part->x = c->x;
+      if (c->y != ARG_UNDEFINED_VALUE)
+       part->y = c->y;
+    }
+
+    if (c->position == POS_LAST &&
+       anim->last_x > -g->width  && anim->last_x < part->viewport_width &&
+       anim->last_y > -g->height && anim->last_y < part->viewport_height)
+    {
+      part->x = anim->last_x;
+      part->y = anim->last_y;
+    }

 
     if (c->step_xoffset != ARG_UNDEFINED_VALUE)
       part->step_xoffset = c->step_xoffset;
 
     if (c->step_xoffset != ARG_UNDEFINED_VALUE)
       part->step_xoffset = c->step_xoffset;


@@ -1039,29 +1323,36 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
       part->step_yoffset = c->step_yoffset;
 
     if (part->init_delay_counter == 0 &&
       part->step_yoffset = c->step_yoffset;
 
     if (part->init_delay_counter == 0 &&

-       part->init_event_state == ANIM_EVENT_NONE)
+       !part->init_event_state)
+    {

       PlayGlobalAnimSoundAndMusic(part);
       PlayGlobalAnimSoundAndMusic(part);

-  }

 
 

-  part->clickable = isClickablePart(part);
+      HandleGlobalAnimDelay(part, ANIM_DELAY_INIT,  "START [INIT_DELAY]");
+      HandleGlobalAnimEvent(part, ANIM_EVENT_START, "START [ANIM]");
+    }
+    else
+    {
+      HandleGlobalAnimEvent(part, ANIM_EVENT_INIT, "START [INIT_DELAY/EVENT]");
+    }
+  }

 
   if (part->clicked &&
 
   if (part->clicked &&

-      part->init_event_state != ANIM_EVENT_NONE)
+      part->init_event_state)

   {
     if (part->initial_anim_sync_frame > 0)
       part->initial_anim_sync_frame -= part->init_delay_counter - 1;
 
     part->init_delay_counter = 1;
   {
     if (part->initial_anim_sync_frame > 0)
       part->initial_anim_sync_frame -= part->init_delay_counter - 1;
 
     part->init_delay_counter = 1;

-    part->init_event_state = ANIM_EVENT_NONE;
+    part->init_event_state = FALSE;

 
     part->clicked = FALSE;
   }
 
   if (part->clicked &&
 
     part->clicked = FALSE;
   }
 
   if (part->clicked &&

-      part->anim_event_state != ANIM_EVENT_NONE)
+      part->anim_event_state)

   {
     part->anim_delay_counter = 1;
   {
     part->anim_delay_counter = 1;

-    part->anim_event_state = ANIM_EVENT_NONE;
+    part->anim_event_state = FALSE;

 
     part->clicked = FALSE;
   }
 
     part->clicked = FALSE;
   }


@@ -1072,17 +1363,23 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
 
     if (part->init_delay_counter == 0)
     {
 
     if (part->init_delay_counter == 0)
     {

-      part->init_event_state = ANIM_EVENT_NONE;
+      part->init_event_state = FALSE;

 
       PlayGlobalAnimSoundAndMusic(part);
 
       PlayGlobalAnimSoundAndMusic(part);

+
+      HandleGlobalAnimDelay(part, ANIM_DELAY_INIT,  "START [INIT_DELAY]");
+      HandleGlobalAnimEvent(part, ANIM_EVENT_START, "START [ANIM]");

     }
 
     return ANIM_STATE_WAITING;
   }
 
     }
 
     return ANIM_STATE_WAITING;
   }
 

-  if (part->init_event_state != ANIM_EVENT_NONE)
+  if (part->init_event_state)

     return ANIM_STATE_WAITING;
 
     return ANIM_STATE_WAITING;
 

+  // animation part is now running/visible and therefore clickable
+  part->clickable = TRUE;
+

   // check if moving animation has left the visible screen area
   if ((part->x <= -g->width              && part->step_xoffset <= 0) ||
       (part->x >=  part->viewport_width  && part->step_xoffset >= 0) ||
   // check if moving animation has left the visible screen area
   if ((part->x <= -g->width              && part->step_xoffset <= 0) ||
       (part->x >=  part->viewport_width  && part->step_xoffset >= 0) ||


@@ -1090,7 +1387,7 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
       (part->y >=  part->viewport_height && part->step_yoffset >= 0))
   {
     // do not wait for "anim" events for off-screen animations
       (part->y >=  part->viewport_height && part->step_yoffset >= 0))
   {
     // do not wait for "anim" events for off-screen animations

-    part->anim_event_state = ANIM_EVENT_NONE;
+    part->anim_event_state = FALSE;

 
     // do not stop animation before "anim" or "post" counter are finished
     if (part->anim_delay_counter == 0 &&
 
     // do not stop animation before "anim" or "post" counter are finished
     if (part->anim_delay_counter == 0 &&


@@ -1098,6 +1395,8 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     {
       StopGlobalAnimSoundAndMusic(part);
 
     {
       StopGlobalAnimSoundAndMusic(part);
 

+      HandleGlobalAnimEvent(part, ANIM_EVENT_END, "END [ANIM/OFF-SCREEN]");
+

       part->post_delay_counter =
        (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
 
       part->post_delay_counter =
        (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
 


@@ -1115,10 +1414,13 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
 
     if (part->anim_delay_counter == 0)
     {
 
     if (part->anim_delay_counter == 0)
     {

-      part->anim_event_state = ANIM_EVENT_NONE;
+      part->anim_event_state = FALSE;

 
       StopGlobalAnimSoundAndMusic(part);
 
 
       StopGlobalAnimSoundAndMusic(part);
 

+      HandleGlobalAnimDelay(part, ANIM_DELAY_ANIM, "END [ANIM_DELAY]");
+      HandleGlobalAnimEvent(part, ANIM_EVENT_END,  "END [ANIM_DELAY/EVENT]");
+

       part->post_delay_counter =
        (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
 
       part->post_delay_counter =
        (c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
 


@@ -1135,11 +1437,19 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     part->post_delay_counter--;
 
     if (part->post_delay_counter == 0)
     part->post_delay_counter--;
 
     if (part->post_delay_counter == 0)

+    {
+      HandleGlobalAnimDelay(part, ANIM_DELAY_POST, "END [POST_DELAY]");
+      HandleGlobalAnimEvent(part, ANIM_EVENT_POST, "END [POST_DELAY]");
+

       return ANIM_STATE_RESTART;
       return ANIM_STATE_RESTART;

+    }

 
     return ANIM_STATE_WAITING;
   }
 
 
     return ANIM_STATE_WAITING;
   }
 

+  // special case to prevent expiring loop sounds when playing
+  PlayGlobalAnimSoundIfLoop(part);
+

   if (!DelayReachedExt(&part->step_delay, part->step_delay_value,
                       anim_sync_frame))
     return ANIM_STATE_RUNNING;
   if (!DelayReachedExt(&part->step_delay, part->step_delay_value,
                       anim_sync_frame))
     return ANIM_STATE_RUNNING;


@@ -1159,14 +1469,20 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
   part->x += part->step_xoffset;
   part->y += part->step_yoffset;
 
   part->x += part->step_xoffset;
   part->y += part->step_yoffset;
 

+  anim->last_x = part->x;
+  anim->last_y = part->y;
+

   return ANIM_STATE_RUNNING;
 }
 
   return ANIM_STATE_RUNNING;
 }
 

-void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
+static void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim,
+                                 int action)

 {
   struct GlobalAnimPartControlInfo *part;
   struct GraphicInfo *c = &anim->control_info;
 {
   struct GlobalAnimPartControlInfo *part;
   struct GraphicInfo *c = &anim->control_info;

+  int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);

   int state, active_part_nr;
   int state, active_part_nr;

+  int i;

 
 #if 0
   printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
 
 #if 0
   printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",


@@ -1207,13 +1523,8 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
     case ANIM_STOP:
       anim->state = ANIM_STATE_INACTIVE;
 
     case ANIM_STOP:
       anim->state = ANIM_STATE_INACTIVE;
 

-      {
-       int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);
-       int i;
-
-       for (i = 0; i < num_parts; i++)
-         StopGlobalAnimSoundAndMusic(&anim->part[i]);
-      }
+      for (i = 0; i < num_parts; i++)
+       StopGlobalAnimSoundAndMusic(&anim->part[i]);

 
       return;
 
 
       return;
 


@@ -1223,9 +1534,6 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
 
   if (c->anim_mode & ANIM_ALL || anim->num_parts == 0)
   {
 
   if (c->anim_mode & ANIM_ALL || anim->num_parts == 0)
   {

-    int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);
-    int i;
-

 #if 0
     printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
           anim->mode_nr, anim->nr, num_parts);
 #if 0
     printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
           anim->mode_nr, anim->nr, num_parts);


@@ -1277,6 +1585,11 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
 
   part = &anim->part[anim->active_part_nr];
 
 
   part = &anim->part[anim->active_part_nr];
 

+  // first set all animation parts to "inactive", ...
+  for (i = 0; i < num_parts; i++)
+    anim->part[i].state = ANIM_STATE_INACTIVE;
+
+  // ... then set current animation parts to "running"

   part->state = ANIM_STATE_RUNNING;
 
   anim->state = HandleGlobalAnim_Part(part, anim->state);
   part->state = ANIM_STATE_RUNNING;
 
   anim->state = HandleGlobalAnim_Part(part, anim->state);


@@ -1315,7 +1628,7 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
   anim->last_active_part_nr = active_part_nr;
 }
 
   anim->last_active_part_nr = active_part_nr;
 }
 

-void HandleGlobalAnim_Mode(struct GlobalAnimControlInfo *ctrl, int action)
+static void HandleGlobalAnim_Mode(struct GlobalAnimControlInfo *ctrl, int action)

 {
   int i;
 
 {
   int i;
 


@@ -1337,7 +1650,7 @@ static void HandleGlobalAnim(int action, int game_mode)
   HandleGlobalAnim_Mode(&global_anim_ctrl[game_mode], action);
 }
 
   HandleGlobalAnim_Mode(&global_anim_ctrl[game_mode], action);
 }
 

-static void DoAnimationExt()
+static void DoAnimationExt(void)

 {
   int i;
 
 {
   int i;
 


@@ -1357,7 +1670,40 @@ static void DoAnimationExt()
 #endif
 }
 
 #endif
 }
 

-static void InitGlobalAnim_Clickable()
+static void DoGlobalAnim_DelayAction(struct GlobalAnimPartControlInfo *part,
+                                    int delay_type)
+{
+  int delay_action =
+    (delay_type == ANIM_DELAY_INIT ? part->control_info.init_delay_action :
+     delay_type == ANIM_DELAY_ANIM ? part->control_info.anim_delay_action :
+     delay_type == ANIM_DELAY_POST ? part->control_info.post_delay_action :
+     ANIM_DELAY_ACTION_NONE);
+
+  if (delay_action == ANIM_DELAY_ACTION_NONE)
+    return;
+
+  PushUserEvent(USEREVENT_ANIM_DELAY_ACTION, delay_action, 0);
+}
+
+static boolean DoGlobalAnim_EventAction(struct GlobalAnimPartControlInfo *part)
+{
+  int event_action = (part->init_event_state ?
+                     part->control_info.init_event_action :
+                     part->control_info.anim_event_action);
+
+  if (event_action == ANIM_EVENT_ACTION_NONE)
+    return FALSE;
+
+  PushUserEvent(USEREVENT_ANIM_EVENT_ACTION, event_action, 0);
+
+  // check if further actions are allowed to be executed
+  if (part->control_info.style & STYLE_MULTIPLE_ACTIONS)
+    return FALSE;
+
+  return TRUE;
+}
+
+static void InitGlobalAnim_Clickable(void)

 {
   int mode_nr;
 
 {
   int mode_nr;
 


@@ -1366,62 +1712,153 @@ static void InitGlobalAnim_Clickable()
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
     int anim_nr;
 
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
     int anim_nr;
 

-    for (anim_nr = 0; anim_nr < NUM_GLOBAL_ANIMS_AND_TOONS; anim_nr++)
+    for (anim_nr = 0; anim_nr < ctrl->num_anims; anim_nr++)

     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
       int part_nr;
 
     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
       int part_nr;
 

-      for (part_nr = 0; part_nr < NUM_GLOBAL_ANIM_PARTS_AND_TOONS; part_nr++)
+      for (part_nr = 0; part_nr < anim->num_parts_all; part_nr++)

       {
        struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
 
       {
        struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
 

+       if (part->triggered)
+         part->clicked = TRUE;
+
+       part->triggered = FALSE;

        part->clickable = FALSE;
       }
     }
   }
 }
 
        part->clickable = FALSE;
       }
     }
   }
 }
 

-static boolean InitGlobalAnim_Clicked(int mx, int my, boolean clicked)
+#define ANIM_CLICKED_RESET     0
+#define ANIM_CLICKED_PRESSED   1
+#define ANIM_CLICKED_RELEASED  2
+
+static boolean InitGlobalAnim_Clicked(int mx, int my, int clicked_event)

 {
 {

+  boolean anything_clicked = FALSE;

   boolean any_part_clicked = FALSE;
   boolean any_part_clicked = FALSE;

+  boolean any_event_action = FALSE;

   int mode_nr;
 
   int mode_nr;
 

-  for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
+  // check game modes in reverse draw order (to stop when clicked)
+  for (mode_nr = NUM_GAME_MODES - 1; mode_nr >= 0; mode_nr--)

   {
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
     int anim_nr;
 
   {
     struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
     int anim_nr;
 

-    for (anim_nr = 0; anim_nr < NUM_GLOBAL_ANIMS_AND_TOONS; anim_nr++)
+    // check animations in reverse draw order (to stop when clicked)
+    for (anim_nr = ctrl->num_anims - 1; anim_nr >= 0; anim_nr--)

     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
       int part_nr;
 
     {
       struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
       int part_nr;
 

-      for (part_nr = 0; part_nr < NUM_GLOBAL_ANIM_PARTS_AND_TOONS; part_nr++)
+      // check animation parts in reverse draw order (to stop when clicked)
+      for (part_nr = anim->num_parts_all - 1; part_nr >= 0; part_nr--)

       {
        struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
 
       {
        struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
 

-       part->clicked = FALSE;
+       if (clicked_event == ANIM_CLICKED_RESET)
+       {
+         part->clicked = FALSE;
+
+         continue;
+       }
+
+       if (!part->clickable)
+         continue;
+
+       if (part->state != ANIM_STATE_RUNNING)
+         continue;
+
+       // always handle "any" click events (clicking anywhere on screen) ...
+       if (clicked_event == ANIM_CLICKED_PRESSED &&
+           isClickablePart(part, ANIM_EVENT_ANY))
+       {
+#if DEBUG_ANIM_EVENTS
+         printf("::: => %d.%d TRIGGERED BY ANY\n",
+                part->old_anim_nr + 1, part->old_nr + 1);
+#endif
+
+         part->clicked = TRUE;
+         anything_clicked = clickConsumed(part);
+       }

 
 

-       if (part->clickable && isClickedPart(part, mx, my, clicked))
-         any_part_clicked = part->clicked = TRUE;
+       // always handle "unclick:any" events (releasing anywhere on screen) ...
+       if (clicked_event == ANIM_CLICKED_RELEASED &&
+           isClickablePart(part, ANIM_EVENT_UNCLICK_ANY))
+       {
+#if DEBUG_ANIM_EVENTS
+         printf("::: => %d.%d TRIGGERED BY UNCLICK:ANY\n",
+                part->old_anim_nr + 1, part->old_nr + 1);
+#endif
+
+         part->clicked = TRUE;
+         anything_clicked = clickConsumed(part);
+       }
+
+       // ... but only handle the first (topmost) clickable animation
+       if (any_part_clicked)
+         continue;
+
+       if (clicked_event == ANIM_CLICKED_PRESSED &&
+           isClickedPart(part, mx, my, TRUE))
+       {
+#if 0
+         printf("::: %d.%d CLICKED [%d]\n", anim_nr, part_nr,
+                part->control_info.anim_event_action);
+#endif
+
+         // after executing event action, ignore any further actions
+         if (!any_event_action && DoGlobalAnim_EventAction(part))
+           any_event_action = TRUE;
+
+         // determine if mouse clicks should be blocked from other animations
+         any_part_clicked = clickConsumed(part);
+
+         if (isClickablePart(part, ANIM_EVENT_SELF))
+         {
+#if DEBUG_ANIM_EVENTS
+           printf("::: => %d.%d TRIGGERED BY SELF\n",
+                  part->old_anim_nr + 1, part->old_nr + 1);
+#endif
+
+           part->clicked = TRUE;
+           anything_clicked = clickConsumed(part);
+         }
+
+         // check if this click is defined to trigger other animations
+         InitGlobalAnim_Triggered(part, &anything_clicked, &any_event_action,
+                                  ANIM_EVENT_CLICK, "CLICK");
+       }

       }
     }
   }
 
       }
     }
   }
 

-  return any_part_clicked;
+  if (anything_clicked)
+  {
+    handle_click = TRUE;
+
+    HandleGlobalAnim(ANIM_CONTINUE, game_status);
+
+    handle_click = FALSE;
+  }
+
+  return (anything_clicked || any_event_action);

 }
 
 }
 

-static void ResetGlobalAnim_Clickable()
+static void ResetGlobalAnim_Clickable(void)

 {
   InitGlobalAnim_Clickable();
 }
 
 {
   InitGlobalAnim_Clickable();
 }
 

-static void ResetGlobalAnim_Clicked()
+static void ResetGlobalAnim_Clicked(void)

 {
 {

-  InitGlobalAnim_Clicked(-1, -1, FALSE);
+  InitGlobalAnim_Clicked(-1, -1, ANIM_CLICKED_RESET);

 }
 
 }
 

-boolean HandleGlobalAnimClicks(int mx, int my, int button)
+boolean HandleGlobalAnimClicks(int mx, int my, int button, boolean force_click)

 {
   static boolean click_consumed = FALSE;
   static int last_button = 0;
 {
   static boolean click_consumed = FALSE;
   static int last_button = 0;


@@ -1429,19 +1866,25 @@ boolean HandleGlobalAnimClicks(int mx, int my, int button)
   boolean release_event;
   boolean click_consumed_current = click_consumed;
 
   boolean release_event;
   boolean click_consumed_current = click_consumed;
 

-  /* check if button state has changed since last invocation */
+  if (button != 0 && force_click)
+    last_button = 0;
+
+  // check if button state has changed since last invocation

   press_event   = (button != 0 && last_button == 0);
   release_event = (button == 0 && last_button != 0);
   last_button = button;
 
   if (press_event)
   {
   press_event   = (button != 0 && last_button == 0);
   release_event = (button == 0 && last_button != 0);
   last_button = button;
 
   if (press_event)
   {

-    click_consumed = InitGlobalAnim_Clicked(mx, my, TRUE);
+    click_consumed = InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_PRESSED);

     click_consumed_current = click_consumed;
   }
 
   if (release_event)
     click_consumed_current = click_consumed;
   }
 
   if (release_event)

+  {
+    InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_RELEASED);

     click_consumed = FALSE;
     click_consumed = FALSE;

+  }

 
   return click_consumed_current;
 }
 
   return click_consumed_current;
 }