Communitygithub.com

Animation de messages textuels

Ce skill doit être utilisé lorsque l'utilisateur demande de « faire une fausse vidéo de SMS », « animer une conversation iMessage », « créer une vidéo d'histoire textuelle », « faire une animation de réponse par chat », « une vidéo de conversation WhatsApp/SMS », « une animation d'indicateur de saisie », « rendre un fil de discussion en vidéo » ou « produire en lot des vidéos de messages textuels à partir d'un script/CSV ». Il couvre la disposition des bulles envoyées/reçues, le timing d'apparition décalée avec indicateurs de saisie, les accusés de lecture/horodatages, la synchronisation sonore par message pop, la zone de sécurité 9:16 et le rendu piloté par les données à partir d'un tableau de messages.

Qu'est-ce que Animation de messages textuels ?

Ce skill permet de transformer un script de conversation textuelle en une vidéo verticale (9:16) pour TikTok, Reels ou Shorts, où les bulles de chat apparaissent une par une, simulant une vraie conversation iMessage, WhatsApp ou SMS. Il gère automatiquement le timing décalé des apparitions de bulles (avec un indicateur de saisie « trois points » avant chaque message reçu), l'alignement des bulles à droite (envoyé, bleu/vert) ou à gauche (reçu, gris), les accusés de lecture, les réactions tapback, les horodatages et le défilement automatique pour que le dernier message reste visible. La synchronisation sonore (pop/ding) est calée sur chaque apparition de bulle, et tout est piloté par un tableau de messages (format JSON ou CSV), ce qui permet une production en lot de nombreuses vidéos à partir d'un même template. Le skill s'appuie sur Remotion pour un rendu headless et reproductible, sans aucune animation CSS ni timer JavaScript. Il est idéal pour les créateurs de contenu, les équipes marketing et les développeurs souhaitant automatiser la production de vidéos narratives basées sur des conversations textuelles, avec un rendu professionnel et une esthétique réaliste.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ItsMeMal/mallss3d-motion/tree/HEAD/.claude/skills/text-message-animation

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Animation de messages textuels ?

Transformez un script de conversation en une vidéo qui arrête le défilement : les bulles apparaissent une à une, un indicateur de saisie pulse avant chaque réponse, un son pop se déclenche à l'envoi, et le fil défile automatiquement pour garder le dernier message dans le cadre. C'est l'un des formats « sans visage » les plus engageants pour les réseaux sociaux — une histoire racontée en bulles iMessage/WhatsApp/SMS que le spectateur lit comme s'il regardait par-dessus l'épaule de quelqu'un.

Quand l'utiliser

  • Vidéos « faux SMS » / histoires de chat pour TikTok, Reels et Shorts (9:16 vertical).
  • Animation d'une conversation iMessage, WhatsApp ou SMS générique à partir d'un script.
  • Vidéos de réponse/réaction où un fil dévoile une punchline message par message.
  • Production en lot de nombreuses vidéos de chat à partir d'un template + un tableau de messages ou un CSV.

Deux règles intangibles

  1. Un message apparaît à la fois, sur un rythme. L'engagement vient du goutte-à-goutte : un temps de saisie, puis une bulle apparaît, puis une pause pour lire. Ne déversez jamais tout le fil à l'image 0 — rythmez-le comme une vraie conversation (un indicateur de saisie avant les réponses reçues, un court temps de lecture après chaque bulle).
  2. Le chrome doit être immédiatement reconnaissable comme l'application réelle. Envoyé = à droite, bleu (iMessage) ou vert (SMS) / vert WhatsApp ; reçu = à gauche, gris. Queue sur la dernière bulle d'une série, coins arrondis ~18–22 px, barre de statut et en-tête corrects. Si un spectateur ne peut pas dire de quelle application il s'agit dans la première demi-seconde, l'illusion est rompue.

Le modèle de données — le script d'abord, le rendu ensuite

Tout est basé sur un tableau de messages. Écrivez l'histoire comme des données ; le moteur de rendu se contente de la jouer. C'est ce qui rend le format industrialisable : un template × N scripts → N vidéos.

type Message = {
  from: "me" | "them";        // me = envoyé (droite/bleu), them = reçu (gauche/gris)
  text: string;
  typingMs?: number;          // affiche l'indicateur de saisie pendant cette durée avant la bulle (reçu uniquement)
  delayMs?: number;           // temps de lecture APRÈS la bulle précédente, avant celle-ci
  status?: "delivered" | "read";  // accusé sous la dernière bulle envoyée
  reaction?: "❤️" | "👍" | "😂" | "‼️" | "❓"; // tapback, arrive ~400 ms après la bulle
};

