Merge branch 'feat/spell-structured-data-migration' into feature/update-supernatural-shields

Author: Julen-BZ

scripts/migrateSpellsToStructuredData.cjs

@@ -0,0 +1,136 @@
+const fs = require('fs');
+const path = require('path');
+
+const MAGIC_PACKS_DIR = path.join(__dirname, '..', 'src', 'packs', 'magic');
+
+function parseDamage(description) {
+  const match = description.match(/Daño *(base)* *(\d+)/i);
+  return match ? parseInt(match[2], 10) : 0;
+}
+
+function parseArea(description) {
+  const match = description.match(/[Áá]rea de (\d+) metros/i);
+  return match ? parseInt(match[1], 10) : 0;
+}
+
+function parseResistanceEffect(description) {
+  const resistances = {
+    physical: 'RF',
+    disease: 'RE',
+    poison: 'RV',
+    magic: 'RM',
+    psychic: 'RP'
+  };
+
+  for (const [type, code] of Object.entries(resistances)) {
+    const beforePattern = new RegExp(`(\\d+) *[RFEVMP]{0,2} *o* *${code}`, 'i');
+    const afterPattern = new RegExp(`${code} *o* *[RFEVMP]{0,2} *(\\d+)`, 'i');
+
+    let match = description.match(beforePattern);
+    if (match) return { value: parseInt(match[1], 10), type };
+
+    match = description.match(afterPattern);
+    if (match) return { value: parseInt(match[1], 10), type };
+  }
+
+  return { value: 0, type: null };
+}
+
+function migrateSpellFile(filePath) {
+  const fileName = path.basename(filePath);
+
+  try {
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    const spellData = JSON.parse(fileContent);
+
+    if (spellData.type !== 'spell') {
+      console.log(`  ⊘ Skipping ${fileName} (not a spell)`);
+      return;
+    }
+
+    let modified = false;
+    const grades = ['base', 'intermediate', 'advanced', 'arcane'];
+
+    for (const gradeName of grades) {
+      const grade = spellData.system?.grades?.[gradeName];
+      if (!grade) continue;
+
+      const description = grade.description?.value || '';
+      const damage = parseDamage(description);
+      const area = parseArea(description);
+      const resistanceEffect = parseResistanceEffect(description);
+
+      if (damage > 0 && !grade.damage) {
+        grade.damage = { value: damage };
+        modified = true;
+      } else if (grade.damage && grade.damage.value !== damage && damage > 0) {
+        console.log(`  ⚠ ${fileName} [${gradeName}]: damage mismatch`);
+      }
+
+      if (area > 0 && !grade.area) {
+        grade.area = { value: area };
+        modified = true;
+      } else if (grade.area && grade.area.value !== area && area > 0) {
+        console.log(`  ⚠ ${fileName} [${gradeName}]: area mismatch`);
+      }
+
+      if (resistanceEffect.value > 0 && !grade.resistanceEffect) {
+        grade.resistanceEffect = resistanceEffect;
+        modified = true;
+      } else if (
+        grade.resistanceEffect &&
+        (grade.resistanceEffect.value !== resistanceEffect.value ||
+         grade.resistanceEffect.type !== resistanceEffect.type) &&
+        resistanceEffect.value > 0
+      ) {
+        console.log(`  ⚠ ${fileName} [${gradeName}]: resistance mismatch`);
+      }
+    }
+
+    if (modified) {
+      fs.writeFileSync(filePath, JSON.stringify(spellData, null, 2), 'utf8');
+      console.log(`  ✓ Migrated ${fileName}`);
+      return true;
+    }
+
+    console.log(`  ○ ${fileName} already has structured data`);
+    return false;
+  } catch (error) {
+    console.error(`  ✗ Error processing ${fileName}:`, error.message);
+    return false;
+  }
+}
+
+function migrateAllSpells() {
+  console.log('Starting spell migration to structured data format...\n');
+
+  if (!fs.existsSync(MAGIC_PACKS_DIR)) {
+    console.error(`Error: Magic packs directory not found at ${MAGIC_PACKS_DIR}`);
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(MAGIC_PACKS_DIR)
+    .filter(file => file.endsWith('.json') && file.startsWith('spell_'));
+
+  console.log(`Found ${files.length} spell files\n`);
+
+  let migratedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+
+  for (const file of files) {
+    const result = migrateSpellFile(path.join(MAGIC_PACKS_DIR, file));
+    if (result === true) migratedCount++;
+    else if (result === false) skippedCount++;
+    else errorCount++;
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log(`Migration complete!`);
+  console.log(`  ✓ Migrated: ${migratedCount}`);
+  console.log(`  ○ Already migrated: ${skippedCount}`);
+  if (errorCount > 0) console.log(`  ✗ Errors: ${errorCount}`);
+  console.log('='.repeat(60));
+}
+
+migrateAllSpells();

src/module/combat/utils/damageCheck.js

@@ -1,8 +1,25 @@
-export const damageCheck = effect => {
+export const damageCheck = gradeDataOrEffect => {
+  if (typeof gradeDataOrEffect === 'object' && gradeDataOrEffect !== null) {
+    const damageValue = gradeDataOrEffect.damage?.value;
+    if (typeof damageValue === 'number') {
+      return damageValue;
+    }
+    if (gradeDataOrEffect.description?.value) {
+      return parseDescriptionForDamage(gradeDataOrEffect.description.value);
+    }
+  }
+
+  if (typeof gradeDataOrEffect === 'string') {
+    return parseDescriptionForDamage(gradeDataOrEffect);
+  }
+
+  return 0;
+};
+
+function parseDescriptionForDamage(effect) {
   effect = effect.replace('.', '');
   if (/Daño *(base)* *\d+/i.test(effect)) {
     return parseInt(effect.match(/Daño *(base)* *\d+/i)[0].match(/\d+/)[0]) ?? 0;
-  } else {
-    return 0;
   }
-};
+  return 0;
+}

src/module/combat/utils/resistanceEffectCheck.js

@@ -1,4 +1,26 @@
-export const resistanceEffectCheck = effect => {
+export const resistanceEffectCheck = gradeDataOrEffect => {
+  if (typeof gradeDataOrEffect === 'object' && gradeDataOrEffect !== null) {
+    const resEffect = gradeDataOrEffect.resistanceEffect;
+    if (resEffect && typeof resEffect.value === 'number' && resEffect.type) {
+      return {
+        value: resEffect.value,
+        type: resEffect.type,
+        check: resEffect.value > 0
+      };
+    }
+    if (gradeDataOrEffect.description?.value) {
+      return parseDescriptionForResistance(gradeDataOrEffect.description.value);
+    }
+  }
+
+  if (typeof gradeDataOrEffect === 'string') {
+    return parseDescriptionForResistance(gradeDataOrEffect);
+  }
+
+  return { value: 0, type: undefined, check: false };
+};
+
+function parseDescriptionForResistance(effect) {
   const resistanceEffect = { value: 0, type: undefined, check: false };
   const resistances = { physical: 'RF', disease: 'RE', poison: 'RV', magic: 'RM', psychic: 'RP' }
 
@@ -22,4 +44,4 @@ export const resistanceEffectCheck = effect => {
   }
 
   return resistanceEffect;
-};
+}

src/module/dialogs/combat/CombatAttackDialog.js

@@ -449,14 +449,14 @@ export class CombatAttackDialog extends FormApplication {
         this.attackerActor.setFlag(game.animabf.id, 'lastOffensiveSpellUsed', spellUsed);
         const { spells } = this.attackerActor.system.mystic;
         const spell = spells.find(w => w._id === spellUsed);
-        const spellUsedEffect = spell?.system.grades[spellGrade].description.value ?? '';
+        const spellGradeData = spell?.system.grades[spellGrade];
         if (this.attackerActor.evaluateCast(spellCasting)) {
           this.modalData.attacker.mystic.overrideMysticCast = true;
           return;
         }
         let visibleCheck = spell?.system.visible;
 
-        let resistanceEffect = resistanceEffectCheck(spellUsedEffect);
+        let resistanceEffect = resistanceEffectCheck(spellGradeData);
 
         let combatModifier = 0;
         for (const key in attackerCombatMod) {
@@ -662,9 +662,8 @@ export class CombatAttackDialog extends FormApplication {
       mystic.spellUsed = spells.find(w => w.system.combatType.value === 'attack')?._id;
     }
     const spell = spells.find(w => w._id === mystic.spellUsed);
-    const spellUsedEffect =
-      spell?.system.grades[mystic.spellGrade].description.value ?? '';
-    mystic.damage.final = mystic.damage.special + damageCheck(spellUsedEffect);
+    const spellGradeData = spell?.system.grades[mystic.spellGrade];
+    mystic.damage.final = mystic.damage.special + damageCheck(spellGradeData);
     mystic.spellCasting = this.attackerActor.mysticCanCastEvaluate(
       spell,
       mystic.spellGrade,

src/module/migration/migrations/10-update-spells-structured-data.js

@@ -0,0 +1,60 @@
+/** @typedef {import('./Migration').Migration} Migration */
+
+import { Logger } from '../../../utils';
+
+const newItems = {
+  get ready() {
+    return !!this.spell;
+  },
+  async init() {
+    if (this.ready) return;
+    this.spell = await game.packs.get('animabf.magic').getDocuments();
+  },
+  async get(itemType, name) {
+    if (!this.ready) await this.init();
+    return this[itemType].find(i => i.name.toLowerCase() === name.toLowerCase());
+  }
+};
+
+/** @type Migration */
+export const Migration10UpdateSpellsStructuredData = {
+  id: 'migration_update-spells-structured-data',
+  version: '2.0.6',
+  order: 1,
+  title: 'Update spells to use structured damage and resistance data',
+  description:
+    'This migration updates existing spells to include structured fields for damage, area of effect, ' +
+    'and resistance bonuses instead of relying on text parsing. This improves performance and ' +
+    'makes spell data more reliable and easier to work with. ' +
+    'Custom spell descriptions will be preserved. Custom spells will be left unchanged but may need ' +
+    'manual updates to benefit from the new structured data format.',
+  filterItems(item) {
+    return item.type === 'spell' && !['animabf.magic'].includes(item.pack);
+  },
+  filterActors(actor) {
+    return actor.items.filter(i => i.type === 'spell').length > 0;
+  },
+  async updateItem(item) {
+    if (item.type !== 'spell') {
+      Logger.error('spell filter not working');
+      return;
+    }
+
+    const name = item.name.includes('-') ? item.name.split(' - ')[1] : item.name;
+    const newItem = await newItems.get('spell', name);
+    if (!newItem) return;
+
+    item.name = newItem.name;
+    const { system } = newItem;
+    system.description.value = item.system.description.value;
+
+    for (const gradeName of ['base', 'intermediate', 'advanced', 'arcane']) {
+      if (item.system.grades?.[gradeName]?.description?.value) {
+        system.grades[gradeName].description.value = item.system.grades[gradeName].description.value;
+      }
+    }
+
+    item.system = system;
+    return item;
+  }
+};

src/module/migration/migrations/index.js

@@ -7,3 +7,4 @@ export { Migration6OldModifiers } from './6-fix-old-modifiers';
 export { Migration7WeaponsOwnStrength } from './7-fix-weapons-ownStrength';
 export { Migration8RemoveWeaponFue } from './8-remove-unused-weaponFue';
 export { Migration9FixKiSeals } from './9-fix-ki-seals';
+export { Migration10UpdateSpellsStructuredData } from './10-update-spells-structured-data';

src/module/types/mystic/SpellItemConfig.js

@@ -54,28 +54,52 @@ export const INITIAL_MYSTIC_SPELL_DATA = {
       intRequired: { value: 0 },
       maintenanceCost: { value: 0 },
       zeon: { value: 0 },
-      description: { value: '' }
+      description: { value: '' },
+      damage: { value: 0 },
+      area: { value: 0 },
+      resistanceEffect: {
+        value: 0,
+        type: ''
+      }
     },
     intermediate: {
       name: { value: SpellGradeNames.INTERMEDIATE },
       intRequired: { value: 0 },
       maintenanceCost: { value: 0 },
       zeon: { value: 0 },
-      description: { value: '' }
+      description: { value: '' },
+      damage: { value: 0 },
+      area: { value: 0 },
+      resistanceEffect: {
+        value: 0,
+        type: ''
+      }
     },
     advanced: {
       name: { value: SpellGradeNames.ADVANCED },
       intRequired: { value: 0 },
       maintenanceCost: { value: 0 },
       zeon: { value: 0 },
-      description: { value: '' }
+      description: { value: '' },
+      damage: { value: 0 },
+      area: { value: 0 },
+      resistanceEffect: {
+        value: 0,
+        type: ''
+      }
     },
     arcane: {
       name: { value: SpellGradeNames.ARCANE },
       intRequired: { value: 0 },
       maintenanceCost: { value: 0 },
       zeon: { value: 0 },
-      description: { value: '' }
+      description: { value: '' },
+      damage: { value: 0 },
+      area: { value: 0 },
+      resistanceEffect: {
+        value: 0,
+        type: ''
+      }
     }
   }
 };

src/packs/magic/spell_Acechar_en_los_Sue_os_jZh9b9NJOR5eesXb.json

@@ -51,6 +51,10 @@
         },
         "description": {
           "value": "RM o RP 120."
+        },
+        "resistanceEffect": {
+          "value": 120,
+          "type": "magic"
         }
       },
       "intermediate": {
@@ -68,6 +72,10 @@
         },
         "description": {
           "value": "RM o RP 160."
+        },
+        "resistanceEffect": {
+          "value": 160,
+          "type": "magic"
         }
       },
       "advanced": {
@@ -85,6 +93,10 @@
         },
         "description": {
           "value": "RM o RP 200."
+        },
+        "resistanceEffect": {
+          "value": 200,
+          "type": "magic"
         }
       },
       "arcane": {
@@ -102,6 +114,10 @@
         },
         "description": {
           "value": "RM o RP 240."
+        },
+        "resistanceEffect": {
+          "value": 240,
+          "type": "magic"
         }
       }
     }