Skip to content

davepoon/buildwithclaude / plugins/all-skills/skills/slack-gif-creator

slack-gif-creator

Verified

Toolkit for creating animated GIFs optimized for Slack, with validators for size constraints and composable animation primitives. This skill applies when users request animated GIFs or emoji animations for Slack from descriptions like "make me a GIF for Slack of X doing Y".

FileKindSize
LICENSE.txtmarkdown11.1 KB
SKILL.mdskill md16.8 KB
core/color_palettes.pyexecutablescript8.5 KB
core/easing.pyexecutablescript6.1 KB
core/frame_composer.pyexecutablescript14.1 KB
core/gif_builder.pyexecutablescript9.3 KB
core/typography.pyexecutablescript10.5 KB
core/validators.pyexecutablescript8.0 KB
core/visual_effects.pyexecutablescript14.5 KB
requirements.txtmanifest66 B
templates/bounce.pyexecutablescript3.0 KB
templates/explode.pyexecutablescript11.0 KB
templates/fade.pyexecutablescript9.9 KB
templates/flip.pyexecutablescript9.2 KB
templates/kaleidoscope.pyexecutablescript6.2 KB
templates/morph.pyexecutablescript11.0 KB
templates/move.pyexecutablescript9.2 KB
templates/pulse.pyexecutablescript8.4 KB
templates/shake.pyexecutablescript3.6 KB
templates/slide.pyexecutablescript9.1 KB
templates/spin.pyexecutablescript8.9 KB
templates/wiggle.pyexecutablescript9.8 KB
templates/zoom.pyexecutablescript9.9 KB

templates/move.py

View on GitHub
#!/usr/bin/env python3
"""
Move Animation - Move objects along paths with various motion types.

Provides flexible movement primitives for objects along linear, arc, or custom paths.
"""

import sys
from pathlib import Path
import math

sys.path.append(str(Path(__file__).parent.parent))

from core.gif_builder import GIFBuilder
from core.frame_composer import create_blank_frame, draw_circle, draw_emoji_enhanced
from core.easing import interpolate, calculate_arc_motion


