X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fanim.c;h=8256ce7f60f5ec62fda3ebf49adb086a5450cc3b;hp=b9ea8becc2a44d2b84ea4e32e8424a95e96a7e87;hb=98ae5fc5e9274fea99a2ed8873b78fc2110ce3ce;hpb=b9cb8d24d6b501098d657ec1715574b2718c02f6

diff --git a/src/anim.c b/src/anim.c
index b9ea8bec..8256ce7f 100644
--- a/src/anim.c
+++ b/src/anim.c
@@ -9,16 +9,25 @@
 // anim.c
 // ============================================================================
 
+#include "libgame/libgame.h"
+
 #include "anim.h"
 #include "main.h"
 #include "tools.h"
+#include "files.h"
+#include "events.h"
+#include "screens.h"
+
+
+#define DEBUG_ANIM_DELAY		0
+#define DEBUG_ANIM_EVENTS		0
 
 
-/* values for global toon animation definition */
+// values for global toon animation definition
 #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,	\
@@ -27,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_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_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_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)
 
-/* values for global animation control */
+// values for global animation control
 #define ANIM_NO_ACTION			0
 #define ANIM_START			1
 #define ANIM_CONTINUE			2
@@ -64,10 +83,15 @@
 
 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;
 
+  boolean is_base;	// animation part is base/main/default animation part
+
   int sound;
   int music;
   int graphic;
@@ -90,6 +114,13 @@ struct GlobalAnimPartControlInfo
   int anim_delay_counter;
   int post_delay_counter;
 
+  boolean init_event_state;
+  boolean anim_event_state;
+
+  boolean triggered;
+  boolean clickable;
+  boolean clicked;
+
   int drawing_stage;
 
   int state;
@@ -106,11 +137,14 @@ struct GlobalAnimMainControlInfo
 
   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;
 
-  boolean has_base;
+  boolean has_base;	// animation has base/main/default animation part
+
+  int last_x, last_y;
 
   int init_delay_counter;
 
@@ -149,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_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				}
 };
@@ -163,16 +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_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_NO_TITLE,		GAME_MODE_PSEUDO_NO_TITLE	},
 
   { -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 ResetGlobalAnim_Clickable(void);
+static void ResetGlobalAnim_Clicked(void);
 
 static struct GlobalAnimControlInfo global_anim_ctrl[NUM_GAME_MODES];
 
@@ -181,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 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 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)
@@ -198,34 +244,34 @@ int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
 
   sync_frame += start_frame * delay;
 
-  if (mode & ANIM_LOOP)			/* looping animation */
+  if (mode & ANIM_LOOP)			// looping animation
   {
     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;
   }
-  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);
   }
-  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);
   }
-  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);
@@ -237,16 +283,16 @@ int getAnimationFrame(int num_frames, int delay, int mode, int start_frame,
     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;
 }
 
 
-/* ========================================================================= */
-/* global animation functions                                                */
-/* ========================================================================= */
+// ============================================================================
+// global animation functions
+// ============================================================================
 
 static int getGlobalAnimationPart(struct GlobalAnimMainControlInfo *anim)
 {
@@ -297,7 +343,7 @@ static int compareGlobalAnimMainControlInfo(const void *obj1, const void *obj2)
   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];
@@ -318,11 +364,15 @@ static void InitToonControls()
   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->last_x = POS_OFFSCREEN;
+  anim->last_y = POS_OFFSCREEN;
+
   anim->init_delay_counter = 0;
 
   anim->state = ANIM_STATE_INACTIVE;
@@ -340,9 +390,13 @@ static void InitToonControls()
     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->graphic_info = graphic_info[graphic];
     part->control_info = graphic_info[control];
 
@@ -363,13 +417,15 @@ static void InitToonControls()
     part->last_anim_status = -1;
 
     anim->num_parts++;
+    anim->num_parts_all++;
+
     part_nr++;
   }
 
   ctrl->num_anims++;
 }
 
-void InitGlobalAnimControls()
+static void InitGlobalAnimControls(void)
 {
   int i, m, a, p;
   int mode_nr, anim_nr, part_nr;
@@ -404,11 +460,15 @@ void InitGlobalAnimControls()
       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->last_x = POS_OFFSCREEN;
+      anim->last_y = POS_OFFSCREEN;
+
       anim->init_delay_counter = 0;
 
       anim->state = ANIM_STATE_INACTIVE;
@@ -438,12 +498,17 @@ void InitGlobalAnimControls()
 	       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->sound = sound;
 	part->music = music;
 	part->graphic = graphic;
+
 	part->graphic_info = graphic_info[graphic];
 	part->control_info = graphic_info[control];
 
@@ -455,13 +520,19 @@ void InitGlobalAnimControls()
 	part->state = ANIM_STATE_INACTIVE;
 	part->last_anim_status = -1;
 
+	anim->num_parts_all++;
+
 	if (p < GLOBAL_ANIM_ID_PART_BASE)
 	{
+	  part->is_base = FALSE;
+
 	  anim->num_parts++;
 	  part_nr++;
 	}
 	else
 	{
+	  part->is_base = TRUE;
+
 	  anim->base = *part;
 	  anim->has_base = TRUE;
 	}
@@ -477,12 +548,12 @@ void InitGlobalAnimControls()
 
   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];
 