const thread: Message[] = [
  { from: "them", text: "attends t'es OÙ là maintenant", typingMs: 900 },
  { from: "me",   text: "devant chez toi 🙂", delayMs: 600, status: "read" },
  { from: "them", text: "...", typingMs: 1400, reaction: "❓" },
];

Dérivez chaque timestamp d'image de ce tableau — voir « Timing » ci-dessous. Gardez text/from comme seuls champs obligatoires pour qu'un CSV (from,text,typingMs,delayMs,status) s'y mappe directement.

Disposition et alignement des bulles

Une bulle est une pilule de largeur maximale alignée sur son côté. Envoyé est collé à la bordure droite ; reçu est collé à la gauche. Empilez verticalement dans l'ordre d'envoi ; la dernière bulle d'une série consécutive du même expéditeur reçoit la queue.

const BUBBLE: React.CSSProperties = {
  maxWidth: "74%",                // jamais pleine largeur — laisse la marge « c'est un téléphone »
  padding: "14px 18px",
  borderRadius: 22,
  fontSize: 34,                   // proportions iMessage à 1080 px de large
  lineHeight: 1.25,
  wordBreak: "break-word",
};
const SENT: React.CSSProperties = {
  ...BUBBLE, alignSelf: "flex-end", background: "#0A84FF", color: "#fff",      // iMessage bleu
};
const RECEIVED: React.CSSProperties = {
  ...BUBBLE, alignSelf: "flex-start", background: "#3B3B3D", color: "#fff",    // gris mode sombre
};

Aide-mémoire des palettes : iMessage envoyé #0A84FF (fond clair #1C1C1E), reçu #E9E9EB texte #000 (clair) / #3B3B3D (sombre). SMS envoyé vert #37C24A. WhatsApp envoyé #005C4B, reçu #202C33 sur fond de chat #0B141A, avec des coches (gris = envoyé, bleu #53BDEB = lu). Utilisez UNE application complètement ; ne mélangez pas le chrome iMessage avec les coches WhatsApp.

Apparition décalée + indicateur de saisie

Chaque bulle surgit légèrement depuis le bas avec un petit effet de zoom, ancrée à sa propre image d'entrée. Les messages reçus sont précédés d'une bulle de saisie à trois points qui pulse, puis est remplacée par la vraie bulle.

import { useCurrentFrame, useVideoConfig, spring, interpolate, Sequence } from "remotion";

const Bubble: React.FC<{ enterFrame: number; sent: boolean; children: React.ReactNode }> =
({ enterFrame, sent, children }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const p = spring({ frame: frame - enterFrame, fps, config: { damping: 14, mass: 0.7 } });
  return (
    <div style={{
      alignSelf: sent ? "flex-end" : "flex-start",
      transform: `translateY(${interpolate(p, [0, 1], [24, 0])}px) scale(${interpolate(p, [0, 1], [0.85, 1])})`,
      opacity: interpolate(p, [0, 1], [0, 1]),
      transformOrigin: sent ? "bottom right" : "bottom left",
    }}>{children}</div>
  );
};

// indicateur de saisie à trois points — les points respirent sur une sinusoïde, pilotée par l'image (pas de minuteurs CSS)
const Typing: React.FC = () => {
  const frame = useCurrentFrame();
  const dot = (i: number) => 0.4 + 0.6 * (0.5 + 0.5 * Math.sin((frame / 8) - i * 0.9));
  return (
    <div style={{ ...RECEIVED, display: "flex", gap: 8, padding: "18px 20px" }}>
      {[0, 1, 2].map(i => (
        <span key={i} style={{ width: 12, height: 12, borderRadius: 6, background: "#aaa", opacity: dot(i) }} />
      ))}
    </div>
  );
};

Placez l'indicateur de saisie dans un <Sequence from={typingStart} durationInFrames={typingLen}> juste avant le <Sequence> de la bulle pour qu'il s'affiche, puis soit remplacé par la vraie bulle. Seuls les messages reçus tapent ; les messages envoyés apparaissent simplement (vous ne vous regardez pas taper).

Timing — transformez le tableau en images

Parcourez les messages en accumulant un curseur en ms. C'est la source de vérité unique que les entrées spring, les fenêtres de saisie, les sons et le défilement automatique lisent tous.

