Advanced 2D AnimationTraditional Principles Meet Digital Pipeline

// ── After Effects Expression: Smooth Loop ─────────────
// Apply this expression to any animated property
// to create a perfectly seamless loop.

// Ping-Pong Loop (goes forward then backward)
loopOut("pingpong");

// Cycle Loop (repeats from start)
loopOut("cycle");

// ── Bounce Expression (Physics-based) ─────────────────
// Apply to Position Y for a realistic bouncing ball
// Uses real physics: gravity + energy loss per bounce
var gravity = 2000;        // pixels per second²
var bounceHeight = 400;    // initial drop height
var dampening = 0.7;       // energy retained (0-1)
var bounceFreq = 2.5;      // bounces per second

var t = time - inPoint;
var amplitude = bounceHeight;
var decay = Math.pow(dampening, t * bounceFreq);

// Simulate bounce with sine wave + decay
value + [0, -amplitude * Math.abs(Math.sin(bounceFreq * t * Math.PI)) * decay];

// ── Walk Cycle Timing Template ────────────────────────
// Standard walk at 24fps, animated on 2s:
//
// Frame 01: Contact Pose (Right foot forward)
// Frame 03: Down Pose (Weight drops)
// Frame 07: Passing Pose (Left leg swings through)
// Frame 09: Up Pose (Push off, highest point)
// Frame 13: Contact Pose (Left foot forward)  ← MIRROR
// Frame 15: Down Pose
// Frame 19: Passing Pose
// Frame 21: Up Pose
// Frame 25: = Frame 01 (cycle complete)
//
// Total: 24 frames = 1 second per full cycle

# ── Toon Boom Harmony — Puppet Rig Setup Guide ───────
# While Harmony uses a visual rigging interface,
# you can automate rig setup with its scripting API.

# Harmony Script: Auto-Peg Setup for Character Rig
# This creates the standard hierarchy for a puppet rig.

def create_character_rig(character_name):
    """
    Creates a professional puppet rig hierarchy.
    
    Standard Hierarchy:
    └── Master_Peg (move entire character)
        ├── Body_Peg
        │   ├── Torso
        │   │   ├── Head_Peg
        │   │   │   ├── Head
        │   │   │   ├── Eyes_Peg
        │   │   │   │   ├── Eye_L
        │   │   │   │   └── Eye_R
        │   │   │   ├── Mouth_Peg
        │   │   │   │   └── Mouth (swap library)
        │   │   │   └── Hair_Peg
        │   │   │       └── Hair (with deformers)
        │   │   ├── Arm_L_Peg
        │   │   │   ├── Upper_Arm_L
        │   │   │   ├── Forearm_L
        │   │   │   └── Hand_L (swap library)
        │   │   └── Arm_R_Peg
        │   │       └── (mirror of Arm_L)
        │   ├── Hips_Peg
        │   │   ├── Leg_L_Peg
        │   │   │   ├── Thigh_L
        │   │   │   ├── Shin_L
        │   │   │   └── Foot_L
        │   │   └── Leg_R_Peg
        │   │       └── (mirror of Leg_L)
        │   └── Shadow
        └── Effects_Peg
            ├── Motion_Blur
            └── Particles
    """
    
    # Create pegs for each body part
    pegs = {
        "Master":   f"{character_name}_Master_Peg",
        "Body":     f"{character_name}_Body_Peg",
        "Head":     f"{character_name}_Head_Peg",
        "Arm_L":    f"{character_name}_Arm_L_Peg",
        "Arm_R":    f"{character_name}_Arm_R_Peg",
        "Leg_L":    f"{character_name}_Leg_L_Peg",
        "Leg_R":    f"{character_name}_Leg_R_Peg",
    }
    
    print(f"✅ Rig hierarchy created for: {character_name}")
    print(f"   Total pegs: {len(pegs)}")
    print(f"   Deformer zones: Hips, Shoulders, Wrists")
    print(f"   Swap libraries: Mouth (visemes), Hands (poses)")
    
    return pegs

# ── Deformer Setup Notes ──────────────────────────────
# Bone Deformers: Use for limbs (smooth bend at elbows/knees)
# Curve Deformers: Use for hair, tails, tentacles (fluid motion)
# Envelope Deformers: Use for facial expressions (lattice warp)
#
# PRO TIP: Always place deformers ABOVE the artwork in
# the node view, never below. Deformers flow top-down.

# ── Animation Curves: The Animator's Control Panel ────
# F-Curves (Function Curves) are the GRAPH representation
# of your animation over time. Mastering them is essential.

import numpy as np
import matplotlib.pyplot as plt

def visualise_easing_curves():
    """
    Visualise the 4 fundamental easing types.
    Every motion in animation uses one of these.
    """
    t = np.linspace(0, 1, 100)  # Normalised time (0 to 1)
    
    # 1. Linear — Constant speed (robotic, unnatural)
    linear = t
    
    # 2. Ease In — Starts slow, ends fast (acceleration)
    #    Think: a ball dropped from height (gravity)
    ease_in = t ** 2.5
    
    # 3. Ease Out — Starts fast, ends slow (deceleration)
    #    Think: a ball thrown upward (slowing down)
    ease_out = 1 - (1 - t) ** 2.5
    
    # 4. Ease In-Out — Slow start, fast middle, slow end
    #    Think: a car starting and stopping at a light
    ease_in_out = np.where(
        t < 0.5,
        2 * t ** 2,           # First half: ease in
        1 - (-2 * t + 2) ** 2 / 2  # Second half: ease out
    )
    
    # ── Plot ───────────────────────────────────────────
    fig, axes = plt.subplots(1, 4, figsize=(20, 4))
    curves = [
        (linear, "Linear\n(Robotic)", "#ff4444"),
        (ease_in, "Ease In\n(Accelerate)", "#44aaff"),
        (ease_out, "Ease Out\n(Decelerate)", "#44ff88"),
        (ease_in_out, "Ease In-Out\n(Natural)", "#ffaa44"),
    ]
    
    for ax, (curve, title, color) in zip(axes, curves):
        ax.plot(t, curve, color=color, linewidth=3)
        ax.set_title(title, fontsize=12, fontweight="bold")
        ax.set_xlabel("Time →")
        ax.set_ylabel("Value →")
        ax.grid(True, alpha=0.2)
        ax.set_xlim(0, 1)
        ax.set_ylim(0, 1)
    
    plt.suptitle(
        "The 4 Fundamental Easing Curves",
        fontsize=14, fontweight="bold", y=1.05,
    )
    plt.tight_layout()
    plt.savefig("easing_curves.png", dpi=150)
    plt.show()

visualise_easing_curves()
print("\n💡 PRO TIP: 90% of all animation uses Ease In-Out.")
print("   The curve editor is where good animation becomes GREAT.")
print("   Spend time here — it's worth it.")