madden-franchise 3.6.0 → 3.7.2

package/FranchiseEnum.js

@@ -90,6 +90,10 @@ class FranchiseEnum {
   };
 
   setMemberLength() {
+    if (this._members.length === 0) {
+      return;
+    }
+
     const maxValue = this._members.reduce((accum, currentVal) => {
       return (accum.value > currentVal.value ? accum : currentVal);
     });

package/FranchiseFile.js

@@ -63,7 +63,7 @@ class FranchiseFile extends EventEmitter {
     this._rawContents = fs.readFileSync(filePath);
 
     /** @private @type {FileType} */
-    this._type = getFileType(this._rawContents);
+    this._type = getFileType(this._rawContents, this._settings);
 
     /** @private @type {number} */
     this._gameYear = this._type.year;
@@ -81,7 +81,7 @@ class FranchiseFile extends EventEmitter {
       this.unpackedFileContents = unpackFile(this._rawContents, this._type);
 
       if (this._type.format === Constants.FORMAT.FRANCHISE_COMMON) {
-        const newType = getFileType(this.unpackedFileContents);
+        const newType = getFileType(this.unpackedFileContents, this._settings);
         this._type.year = newType.year;
         this._gameYear = this._type.year;
         this._expectedSchemaVersion = getSchemaMetadata(
@@ -121,7 +121,11 @@ class FranchiseFile extends EventEmitter {
             ).path;
 
       try {
-        this.schemaList = new FranchiseSchema(schemaPath);
+        this.schemaList = new FranchiseSchema(schemaPath, {
+          extraSchemas: this.settings.extraSchemas,
+          fileMap: this.settings.schemaFileMap,
+          useNewSchemaGeneration: this.settings.useNewSchemaGeneration
+        });
         this.schemaList.on("schemas:done", () => {
           resolve();
         });
@@ -583,12 +587,13 @@ function _saveSync(destination, packedContents) {
 /**
  * 
  * @param {Buffer} data 
+ * @param {FranchiseFileSettings} settings
  * @returns {FileType}
  */
-function getFileType(data) {
+function getFileType(data, settings) {
   const isDataCompressed = isCompressed(data);
   const format = getFormat(data, isDataCompressed);
-  const year = getGameYear(data, isDataCompressed, format);
+  const year = settings?.gameYearOverride ?? getGameYear(data, isDataCompressed, format);
 
   return {
     format: format,
@@ -652,7 +657,7 @@ function getGameYear(data, isCompressed, format) {
       max: 95,
     },
     {
-      year: 25,
+      year: 26,
       max: 999,
     },
   ];
@@ -687,6 +692,8 @@ function getGameYear(data, isCompressed, format) {
     } else if (data[0x2A] === 0x35) {
       // M25 has year indicator in a different location
       return 25;
+    } else if (data[0x2A] === 0x36) {
+      return 26;
     } else {
       const schemaMajor = getCompressedSchema(data).major;
       const year = schemaMax.find((schema) => {

package/FranchiseFileField.js

@@ -149,7 +149,7 @@ class FranchiseFileField {
             // return (formatted == 1 || (formatted.toString().toLowerCase() == 'true')) ? '1' : '0';
             actualValue = (value == 1 || (value.toString().toLowerCase() == 'true'));
             this._value = actualValue;
-            this._unformattedValue.setBits(this.offset.offset, actualValue, 1);
+            this._unformattedValue.setBits(this.offset.offset + (this.offset.length - 1), actualValue, 1);
             break;
           case 'float':
             actualValue = parseFloat(value);
@@ -299,7 +299,7 @@ class FranchiseFileField {
             }
           }
           case 'bool':
-            return unformatted.getBits(offset.offset, 1) ? true : false;
+            return unformatted.getBits(offset.offset + (offset.length - 1), 1) ? true : false;
           case 'float':
             // return utilService.bin2Float(unformatted);
             return unformatted.getFloat32(offset.offset, offset.length);

package/FranchiseFileSettings.js

@@ -17,9 +17,17 @@ class FranchiseFileSettings {
     /** @type {string | false} */
     this.schemaDirectory = settings && settings.schemaDirectory ? settings.schemaDirectory : false;
     /** @type {boolean} */
+    this.useNewSchemaGeneration = settings?.useNewSchemaGeneration ?? false;
+    /** @type {Object} */
+    this.schemaFileMap = settings?.schemaFileMap || {};
+    /** @type {Object[]} */
+    this.extraSchemas = settings?.extraSchemas || undefined;
+    /** @type {boolean} */
     this.autoParse = settings && (settings.autoParse !== null && settings.autoParse !== undefined) ? settings.autoParse : true;
     /** @type {boolean} */
     this.autoUnempty = settings && (settings.autoUnempty !== null && settings.autoUnempty !== undefined) ? settings.autoUnempty : false;
+    /** @type {number} */
+    this.gameYearOverride = settings && (settings.gameYearOverride !== null && settings.gameYearOverride !== undefined) ? settings.gameYearOverride : null;
   }
 };
 

package/FranchiseSchema.js

@@ -4,6 +4,7 @@ const zlib = require('zlib');
 const FranchiseEnum = require('./FranchiseEnum');
 const EventEmitter = require('events').EventEmitter;
 const schemaGenerator = require('./services/schemaGenerator');
+const { generateSchemaV2 } = require('./services/schemaGeneratorV2');
 
 /** 
    * @typedef SchemaAttribute
@@ -30,12 +31,15 @@ const schemaGenerator = require('./services/schemaGenerator');
 */
 
 class FranchiseSchema extends EventEmitter {
-  constructor (filePath) {
+  constructor (filePath, { useNewSchemaGeneration = false, extraSchemas = [], fileMap = {} } = {}) {
     super();
     this.schemas = [];
     this.path = filePath;
+    this.useNewSchemaGeneration = useNewSchemaGeneration;
+    this.extraSchemas = extraSchemas;
+    this.fileMap = fileMap;
   };
-
+  
   evaluate () {
     const fileExtension = path.extname(this.path).toLowerCase();
 
@@ -109,15 +113,28 @@ class FranchiseSchema extends EventEmitter {
   };
 
   evaluateSchemaXml() {
-    schemaGenerator.eventEmitter.on('schemas:done', (schema) => {
-      this.schema = schema;
-      this.meta = schema.meta;
-      this.schemas = schema.schemas;
-      this.schemaMap = schema.schemaMap;
-      this.emit('schemas:done');
-    });
-
-    schemaGenerator.generate(this.path);
+    if (this.useNewSchemaGeneration) {
+      generateSchemaV2({
+        fileMap: this.fileMap,
+        extraSchemas: this.extraSchemas
+      }).then((schema) => {
+        this.schema = schema;
+        this.meta = schema.meta;
+        this.schemas = schema.schemas;
+        this.schemaMap = schema.schemaMap;
+        this.emit('schemas:done');
+      });
+    } else {
+      schemaGenerator.eventEmitter.on('schemas:done', (schema) => {
+        this.schema = schema;
+        this.meta = schema.meta;
+        this.schemas = schema.schemas;
+        this.schemaMap = schema.schemaMap;
+        this.emit('schemas:done');
+      });
+  
+      schemaGenerator.generate(this.path);
+    }
   };
 };
 

package/README.md

@@ -35,6 +35,7 @@ madden-franchise is a Madden franchise file parser written in NodeJS that allows
 | Madden 23 | ✅ Full |
 | Madden 24 | ✅ Full |
 | Madden 25 | ✅ Full |
+| Madden 26 | 🟡 Everything but CharacterVisuals |
 
 ### Quick Start
 #### Initializing
@@ -65,6 +66,22 @@ madden-franchise is a Madden franchise file parser written in NodeJS that allows
       // AUTO UNEMPTY - specify if you want the system to automatically determine if an empty field should become un-empty once you edit it.
       // Warning: may have unintended side-effects if you batch import. Enable with caution.
       autoUnempty: true/false [default: false]
+
+      // USE NEW SCHEMA GENERATION - use v2 schema generation, may cause issues
+      useNewSchemaGeneration: true/false [default: false]
+
+      // SCHEMA FIELD MAP - used with v2 schema generation - specify all schema input files. Object key should be either `main` to specify the main schema, or the name of the file as specified in the `<IncludeFile>`. Values should be absolute paths to the schema files.
+      schemaFileMap: {
+        main: '/abs/path/to/franchise-schemas.ftx',
+        'core-schemas': '/abs/path/to/core-schemas.ftx',
+        ...
+      }
+
+      // EXTRA SCHEMAS - used with v2 schema generation to specify extra schemas to include other than the defaults. Warning: if these are included, the default extra schemas will NOT be included and vice-versa.
+      extraSchemas: [...]
+
+      // GAME YEAR OVERRIDE - use to override the game year to adjust schema picker logic. Helpful for FTC files and other files that can't auto-detect year accurately.
+      gameYearOverride: number
     }
 
 #### Terminology

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "3.6.0",
+  "version": "3.7.2",
   "description": "Tools to read a madden franchise file and get data from it",
   "main": "FranchiseFile.js",
   "scripts": {
@@ -14,6 +14,7 @@
   "license": "MIT",
   "dependencies": {
     "bit-buffer": "^0.2.5",
+    "fast-xml-parser": "^5.2.5",
     "node-xml-stream-parser": "^1.0.12"
   },
   "repository": {
@@ -22,7 +23,6 @@
   },
   "devDependencies": {
     "chai": "^4.2.0",
-    "chai-eventemitter": "^1.1.1",
     "mocha": "^9.1.4",
     "proxyquire": "^2.1.3",
     "sinon": "^7.5.0",

package/scripts/schema-generator-script-v2.js

@@ -0,0 +1,44 @@
+// USAGE:
+//  node schema-generator-script.js [input file folder] [output file folder] [main schema name] [extra schema path]
+const fs = require('fs/promises');
+const path = require('path');
+const { gzipSync } = require('zlib');
+const { generateSchemaV2 } = require('../services/schemaGeneratorV2');
+
+let done = false;
+
+(async () => {
+    const files = await fs.readdir(process.argv[2], { withFileTypes: true });
+    const schemas = files.filter(f => f.isFile() && f.name.endsWith('.FTX') && f.name !== 'football.FTX');
+    const mainSchemaName = process.argv[4] || 'franchise-schemas.FTX';
+
+    const main = schemas.find(f => f.name === mainSchemaName);
+    const otherSchemas = schemas
+        .filter(f => f.name !== mainSchemaName)
+        .reduce((acc, file) => {
+            const name = file.name.replace(/\.FTX$/i, '');
+            acc[name] = path.join(process.argv[2], file.name);
+            return acc;
+        }, {});
+
+    const schema = await generateSchemaV2({
+        fileMap: {
+            main: path.join(process.argv[2], main.name),
+            ...otherSchemas
+        },
+        extraSchemas: process.argv[5] ? JSON.parse(await fs.readFile(process.argv[5], 'utf8')) : undefined
+    });
+
+    const outputPath = process.argv[3] || __dirname;
+    const compressed = gzipSync(JSON.stringify(schema));
+    await fs.writeFile(path.join(outputPath, `M${schema.meta.gameYear}_${schema.meta.major}_${schema.meta.minor}.gz`), compressed);
+    done = true;
+})();
+
+function wait () {
+    if (!done) {
+        setTimeout(wait, 500);
+    }
+};
+
+wait();

package/services/schemaGeneratorV2.js

@@ -0,0 +1,193 @@
+const fs = require('fs').promises;
+const path = require('path');
+const { XMLParser } = require('fast-xml-parser');
+const FranchiseEnum = require('../FranchiseEnum');
+const utilService = require('./utilService');
+
+/**
+ * Parse FTX schema files with support for IncludeFile dependencies.
+ * @param {{main: string, [id:string]: string}} fileMap - { main: '/abs/path/to/main.FTX', ...otherName: '/abs/path/to/other.FTX' }
+ * @param {Object[]} [extraSchemas] - Optional array of extra schemas to include. If not included, will use defaults.
+ * @returns {Promise<Object>} - Parsed schema object
+ */
+async function generateSchemaV2({ fileMap, extraSchemas }) {
+  const parsedFiles = {};
+  const enums = [];
+  const schemas = [];
+  const schemaMap = {};
+  let schemaMeta = {};
+
+  if (!extraSchemas || extraSchemas.length === 0) {
+    // Load extra schemas if available
+    try {
+      const extraPath = path.join(__dirname, '../data/schemas/extra-schemas.json');
+      const extraRaw = await fs.readFile(extraPath, 'utf8');
+      extraSchemas = JSON.parse(extraRaw);
+    } catch (e) {
+      // ignore if not present
+    }
+  }
+
+  // Recursively parse a file and its includes (async)
+  async function parseFile(fileKey) {
+    if (parsedFiles[fileKey]) return;
+    const filePath = fileMap[fileKey];
+    if (!filePath) throw new Error(`Missing file mapping for: ${fileKey}`);
+    const xml = await fs.readFile(filePath, 'utf8');
+    const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '', allowBooleanAttributes: true, trimValues: false });
+    const doc = parser.parse(xml);
+    const root = doc.FranTkData;
+    if (!schemaMeta.databaseName && root.databaseName) {
+      schemaMeta = {
+        databaseName: root.databaseName,
+        dataMajorVersion: root.dataMajorVersion,
+        dataMinorVersion: root.dataMinorVersion
+      };
+    }
+    // Parse includes first
+    if (root.Includes && root.Includes.IncludeFile) {
+      const includes = Array.isArray(root.Includes.IncludeFile)
+        ? root.Includes.IncludeFile
+        : [root.Includes.IncludeFile];
+      for (const inc of includes) {
+        let incKey = inc.fileName.replace(/\.FTX$/i, '');
+        if (!fileMap[incKey]) {
+          // Try all lowercase
+          incKey = incKey.toLowerCase();
+          if (!fileMap[incKey]) {
+            console.warn(`schemaGeneratorV2: Missing file mapping for include: ${incKey} in ${fileKey}`);
+            continue; // Suppress missing include mapping
+          }
+        }
+        await parseFile(incKey);
+      }
+    }
+    // Parse enums and schemas
+    if (root.schemas) {
+      const items = Object.entries(root.schemas)
+        .flatMap(([tag, val]) => Array.isArray(val) ? val.map(v => ({ tag, ...v })) : [{ tag, ...val }]);
+      for (const item of items) {
+        if (item.tag === 'enum') {
+          const theEnum = new FranchiseEnum(item.name, item.assetId, item.isRecordPersistent);
+          theEnum._members = [];
+          if (item.attribute) {
+            const members = Array.isArray(item.attribute) ? item.attribute : [item.attribute];
+            for (const attr of members) {
+              theEnum.addMember && theEnum.addMember(attr.name, attr.idx, attr.value);
+            }
+          }
+          enums.push(theEnum);
+        } else if (item.tag === 'schema') {
+          const schema = {
+            assetId: item.assetId,
+            ownerAssetId: item.ownerAssetId,
+            numMembers: item.numMembers,
+            name: item.name,
+            base: item.base,
+            attributes: []
+          };
+          if (item.attribute) {
+            const attrs = Array.isArray(item.attribute) ? item.attribute : [item.attribute];
+            for (const attr of attrs) {
+              schema.attributes.push(parseAttribute(attr));
+            }
+          }
+          schemas.push(schema);
+          schemaMap[schema.name] = schema;
+        }
+      }
+    }
+    parsedFiles[fileKey] = true;
+  }
+
+  // Attribute parsing logic (copied from schemaGenerator.js)
+  function parseAttribute(attributeAttributes) {
+    return {
+      index: attributeAttributes.idx,
+      name: attributeAttributes.name,
+      type: attributeAttributes.type,
+      minValue: attributeAttributes.minValue,
+      maxValue: attributeAttributes.maxValue,
+      maxLength: attributeAttributes.maxLen,
+      default: getDefaultValue(attributeAttributes.default),
+      final: attributeAttributes.final,
+      enum: getEnum(attributeAttributes.type),
+      const: attributeAttributes.const
+    };
+    function getDefaultValue(defaultVal) {
+      if (!defaultVal) { return undefined; }
+      // Only replace XML entities, do not trim or modify whitespace at all
+      return defaultVal
+        .replace(/&#xD;/g, '\r')
+        .replace(/&#xA;/g, '\n')
+        .replace(/&amp;/g, '&')
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&quot;/g, '"');
+    }
+  }
+
+  function getEnum(name) {
+    return enums.find(theEnum => theEnum.name === name);
+  }
+
+  function addExtraSchemas() {
+    if (!Array.isArray(extraSchemas)) return;
+    extraSchemas.forEach((schema) => {
+      if (!schemaMap[schema.name]) {
+        schema.attributes.filter((attrib) => {
+          return attrib.enum && !(attrib.enum instanceof FranchiseEnum);
+        }).forEach((attrib) => {
+          attrib.enum = getEnum(attrib.enum);
+        });
+        schemas.unshift(schema);
+      }
+    });
+  }
+
+  function calculateInheritedSchemas(schemaList) {
+    const schemasWithBase = schemaList.filter((schema) => schema.base && schema.base.indexOf('()') === -1);
+    schemasWithBase.forEach((schema) => {
+      if (schema.base && schema.base.indexOf('()') === -1) {
+        schema.originalAttributesOrder = schema.attributes;
+        const baseSchema = schemaList.find((schemaToSearch) => schemaToSearch.name === schema.base);
+        
+        if (baseSchema) {
+          baseSchema.attributes.forEach((baseAttribute, index) => {
+            let oldIndex = schema.attributes.findIndex((schemaAttribute) => schemaAttribute?.name === baseAttribute?.name);
+            utilService.arrayMove(schema.attributes, oldIndex, index);
+          });
+        }
+      }
+    });
+  }
+
+  await parseFile('main');
+  addExtraSchemas();
+  calculateInheritedSchemas(schemas);
+
+  // Set enum member lengths if needed
+  enums.forEach(e => e.setMemberLength && e.setMemberLength());
+
+  // Extract gameYear from databaseName
+  const majorVersion = schemaMeta.dataMajorVersion;
+  const minorVersion = schemaMeta.dataMinorVersion;
+  const databaseName = schemaMeta.databaseName;
+  const gameYearMatch = /Madden(\d{2})/.exec(databaseName);
+  const gameYear = gameYearMatch ? parseInt(gameYearMatch[1]) : null;
+
+  const root = {
+    meta: {
+      major: parseInt(majorVersion),
+      minor: parseInt(minorVersion),
+      gameYear
+    },
+    schemas,
+    schemaMap
+  };
+
+  // Return the plain object
+  return root;
+}
+
+module.exports = { generateSchemaV2 };

package/strategies/StrategyPicker.js

@@ -25,6 +25,7 @@ StrategyPicker.pick = (type) => {
             case 24:
                 return M24Strategy;
             case 25:
+            case 26:
                 return M25Strategy;
         }
     }