-    /* 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);
@@ -491,7 +562,7 @@ void InitGlobalAnimControls()
     {
       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);
@@ -510,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_status_last_before_fading = GAME_MODE_LOADING;
   anim_status_last = GAME_MODE_LOADING;
   anim_classes_last = ANIM_CLASS_NONE;
 }
 
-void InitGlobalAnimations()
+void InitGlobalAnimations(void)
 {
   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 :
@@ -548,15 +620,23 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
     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")
 
-    // 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)
@@ -585,7 +665,10 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
     if (drawing_target == DRAW_TO_SCREEN)
     {
       if (after_fading)
+      {
 	anim_classes_last = anim_classes_next;
+	anim_status_last_before_fading = global.anim_status;
+      }
 
       anim_status_last = global.anim_status;
 
@@ -663,6 +746,10 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
 	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;
@@ -706,11 +793,11 @@ void DrawGlobalAnimationsExt(int drawing_target, int drawing_stage)
 	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
-	  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);
       }
     }
   }
@@ -728,10 +815,27 @@ void DrawGlobalAnimationsExt(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)
+  {
+    ResetGlobalAnim_Clickable();
+
+    gfx.cursor_mode_override = CURSOR_UNDEFINED;
+  }
+
   DrawGlobalAnimationsExt(drawing_target, drawing_stage);
+
+  if (drawing_stage == DRAW_GLOBAL_ANIM_STAGE_2)
+  {
+    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;
@@ -739,7 +843,8 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
   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;
@@ -756,6 +861,20 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
 
     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;
@@ -765,10 +884,20 @@ boolean SetGlobalAnimPart_Viewport(struct GlobalAnimPartControlInfo *part)
   }
   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"
   {
@@ -842,7 +971,10 @@ static void PlayGlobalAnimMusic(struct GlobalAnimPartControlInfo *part)
   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",
@@ -881,8 +1013,201 @@ static void StopGlobalAnimSoundAndMusic(struct GlobalAnimPartControlInfo *part)
   StopGlobalAnimMusic(part);
 }
 
-int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
+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;
+  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);
+
+    if (checkGlobalAnimEvent(anim_event, mask))
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+static boolean isClickedPart(struct GlobalAnimPartControlInfo *part,
+			     int mx, int my, boolean clicked)
+{
+  struct GraphicInfo *g = &part->graphic_info;
+  int part_x = part->viewport_x + part->x;
+  int part_y = part->viewport_y + part->y;
+  int part_width  = g->width;
+  int part_height = g->height;
+
+  // check if mouse click was detected at all
+  if (!clicked)
+    return FALSE;
+
+  // check if mouse click is inside the animation part's viewport
+  if (mx <  part->viewport_x ||
+      mx >= part->viewport_x + part->viewport_width ||
+      my <  part->viewport_y ||
+      my >= part->viewport_y + part->viewport_height)
+    return FALSE;
+
+  // check if mouse click is inside the animation part's graphic
+  if (mx <  part_x ||
+      mx >= part_x + part_width ||
+      my <  part_y ||
+      my >= part_y + part_height)
+    return FALSE;
+
+  return TRUE;
+}
+
+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);
@@ -905,6 +1230,11 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     part->anim_delay_counter =
       (c->anim_delay_fixed + GetSimpleRandom(c->anim_delay_random));
 
+    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);
 
@@ -971,18 +1301,60 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
       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_yoffset != ARG_UNDEFINED_VALUE)
       part->step_yoffset = c->step_yoffset;
 
-    if (part->init_delay_counter == 0)
+    if (part->init_delay_counter == 0 &&
+	!part->init_event_state)
+    {
       PlayGlobalAnimSoundAndMusic(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 &&
+      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;
+    part->init_event_state = FALSE;
+
+    part->clicked = FALSE;
+  }
+
+  if (part->clicked &&
+      part->anim_event_state)
+  {
+    part->anim_delay_counter = 1;
+    part->anim_event_state = FALSE;
+
+    part->clicked = FALSE;
   }
 
   if (part->init_delay_counter > 0)
@@ -990,23 +1362,41 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     part->init_delay_counter--;
 
     if (part->init_delay_counter == 0)
+    {
+      part->init_event_state = FALSE;
+
       PlayGlobalAnimSoundAndMusic(part);
 
+      HandleGlobalAnimDelay(part, ANIM_DELAY_INIT,  "START [INIT_DELAY]");
+      HandleGlobalAnimEvent(part, ANIM_EVENT_START, "START [ANIM]");
+    }
+
     return ANIM_STATE_WAITING;
   }
 
+  if (part->init_event_state)
+    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) ||
       (part->y <= -g->height             && part->step_yoffset <= 0) ||
       (part->y >=  part->viewport_height && part->step_yoffset >= 0))
   {
+    // do not wait for "anim" events for off-screen animations
+    part->anim_event_state = FALSE;
+
     // do not stop animation before "anim" or "post" counter are finished
     if (part->anim_delay_counter == 0 &&
 	part->post_delay_counter == 0)
     {
       StopGlobalAnimSoundAndMusic(part);
 
+      HandleGlobalAnimEvent(part, ANIM_EVENT_END, "END [ANIM/OFF-SCREEN]");
+
       part->post_delay_counter =
 	(c->post_delay_fixed + GetSimpleRandom(c->post_delay_random));
 
@@ -1024,8 +1414,13 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
 
     if (part->anim_delay_counter == 0)
     {
+      part->anim_event_state = FALSE;
+
       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));
 
@@ -1042,11 +1437,19 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
     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_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;
@@ -1066,14 +1469,20 @@ int HandleGlobalAnim_Part(struct GlobalAnimPartControlInfo *part, int state)
   part->x += part->step_xoffset;
   part->y += part->step_yoffset;
 
+  anim->last_x = part->x;
+  anim->last_y = part->y;
+
   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;
+  int num_parts = anim->num_parts + (anim->has_base ? 1 : 0);
   int state, active_part_nr;
+  int i;
 
 #if 0
   printf("::: HandleGlobalAnim_Main: %d, %d => %d\n",
@@ -1114,13 +1523,8 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
     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;
 
@@ -1130,9 +1534,6 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
 
   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);
@@ -1184,6 +1585,11 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
 
   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);
@@ -1222,7 +1628,7 @@ void HandleGlobalAnim_Main(struct GlobalAnimMainControlInfo *anim, int action)
   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;
 
@@ -1244,7 +1650,7 @@ static void HandleGlobalAnim(int action, int game_mode)
   HandleGlobalAnim_Mode(&global_anim_ctrl[game_mode], action);
 }
 
-static void DoAnimationExt()
+static void DoAnimationExt(void)
 {
   int i;
 
@@ -1263,3 +1669,222 @@ static void DoAnimationExt()
   redraw_mask = REDRAW_ALL;
 #endif
 }
+
+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;
+
+  for (mode_nr = 0; mode_nr < NUM_GAME_MODES; mode_nr++)
+  {
+    struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr];
+    int anim_nr;
+
+    for (anim_nr = 0; anim_nr < ctrl->num_anims; anim_nr++)
+    {
+      struct GlobalAnimMainControlInfo *anim = &ctrl->anim[anim_nr];
+      int part_nr;
+
+      for (part_nr = 0; part_nr < anim->num_parts_all; part_nr++)
+      {
+	struct GlobalAnimPartControlInfo *part = &anim->part[part_nr];
+
+	if (part->triggered)
+	  part->clicked = TRUE;
+
+	part->triggered = FALSE;
+	part->clickable = FALSE;
+      }
+    }
+  }
+}
+
+#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_event_action = FALSE;
+  int 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;
+
+    // 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;
+
+      // 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];
+
+	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);
+	}
+
+	// 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");
+	}
+      }
+    }
+  }
+
+  if (anything_clicked)
+  {
+    handle_click = TRUE;
+
+    HandleGlobalAnim(ANIM_CONTINUE, game_status);
+
+    handle_click = FALSE;
+  }
+
+  return (anything_clicked || any_event_action);
+}
+
+static void ResetGlobalAnim_Clickable(void)
+{
+  InitGlobalAnim_Clickable();
+}
+
+static void ResetGlobalAnim_Clicked(void)
+{
+  InitGlobalAnim_Clicked(-1, -1, ANIM_CLICKED_RESET);
+}
+
+boolean HandleGlobalAnimClicks(int mx, int my, int button, boolean force_click)
+{
+  static boolean click_consumed = FALSE;
+  static int last_button = 0;
+  boolean press_event;
+  boolean release_event;
+  boolean click_consumed_current = click_consumed;
+
+  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)
+  {
+    click_consumed = InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_PRESSED);
+    click_consumed_current = click_consumed;
+  }
+
+  if (release_event)
+  {
+    InitGlobalAnim_Clicked(mx, my, ANIM_CLICKED_RELEASED);
+    click_consumed = FALSE;
+  }
+
+  return click_consumed_current;
+}