const f = (ms: number) => Math.round((ms / 1000) * fps);
let cursor = 0;
const timeline = thread.map((m) => {
  cursor += m.delayMs ?? 500;                          // temps de lecture avant ce message
  const typingLen = m.from === "them" ? (m.typingMs ?? 800) : 0;
  const typingStart = cursor;
  cursor += typingLen;                                 // la saisie se joue pendant le temps
  const enterMs = cursor;                              // la bulle apparaît à la fin de la saisie
  cursor += 250;                                       // temps de stabilisation avant le prochain temps de lecture
  return { ...m, typingStartMs: typingStart, typingLenMs: typingLen, enterMs };
});
const durationMs = cursor + 1000;                      // marge finale pour que la dernière bulle soit lisible

Réglez la sensation : les fils rapides/crépitants utilisent delayMs 300–500 et typingMs 500–900 ; les révélations pleines de suspense étirent typingMs jusqu'à 1500–2500 avant la ligne de chute. Calculez durationInFrames à partir de durationMs dans calculateMetadata pour qu'un script plus long produise automatiquement une vidéo plus longue.

Accusés de lecture, horodatages et réactions

  • Accusé (« Delivered » / « Read ») s'affiche petit et aligné à droite sous la dernière bulle envoyée ; fondu entrant ~300 ms après l'arrivée de la bulle. Sur WhatsApp, c'est la double coche qui devient bleue.
  • Horodatage (« Today 9:41 PM ») est un séparateur gris centré au-dessus du premier message d'un nouveau bloc horaire — ne l'affichez pas sur chaque bulle.
  • Réaction / tapback s'agrandit dans le coin de sa bulle cible ~400 ms après l'apparition de la bulle, avec un léger dépassement. Ancrez-le au enterMs + 400 de cette bulle, pas à une image globale.

Défilement automatique — gardez la dernière bulle dans le cadre

Lorsque la pile dépasse la zone visible, déplacez tout le fil vers le haut pour que la dernière bulle se trouve dans le tiers inférieur. Animez le décalage de défilement vers la cible avec un spring à chaque fois qu'un message arrive — il doit glisser, pas sauter.

// targetY = hauteur totale des messages au-dessus du bas de la fenêtre, recalculée à chaque entrée de bulle
const scroll = spring({ frame: frame - lastEnterFrame, fps, config: { damping: 200 } });
const y = prevY + (targetY - prevY) * scroll;   // transition douce de l'ancien décalage au nouveau
return <div style={{ transform: `translateY(${-y}px)` }}>{/* bulles */}</div>;

Gardez la bulle la plus récente éloignée de la zone de sécurité inférieure (voir ci-dessous) pour que les points d'accusé/saisie en dessous restent visibles.

Synchronisation sonore (pop par message)

Un « swoosh/pop » net à chaque envoi et un « ding » plus doux à chaque réception représentent la moitié de la sensation de réalisme de ce format. Placez un signal audio par message au enterMs de ce message, dans la même base de temps que les visuels.

import { Audio, staticFile, Sequence } from "remotion";
{timeline.map((m, i) => (
  <Sequence key={i} from={f(m.enterMs)}>
    <Audio src={staticFile(m.from === "me" ? "send.mp3" : "receive.mp3")} />
  </Sequence>
))}

Ajoutez éventuellement un léger bruit de clavier en fond pendant chaque fenêtre de saisie. Gardez les signaux courts (<300 ms) pour qu'ils ne s'accumulent pas sur les fils rapides. Ne déclenchez jamais le son à partir d'un timer — planifiez-le sur la timeline des images pour qu'il survive au rendu headless.

Zone de sécurité pour le 9:16 (1080×1920)

ZoneÀ garder librePourquoi
Barre de statut haute~120 pxVotre fausse barre de statut/encoche se trouve ici ; ne mettez pas de bulles en dessous
En-tête de l'app~150 px (avatar + nom)L'en-tête de contact vend l'application — gardez-le épinglé et dégagé
Barre de saisie + UI basse~360 pxLa fausse barre de composition ET l'UI de légende/CTA/audio de la plateforme s'entassent toutes les deux en bas
Marges latéralescentre ~88 % de largeurLes bulles ne touchent jamais le bord de l'écran — la marge est ce qui fait penser à « un téléphone »

Faites défiler la conversation en direct dans la bande entre l'en-tête et la barre de composition. Faites atterrir chaque nouvelle bulle dans le tiers inférieur de cette bande (au-dessus de la zone de saisie), puis défilez automatiquement — c'est là que l'œil attend le nouveau message.

