@amrhas82/agentic-kit 1.0.0

package/skills/slack-gif-creator/templates/explode.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""
+Explode Animation - Break objects into pieces that fly outward.
+
+Creates explosion, shatter, and particle burst effects.
+"""
+
+import sys
+from pathlib import Path
+import math
+import random
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from PIL import Image, ImageDraw
+import numpy as np
+from core.gif_builder import GIFBuilder
+from core.frame_composer import create_blank_frame, draw_emoji_enhanced
+from core.visual_effects import ParticleSystem
+from core.easing import interpolate
+
+
+def create_explode_animation(
+    object_type: str = 'emoji',
+    object_data: dict | None = None,
+    num_frames: int = 30,
+    explode_type: str = 'burst',  # 'burst', 'shatter', 'dissolve', 'implode'
+    num_pieces: int = 20,
+    explosion_speed: float = 5.0,
+    center_pos: tuple[int, int] = (240, 240),
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Create explosion animation.
+
+    Args:
+        object_type: 'emoji', 'circle', 'text'
+        object_data: Object configuration
+        num_frames: Number of frames
+        explode_type: Type of explosion
+        num_pieces: Number of pieces/particles
+        explosion_speed: Speed of explosion
+        center_pos: Center position
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    # Default object data
+    if object_data is None:
+        if object_type == 'emoji':
+            object_data = {'emoji': '💣', 'size': 100}
+
+    # Generate pieces/particles
+    pieces = []
+    for _ in range(num_pieces):
+        angle = random.uniform(0, 2 * math.pi)
+        speed = random.uniform(explosion_speed * 0.5, explosion_speed * 1.5)
+        vx = math.cos(angle) * speed
+        vy = math.sin(angle) * speed
+        size = random.randint(3, 12)
+        color = (
+            random.randint(100, 255),
+            random.randint(100, 255),
+            random.randint(100, 255)
+        )
+        rotation_speed = random.uniform(-20, 20)
+
+        pieces.append({
+            'vx': vx,
+            'vy': vy,
+            'size': size,
+            'color': color,
+            'rotation': 0,
+            'rotation_speed': rotation_speed
+        })
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+        draw = ImageDraw.Draw(frame)
+
+        if explode_type == 'burst':
+            # Show object at start, then explode
+            if t < 0.2:
+                # Object still intact
+                scale = interpolate(1.0, 1.2, t / 0.2, 'ease_out')
+                if object_type == 'emoji':
+                    size = int(object_data['size'] * scale)
+                    draw_emoji_enhanced(
+                        frame,
+                        emoji=object_data['emoji'],
+                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
+                        size=size,
+                        shadow=False
+                    )
+            else:
+                # Exploded - draw pieces
+                explosion_t = (t - 0.2) / 0.8
+                for piece in pieces:
+                    # Update position
+                    x = center_pos[0] + piece['vx'] * explosion_t * 50
+                    y = center_pos[1] + piece['vy'] * explosion_t * 50 + 0.5 * 300 * explosion_t ** 2  # Gravity
+
+                    # Fade out
+                    alpha = 1.0 - explosion_t
+                    if alpha > 0:
+                        color = tuple(int(c * alpha) for c in piece['color'])
+                        size = int(piece['size'] * (1 - explosion_t * 0.5))
+
+                        draw.ellipse(
+                            [x - size, y - size, x + size, y + size],
+                            fill=color
+                        )
+
+        elif explode_type == 'shatter':
+            # Break into geometric pieces
+            if t < 0.15:
+                # Object intact
+                if object_type == 'emoji':
+                    draw_emoji_enhanced(
+                        frame,
+                        emoji=object_data['emoji'],
+                        position=(center_pos[0] - object_data['size'] // 2,
+                                center_pos[1] - object_data['size'] // 2),
+                        size=object_data['size'],
+                        shadow=False
+                    )
+            else:
+                # Shattered
+                shatter_t = (t - 0.15) / 0.85
+
+                # Draw triangular shards
+                for piece in pieces[:min(10, len(pieces))]:
+                    x = center_pos[0] + piece['vx'] * shatter_t * 30
+                    y = center_pos[1] + piece['vy'] * shatter_t * 30 + 0.5 * 200 * shatter_t ** 2
+
+                    # Update rotation
+                    rotation = piece['rotation_speed'] * shatter_t * 100
+
+                    # Draw triangle shard
+                    shard_size = piece['size'] * 2
+                    points = []
+                    for j in range(3):
+                        angle = (rotation + j * 120) * math.pi / 180
+                        px = x + shard_size * math.cos(angle)
+                        py = y + shard_size * math.sin(angle)
+                        points.append((px, py))
+
+                    alpha = 1.0 - shatter_t
+                    if alpha > 0:
+                        color = tuple(int(c * alpha) for c in piece['color'])
+                        draw.polygon(points, fill=color)
+
+        elif explode_type == 'dissolve':
+            # Dissolve into particles
+            dissolve_scale = interpolate(1.0, 0.0, t, 'ease_in')
+
+            if dissolve_scale > 0.1:
+                # Draw fading object
+                if object_type == 'emoji':
+                    size = int(object_data['size'] * dissolve_scale)
+                    size = max(12, size)
+
+                    emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+                    draw_emoji_enhanced(
+                        emoji_canvas,
+                        emoji=object_data['emoji'],
+                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
+                        size=size,
+                        shadow=False
+                    )
+
+                    # Apply opacity
+                    from templates.fade import apply_opacity
+                    emoji_canvas = apply_opacity(emoji_canvas, dissolve_scale)
+
+                    frame_rgba = frame.convert('RGBA')
+                    frame = Image.alpha_composite(frame_rgba, emoji_canvas)
+                    frame = frame.convert('RGB')
+                    draw = ImageDraw.Draw(frame)
+
+            # Draw outward-moving particles
+            for piece in pieces:
+                x = center_pos[0] + piece['vx'] * t * 40
+                y = center_pos[1] + piece['vy'] * t * 40
+
+                alpha = 1.0 - t
+                if alpha > 0:
+                    color = tuple(int(c * alpha) for c in piece['color'])
+                    size = int(piece['size'] * (1 - t * 0.5))
+                    draw.ellipse(
+                        [x - size, y - size, x + size, y + size],
+                        fill=color
+                    )
+
+        elif explode_type == 'implode':
+            # Reverse explosion - pieces fly inward
+            if t < 0.7:
+                # Pieces converging
+                implode_t = 1.0 - (t / 0.7)
+                for piece in pieces:
+                    x = center_pos[0] + piece['vx'] * implode_t * 50
+                    y = center_pos[1] + piece['vy'] * implode_t * 50
+
+                    alpha = 1.0 - (1.0 - implode_t) * 0.5
+                    color = tuple(int(c * alpha) for c in piece['color'])
+                    size = int(piece['size'] * alpha)
+
+                    draw.ellipse(
+                        [x - size, y - size, x + size, y + size],
+                        fill=color
+                    )
+            else:
+                # Object reforms
+                reform_t = (t - 0.7) / 0.3
+                scale = interpolate(0.5, 1.0, reform_t, 'elastic_out')
+
+                if object_type == 'emoji':
+                    size = int(object_data['size'] * scale)
+                    draw_emoji_enhanced(
+                        frame,
+                        emoji=object_data['emoji'],
+                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
+                        size=size,
+                        shadow=False
+                    )
+
+        frames.append(frame)
+
+    return frames
+
+
+def create_particle_burst(
+    num_frames: int = 25,
+    particle_count: int = 30,
+    center_pos: tuple[int, int] = (240, 240),
+    colors: list[tuple[int, int, int]] | None = None,
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Create simple particle burst effect.
+
+    Args:
+        num_frames: Number of frames
+        particle_count: Number of particles
+        center_pos: Burst center
+        colors: Particle colors (None for random)
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    particles = ParticleSystem()
+
+    # Emit particles
+    if colors is None:
+        from core.color_palettes import get_palette
+        palette = get_palette('vibrant')
+        colors = [palette['primary'], palette['secondary'], palette['accent']]
+
+    for _ in range(particle_count):
+        color = random.choice(colors)
+        particles.emit(
+            center_pos[0], center_pos[1],
+            count=1,
+            speed=random.uniform(3, 8),
+            color=color,
+            lifetime=random.uniform(20, 30),
+            size=random.randint(3, 8),
+            shape='star'
+        )
+
+    frames = []
+    for _ in range(num_frames):
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+
+        particles.update()
+        particles.render(frame)
+
+        frames.append(frame)
+
+    return frames
+
+
+# Example usage
+if __name__ == '__main__':
+    print("Creating explode animations...")
+
+    builder = GIFBuilder(width=480, height=480, fps=20)
+
+    # Example 1: Burst
+    frames = create_explode_animation(
+        object_type='emoji',
+        object_data={'emoji': '💣', 'size': 100},
+        num_frames=30,
+        explode_type='burst',
+        num_pieces=25
+    )
+    builder.add_frames(frames)
+    builder.save('explode_burst.gif', num_colors=128)
+
+    # Example 2: Shatter
+    builder.clear()
+    frames = create_explode_animation(
+        object_type='emoji',
+        object_data={'emoji': '🪟', 'size': 100},
+        num_frames=30,
+        explode_type='shatter',
+        num_pieces=12
+    )
+    builder.add_frames(frames)
+    builder.save('explode_shatter.gif', num_colors=128)
+
+    # Example 3: Particle burst
+    builder.clear()
+    frames = create_particle_burst(num_frames=25, particle_count=40)
+    builder.add_frames(frames)
+    builder.save('explode_particles.gif', num_colors=128)
+
+    print("Created explode animations!")

package/skills/slack-gif-creator/templates/fade.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""
+Fade Animation - Fade in, fade out, and crossfade effects.
+
+Creates smooth opacity transitions for appearing, disappearing, and transitioning.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from PIL import Image, ImageDraw
+import numpy as np
+from core.gif_builder import GIFBuilder
+from core.frame_composer import create_blank_frame, draw_emoji_enhanced
+from core.easing import interpolate
+
+
+def create_fade_animation(
+    object_type: str = 'emoji',
+    object_data: dict | None = None,
+    num_frames: int = 30,
+    fade_type: str = 'in',  # 'in', 'out', 'in_out', 'blink'
+    easing: str = 'ease_in_out',
+    center_pos: tuple[int, int] = (240, 240),
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Create fade animation.
+
+    Args:
+        object_type: 'emoji', 'text', 'image'
+        object_data: Object configuration
+        num_frames: Number of frames
+        fade_type: Type of fade effect
+        easing: Easing function
+        center_pos: Center position
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    # Default object data
+    if object_data is None:
+        if object_type == 'emoji':
+            object_data = {'emoji': '✨', 'size': 100}
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Calculate opacity based on fade type
+        if fade_type == 'in':
+            opacity = interpolate(0, 1, t, easing)
+        elif fade_type == 'out':
+            opacity = interpolate(1, 0, t, easing)
+        elif fade_type == 'in_out':
+            if t < 0.5:
+                opacity = interpolate(0, 1, t * 2, easing)
+            else:
+                opacity = interpolate(1, 0, (t - 0.5) * 2, easing)
+        elif fade_type == 'blink':
+            # Quick fade out and back in
+            if t < 0.2:
+                opacity = interpolate(1, 0, t / 0.2, 'ease_in')
+            elif t < 0.4:
+                opacity = interpolate(0, 1, (t - 0.2) / 0.2, 'ease_out')
+            else:
+                opacity = 1.0
+        else:
+            opacity = interpolate(0, 1, t, easing)
+
+        # Create background
+        frame_bg = create_blank_frame(frame_width, frame_height, bg_color)
+
+        # Create object layer with transparency
+        if object_type == 'emoji':
+            # Create RGBA canvas for emoji
+            emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+            emoji_size = object_data['size']
+            draw_emoji_enhanced(
+                emoji_canvas,
+                emoji=object_data['emoji'],
+                position=(center_pos[0] - emoji_size // 2, center_pos[1] - emoji_size // 2),
+                size=emoji_size,
+                shadow=object_data.get('shadow', False)
+            )
+
+            # Apply opacity
+            emoji_canvas = apply_opacity(emoji_canvas, opacity)
+
+            # Composite onto background
+            frame_bg_rgba = frame_bg.convert('RGBA')
+            frame = Image.alpha_composite(frame_bg_rgba, emoji_canvas)
+            frame = frame.convert('RGB')
+
+        elif object_type == 'text':
+            from core.typography import draw_text_with_outline
+
+            # Create text on separate layer
+            text_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+            text_canvas_rgb = text_canvas.convert('RGB')
+            text_canvas_rgb.paste(bg_color, (0, 0, frame_width, frame_height))
+
+            draw_text_with_outline(
+                text_canvas_rgb,
+                text=object_data.get('text', 'FADE'),
+                position=center_pos,
+                font_size=object_data.get('font_size', 60),
+                text_color=object_data.get('text_color', (0, 0, 0)),
+                outline_color=object_data.get('outline_color', (255, 255, 255)),
+                outline_width=3,
+                centered=True
+            )
+
+            # Convert to RGBA and make background transparent
+            text_canvas = text_canvas_rgb.convert('RGBA')
+            data = text_canvas.getdata()
+            new_data = []
+            for item in data:
+                if item[:3] == bg_color:
+                    new_data.append((255, 255, 255, 0))
+                else:
+                    new_data.append(item)
+            text_canvas.putdata(new_data)
+
+            # Apply opacity
+            text_canvas = apply_opacity(text_canvas, opacity)
+
+            # Composite
+            frame_bg_rgba = frame_bg.convert('RGBA')
+            frame = Image.alpha_composite(frame_bg_rgba, text_canvas)
+            frame = frame.convert('RGB')
+
+        else:
+            frame = frame_bg
+
+        frames.append(frame)
+
+    return frames
+
+
+def apply_opacity(image: Image.Image, opacity: float) -> Image.Image:
+    """
+    Apply opacity to an RGBA image.
+
+    Args:
+        image: RGBA image
+        opacity: Opacity value (0.0 to 1.0)
+
+    Returns:
+        Image with adjusted opacity
+    """
+    if image.mode != 'RGBA':
+        image = image.convert('RGBA')
+
+    # Get alpha channel
+    r, g, b, a = image.split()
+
+    # Multiply alpha by opacity
+    a_array = np.array(a, dtype=np.float32)
+    a_array = a_array * opacity
+    a = Image.fromarray(a_array.astype(np.uint8))
+
+    # Merge back
+    return Image.merge('RGBA', (r, g, b, a))
+
+
+def create_crossfade(
+    object1_data: dict,
+    object2_data: dict,
+    num_frames: int = 30,
+    easing: str = 'ease_in_out',
+    object_type: str = 'emoji',
+    center_pos: tuple[int, int] = (240, 240),
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Crossfade between two objects.
+
+    Args:
+        object1_data: First object configuration
+        object2_data: Second object configuration
+        num_frames: Number of frames
+        easing: Easing function
+        object_type: Type of objects
+        center_pos: Center position
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Calculate opacities
+        opacity1 = interpolate(1, 0, t, easing)
+        opacity2 = interpolate(0, 1, t, easing)
+
+        # Create background
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+
+        if object_type == 'emoji':
+            # Create first emoji
+            emoji1_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+            size1 = object1_data['size']
+            draw_emoji_enhanced(
+                emoji1_canvas,
+                emoji=object1_data['emoji'],
+                position=(center_pos[0] - size1 // 2, center_pos[1] - size1 // 2),
+                size=size1,
+                shadow=False
+            )
+            emoji1_canvas = apply_opacity(emoji1_canvas, opacity1)
+
+            # Create second emoji
+            emoji2_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+            size2 = object2_data['size']
+            draw_emoji_enhanced(
+                emoji2_canvas,
+                emoji=object2_data['emoji'],
+                position=(center_pos[0] - size2 // 2, center_pos[1] - size2 // 2),
+                size=size2,
+                shadow=False
+            )
+            emoji2_canvas = apply_opacity(emoji2_canvas, opacity2)
+
+            # Composite both
+            frame_rgba = frame.convert('RGBA')
+            frame_rgba = Image.alpha_composite(frame_rgba, emoji1_canvas)
+            frame_rgba = Image.alpha_composite(frame_rgba, emoji2_canvas)
+            frame = frame_rgba.convert('RGB')
+
+        frames.append(frame)
+
+    return frames
+
+
+def create_fade_to_color(
+    start_color: tuple[int, int, int],
+    end_color: tuple[int, int, int],
+    num_frames: int = 20,
+    easing: str = 'linear',
+    frame_width: int = 480,
+    frame_height: int = 480
+) -> list[Image.Image]:
+    """
+    Fade from one solid color to another.
+
+    Args:
+        start_color: Starting RGB color
+        end_color: Ending RGB color
+        num_frames: Number of frames
+        easing: Easing function
+        frame_width: Frame width
+        frame_height: Frame height
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Interpolate each color channel
+        r = int(interpolate(start_color[0], end_color[0], t, easing))
+        g = int(interpolate(start_color[1], end_color[1], t, easing))
+        b = int(interpolate(start_color[2], end_color[2], t, easing))
+
+        color = (r, g, b)
+        frame = create_blank_frame(frame_width, frame_height, color)
+        frames.append(frame)
+
+    return frames
+
+
+# Example usage
+if __name__ == '__main__':
+    print("Creating fade animations...")
+
+    builder = GIFBuilder(width=480, height=480, fps=20)
+
+    # Example 1: Fade in
+    frames = create_fade_animation(
+        object_type='emoji',
+        object_data={'emoji': '✨', 'size': 120},
+        num_frames=30,
+        fade_type='in',
+        easing='ease_out'
+    )
+    builder.add_frames(frames)
+    builder.save('fade_in.gif', num_colors=128)
+
+    # Example 2: Crossfade
+    builder.clear()
+    frames = create_crossfade(
+        object1_data={'emoji': '😊', 'size': 100},
+        object2_data={'emoji': '😂', 'size': 100},
+        num_frames=30,
+        object_type='emoji'
+    )
+    builder.add_frames(frames)
+    builder.save('fade_crossfade.gif', num_colors=128)
+
+    # Example 3: Blink
+    builder.clear()
+    frames = create_fade_animation(
+        object_type='emoji',
+        object_data={'emoji': '👀', 'size': 100},
+        num_frames=20,
+        fade_type='blink'
+    )
+    builder.add_frames(frames)
+    builder.save('fade_blink.gif', num_colors=128)
+
+    print("Created fade animations!")