def create_move_animation(
    object_type: str = 'emoji',
    object_data: dict | None = None,
    start_pos: tuple[int, int] = (50, 240),
    end_pos: tuple[int, int] = (430, 240),
    num_frames: int = 30,
    motion_type: str = 'linear',  # 'linear', 'arc', 'bezier', 'circle', 'wave'
    easing: str = 'ease_out',
    motion_params: dict | None = None,
    frame_width: int = 480,
    frame_height: int = 480,
    bg_color: tuple[int, int, int] = (255, 255, 255)
) -> list:
    """
    Create frames showing object moving along a path.

    Args:
        object_type: 'circle', 'emoji', or 'custom'
        object_data: Data for the object
        start_pos: Starting (x, y) position
        end_pos: Ending (x, y) position
        num_frames: Number of frames
        motion_type: Type of motion path
        easing: Easing function name
        motion_params: Additional parameters for motion (e.g., {'arc_height': 100})
        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 == 'circle':
            object_data = {'radius': 30, 'color': (100, 150, 255)}
        elif object_type == 'emoji':
            object_data = {'emoji': 'πŸš€', 'size': 60}

    # Default motion params
    if motion_params is None:
        motion_params = {}

    for i in range(num_frames):
        frame = create_blank_frame(frame_width, frame_height, bg_color)

        t = i / (num_frames - 1) if num_frames > 1 else 0

        # Calculate position based on motion type
        if motion_type == 'linear':
            # Straight line with easing
            x = interpolate(start_pos[0], end_pos[0], t, easing)
            y = interpolate(start_pos[1], end_pos[1], t, easing)

        elif motion_type == 'arc':
            # Parabolic arc
            arc_height = motion_params.get('arc_height', 100)
            x, y = calculate_arc_motion(start_pos, end_pos, arc_height, t)

        elif motion_type == 'circle':
            # Circular motion around a center
            center = motion_params.get('center', (frame_width // 2, frame_height // 2))
            radius = motion_params.get('radius', 150)
            start_angle = motion_params.get('start_angle', 0)
            angle_range = motion_params.get('angle_range', 360)  # Full circle

            angle = start_angle + (angle_range * t)
            angle_rad = math.radians(angle)

            x = center[0] + radius * math.cos(angle_rad)
            y = center[1] + radius * math.sin(angle_rad)

        elif motion_type == 'wave':
            # Move in straight line but add wave motion
            wave_amplitude = motion_params.get('wave_amplitude', 50)
            wave_frequency = motion_params.get('wave_frequency', 2)

            # Base linear motion
            base_x = interpolate(start_pos[0], end_pos[0], t, easing)
            base_y = interpolate(start_pos[1], end_pos[1], t, easing)

            # Add wave offset perpendicular to motion direction
            dx = end_pos[0] - start_pos[0]
            dy = end_pos[1] - start_pos[1]
            length = math.sqrt(dx * dx + dy * dy)

            if length > 0:
                # Perpendicular direction
                perp_x = -dy / length
                perp_y = dx / length

                # Wave offset
                wave_offset = math.sin(t * wave_frequency * 2 * math.pi) * wave_amplitude

                x = base_x + perp_x * wave_offset
                y = base_y + perp_y * wave_offset
            else:
                x, y = base_x, base_y

        elif motion_type == 'bezier':
            # Quadratic bezier curve
            control_point = motion_params.get('control_point', (
                (start_pos[0] + end_pos[0]) // 2,
                (start_pos[1] + end_pos[1]) // 2 - 100
            ))

            # Quadratic Bezier formula: B(t) = (1-t)Β²P0 + 2(1-t)tP1 + tΒ²P2
            x = (1 - t) ** 2 * start_pos[0] + 2 * (1 - t) * t * control_point[0] + t ** 2 * end_pos[0]
            y = (1 - t) ** 2 * start_pos[1] + 2 * (1 - t) * t * control_point[1] + t ** 2 * end_pos[1]

        else:
            # Default to linear
            x = interpolate(start_pos[0], end_pos[0], t, easing)
            y = interpolate(start_pos[1], end_pos[1], t, easing)

        # Draw object at calculated position
        x, y = int(x), int(y)

        if object_type == 'circle':
            draw_circle(
                frame,
                center=(x, y),
                radius=object_data['radius'],
                fill_color=object_data['color']
            )
        elif object_type == 'emoji':
            draw_emoji_enhanced(
                frame,
                emoji=object_data['emoji'],
                position=(x - object_data['size'] // 2, y - object_data['size'] // 2),
                size=object_data['size'],
                shadow=object_data.get('shadow', True)
            )

        frames.append(frame)

    return frames


def create_path_from_points(points: list[tuple[int, int]],
                            num_frames: int = 60,
                            easing: str = 'ease_in_out') -> list[tuple[int, int]]:
    """
    Create a smooth path through multiple points.

    Args:
        points: List of (x, y) waypoints
        num_frames: Total number of frames
        easing: Easing between points

    Returns:
        List of (x, y) positions for each frame
    """
    if len(points) < 2:
        return points * num_frames

    path = []
    frames_per_segment = num_frames // (len(points) - 1)

    for i in range(len(points) - 1):
        start = points[i]
        end = points[i + 1]

        # Last segment gets remaining frames
        if i == len(points) - 2:
            segment_frames = num_frames - len(path)
        else:
            segment_frames = frames_per_segment

        for j in range(segment_frames):
            t = j / segment_frames if segment_frames > 0 else 0
            x = interpolate(start[0], end[0], t, easing)
            y = interpolate(start[1], end[1], t, easing)
            path.append((int(x), int(y)))

    return path


def apply_trail_effect(frames: list, trail_length: int = 5,
                      fade_alpha: float = 0.3) -> list:
    """
    Add motion trail effect to moving object.

    Args:
        frames: List of frames with moving object
        trail_length: Number of previous frames to blend
        fade_alpha: Opacity of trail frames

    Returns:
        List of frames with trail effect
    """
    from PIL import Image, ImageChops
    import numpy as np

    trailed_frames = []

    for i, frame in enumerate(frames):
        # Start with current frame
        result = frame.copy()

        # Blend previous frames
        for j in range(1, min(trail_length + 1, i + 1)):
            prev_frame = frames[i - j]

            # Calculate fade
            alpha = fade_alpha ** j

            # Blend
            result_array = np.array(result, dtype=np.float32)
            prev_array = np.array(prev_frame, dtype=np.float32)

            blended = result_array * (1 - alpha) + prev_array * alpha
            result = Image.fromarray(blended.astype(np.uint8))

        trailed_frames.append(result)

    return trailed_frames


# Example usage
if __name__ == '__main__':
    print("Creating movement examples...")

    # Example 1: Linear movement
    builder = GIFBuilder(width=480, height=480, fps=20)
    frames = create_move_animation(
        object_type='emoji',
        object_data={'emoji': 'πŸš€', 'size': 60},
        start_pos=(50, 240),
        end_pos=(430, 240),
        num_frames=30,
        motion_type='linear',
        easing='ease_out'
    )
    builder.add_frames(frames)
    builder.save('move_linear.gif', num_colors=128)

    # Example 2: Arc movement
    builder.clear()
    frames = create_move_animation(
        object_type='emoji',
        object_data={'emoji': '⚽', 'size': 60},
        start_pos=(50, 350),
        end_pos=(430, 350),
        num_frames=30,
        motion_type='arc',
        motion_params={'arc_height': 150},
        easing='linear'
    )
    builder.add_frames(frames)
    builder.save('move_arc.gif', num_colors=128)

    # Example 3: Circular movement
    builder.clear()
    frames = create_move_animation(
        object_type='emoji',
        object_data={'emoji': '🌍', 'size': 50},
        start_pos=(0, 0),  # Ignored for circle
        end_pos=(0, 0),    # Ignored for circle
        num_frames=40,
        motion_type='circle',
        motion_params={
            'center': (240, 240),
            'radius': 120,
            'start_angle': 0,
            'angle_range': 360
        },
        easing='linear'
    )
    builder.add_frames(frames)
    builder.save('move_circle.gif', num_colors=128)

    print("Created movement examples!")
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why β€” repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" β€” or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself β€” your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall