FoundryVTT RPG Spell Animation Creator

Creates visual spell animations for a custom RPG system in FoundryVTT using the Sequencer module. This skill helps you build RPG-compliant spell macros with proper turn validation, element mechanics, and focus stance support.

Project Context

This is a **FoundryVTT spell animation collection** for a **custom RPG system** (NOT D&D 5e). All spells must comply with specific custom game rules.

Custom RPG Rules

**Combat System:**

Initiative based on Agilité characteristic

1 Simple Action + 1 Movement Action per turn

Movement: Up to 6 squares, diagonal costs 1.5 (rounded down)

**Combat Stances (choose at turn start):**

1. **Offensive**: Maximize all damage dice, -2 Agilité for defense

2. **Defensive**: Can use reactive spells, use spell stats for defense

3. **Focus**: Most spells become free mana cost, -1 Agilité

**Resources:**

Health Points: 10 base + bonus

Mana Points: 5 base + bonus

Critical: 0 HP or MP = unconscious/danger

**Spell Mechanics:**

Damage Formula: Varies by spell, often `1d6 + (Stat + bonus)/2`

Mana Costs: Specific per spell, many are "focusable" (free in Focus stance)

Spell Levels: Start at 1, gain +2 hit bonus per level

Element Effects: Create tactical advantages/vulnerabilities

Available Modules

**Essential (Pre-installed):**

Sequencer (core animation system)

JB2A Free & Patreon (visual effects libraries)

Portal (crosshair targeting)

Carousel Combat Track (turn order)

Animated Spell Effects (additional effects)

Instructions

1. Understand the Project Structure

Before creating spells, review the project documentation:

`GAME-RULES.md` - Complete RPG mechanics (REQUIRED reading)

`DEVELOPMENT.md` - Installation and setup guidelines

`MODULE-REQUIREMENTS.md` - Module dependencies

`assets/README.md` - Effects and assets reference

2. Use the Standard Spell Macro Template

```javascript

/**

* [Spell Name] - [Brief Description]

* RPG-COMPLIANT SPELL for Custom RPG System

* Description: [Detailed spell mechanics]

* Damage/Healing: [Formula explanation]

* Mana Cost: X mana (focusable/not focusable)

* Prerequisites: Sequencer, Portal, [other modules]

(async () => {

// 1. Validate requirements

if (!canvas.tokens.controlled.length) {

ui.notifications.error("Please select your character token first!");

return;

}

// 2. Validate turn order

const casterToken = canvas.tokens.controlled[0];

if (!validateSpellCasting(casterToken, "Spell Name")) {

return;

}

// 3. Get user inputs (dialogs for stats, options)

// Use HTML dialogs to collect:

// - Primary stat value (Physique, Esprit, etc.)

// - Stat bonus

// - Element variant (if applicable)

// - Focus stance (if spell is focusable)

// 4. Handle targeting (Portal crosshairs)

// Use Portal.Spawn for crosshair targeting

// Handle single target, multi-target, or self-targeting

// 5. Roll damage/healing for display

// Calculate damage: typically 1d6 + (Stat + bonus)/2

// Use Roll API to generate results

// 6. Create Sequencer animation

// Use JB2A effects with proper timing

// Include: casting effect, projectile/effect, impact, sound

// 7. Display results in chat

// Show spell details, targets, damage/healing, element effects

// 8. Helper functions

function validateSpellCasting(casterToken, spellName) {

const combat = game.combat;

if (!combat?.started) {

ui.notifications.warn(`${spellName} requires active combat`);

return false;

}

const activeCombatant = combat.combatant;

if (activeCombatant?.token?.id !== casterToken.id) {

ui.notifications.warn(`${spellName}: Wait for your turn!`);

return false;

}

return true;

}

})();

```

3. Implement Core Spell Elements

**Required Elements:**

✅ RPG rule compliance (custom game mechanics)

✅ User input dialogs for stats and options

✅ Portal targeting for crosshair selection

✅ Damage/healing display in chat with formula

✅ Proper error handling and input validation

✅ Clear documentation explaining RPG mechanics

**Animation Elements:**

✅ Casting effect on caster

✅ Projectile or main spell effect

✅ Impact or result visual

✅ Sound effects

✅ Proper timing and synchronization

**DO NOT Include:**

❌ Automatic dice rolling (let external systems handle)

❌ Character sheet automation (don't modify actor data)

❌ Turn order management (Carousel Combat Track handles)

❌ Mana deduction (character sheet manages resources)

❌ Damage application (show results only, don't apply)

4. Follow Animation Patterns

**Basic Effect:**

```javascript

new Sequence()

.effect()

.file("jb2a.effect.webm")

.atLocation(caster)

.scale(0.8)

.sound()

.file("path/to/sound.wav")

.volume(0.3)

.play();

```

**Projectile Pattern:**

```javascript

new Sequence()

.effect()

.file("jb2a.projectile")

.atLocation(caster)

.stretchTo(target)

.waitUntilFinished(-200)

.effect()

.file("jb2a.explosion")

.atLocation(target)

.play();

```

5. Implement Spell Categories by Stat

Map spells to the appropriate RPG stat:

**Physique**: Physical-based spells (force, impact)

**Dextérité**: Precision spells (targeting, fine control)

**Esprit**: Mental/concentration spells (most magic)

**Sens**: Perception-based spells (detection, awareness)

**Volonté**: Will-based spells (resistance, determination)

**Charisme**: Social/emotional spells (charm, fear)

6. Handle Focus Mechanics

**Focusable Spells**: Become free (0 mana) in Focus stance

**Non-Focusable**: Always cost mana regardless of stance

**Half-Focus**: Mana cost reduced by half in Focus stance

7. Implement Element Interactions

**Water**: Reduces speed/movement

**Ice**: Creates electrical damage vulnerability

**Fire**: Direct damage, synergizes with oil

**Oil**: Creates fire damage vulnerability

**Lightning**: Benefits from ice vulnerability

**Shadow**: Life drain, stealth effects

**Living Water**: Healing variant, often non-focusable

8. Format Chat Messages

```javascript

const chatContent = `

<h3>🎯 ${spellName} (${elementType})</h3>

Caster: ${actor.name}

Targets: ${targetDescription}

Mana Cost: ${manaCost}

<hr>

Damage/Healing: ${result}

<hr>

Element Effect: ${elementEffect}

</div>

ChatMessage.create({

content: chatContent,

speaker: ChatMessage.getSpeaker({ actor })

});

```

9. File Organization

Place spell macros in the appropriate directory:

```

/macros/

├── basic/ # Simple single-effect spells

├── intermediate/ # Multi-step sequences

├── advanced/ # Complex targeting & interactions

├── spells/ # Generic spell animations

├── characters/ # Character-specific RPG-compliant spells

└── utilities/ # Helper functions

```

10. Reference Implementation

See `/macros/characters/ora/bubbles.js` for a complete RPG-compliant spell example featuring:

Four element variants (Water, Ice, Oil, Living Water)

Proper focus mechanics

Self-targeting capability

Dual/single projectile logic

Complete user interaction flow

Important Notes

1. **Always ask for stat values** - cannot be auto-retrieved from character sheets

2. **Focus on visual effects** - this is an animation collection, not a game system

3. **Follow RPG rules strictly** - this is NOT generic D&D 5e

4. **Use proper error handling** - validate all user inputs

5. **Include comprehensive documentation** - explain RPG mechanics in comments

6. **Test targeting scenarios** - single target, multi-target, self-target

7. **Consider stance implications** - how spell behaves in different combat stances

Example Usage

When creating a new spell:

1. Start with the template structure

2. Define spell mechanics (damage formula, mana cost, focusability)

3. Implement user input dialogs for stats and options

4. Set up Portal targeting for crosshair selection

5. Create Sequencer animation with appropriate JB2A effects

6. Format and display results in chat with proper RPG information

7. Test in all combat stances and targeting scenarios

FoundryVTT RPG Spell Animation Creator

FoundryVTT RPG Spell Animation Creator

Project Context

Custom RPG Rules

Available Modules

Instructions

1. Understand the Project Structure

2. Use the Standard Spell Macro Template

3. Implement Core Spell Elements

4. Follow Animation Patterns

5. Implement Spell Categories by Stat

6. Handle Focus Mechanics

7. Implement Element Interactions

8. Format Chat Messages

9. File Organization

10. Reference Implementation

Important Notes

Example Usage

Reviews (0)