Liste de vérification pour la sortie

  • Un seul tableau de messages pilote tout ; les horodatages sont dérivés, pas placés à la main.
  • Un message à la fois : temps de lecture → saisie (reçu uniquement) → apparition, sur un rythme réglé.
  • Chrome d'application correct de bout en bout (couleurs, queues, en-tête, accusés) — pas de mélange d'applications.
  • Envoyé à droite/bleu-ou-vert, reçu à gauche/gris ; queue sur la dernière de chaque série.
  • Accusé sous la dernière bulle envoyée ; séparateur d'horodatage par bloc temporel ; dépassement des tapbacks entrants.
  • Défilement automatique maintient la bulle la plus récente dans le tiers inférieur, hors des zones de sécurité.
  • Un pop/ding par message, planifié sur la timeline des images (pas de timers).
  • En-tête épinglé sous la barre de statut ; conversation dans la bande de sécurité 9:16.

Livrez et vérifiez (images rendues → MP4)

Assistant empaqueté (scripts/) : mosaïquez vos images avec scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png, puis vérifiez l'encodage avec scripts/probe-mp4.sh out.mp4 [LxH] [fps]. Voir scripts/README.md.

Livré en tant que composition Remotion (<Composition> + schéma zod + defaultProps) dont les props sont le tableau de messages. Chaque entrée de bulle, pulsation de saisie, décalage de défilement et signal sonore est piloté par l'image via useCurrentFrame() — jamais Date.now() / Math.random() / de minuteurs d'animation CSS — pour que n'importe quelle image soit rendue de manière identique en mode headless. Livrable = out/*.mp4 + le projet (re-rendu avec un nouveau script). 9:16 vertical (1080×1920) est la valeur par défaut. La durée dépend des données, donc calculez durationInFrames dans calculateMetadata à partir du curseur de la timeline, jamais à la main.

Boucle de vérification — rendre des images → inspecter → encoder. Le timing des apparitions et la position de défilement sont ce qui casse ; vérifiez les images exactes avant de lancer un encodage.

# Images AVEC LES PROPS FOURNIES (le vrai fil) à : un temps de saisie / une apparition au milieu / la dernière bulle
npx remotion still TextThread out/f-typing.png --frame=24  --props='{"threadSrc":"thread.json"}'
npx remotion still TextThread out/f-mid.png    --frame=90  --props='{"threadSrc":"thread.json"}'
npx remotion still TextThread out/f-end.png    --frame=N   --props='{"threadSrc":"thread.json"}'  # N = durationInFrames-1

# Inspectez chaque PNG :
#  - l'image 24 montre l'indicateur de saisie à trois points à GAUCHE (reçu), pas encore de vraie bulle
#  - à l'image du milieu, la bulle qui vient d'arriver est du bon côté/couleur avec sa queue ; accusé/réaction bien placés
#  - le fil a défilé automatiquement pour que la bulle la plus récente se trouve dans le tiers inférieur, PAS cachée sous la barre de composition
#  - le chrome de l'application est cohérent (barre de statut, en-tête) et à l'intérieur de la bande de sécurité 9:16 ; rien sous l'encoche haute

npx remotion render TextThread out/thread.mp4 --props='{"threadSrc":"thread.json"}'   # encodez une fois que les images sont bonnes
npx remotion render TextThread out/demo.gif --codec=gif                               # clip de preuve pour le README

Utilisez npx remotion compositions pour lire durationInFrames/fps et choisir les images de saisie/milieu/fin. Pour un aperçu rapide sans build, la même disposition s'affiche sous forme de page HTML autonome avec un mécanisme de recherche ?t=N — voir references/bubble-recipes.md.

Avant de terminer :

  1. Les images sont rendues proprement à une image de saisie, une apparition au milieu et la dernière bulle — pas de polices/audio manquants.
  2. Sur une image de saisie, l'indicateur (pas la bulle) s'affiche du côté reçu ; la bulle n'apparaît qu'après.
  3. Chaque bulle est du bon côté/couleur avec la bonne queue ; accusé/horodatage/réaction arrivent là où prévu.
  4. Le défilement automatique maintient la bulle la plus récente dans le tiers inférieur et dans la zone de sécurité 9:16 à chaque image vérifiée.
  5. Uniquement piloté par l'image (pas de Date.now()/Math.random()/minuteurs) ; les props fournies s'affichent correctement ; MP4 + GIF optionnel émis.

Fichiers de référence

  • references/bubble-recipes.md — modèle prêt à l'emploi : chrome et palettes iMessage/WhatsApp/SMS, modèle de données message → timeline d'images, bulle spring + queue, indicateur de saisie à trois points, accusés de lecture/horodatages/tapbacks, défilement automatique, planification sonore par message, la composition Remotion complète avec calculateMetadata, et un aperçu HTML autonome avec le mécanisme de recherche ?t=N.
  • references/data-driven.md — la forme des données script→messages, création de fils en JSON/CSV, cartographie d'un CSV dans le type Message[], et rendu en lot de nombreuses vidéos à partir d'un seul template avec @remotion/renderer.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés