madden-franchise 2.3.15 → 2.5.0

package/FranchiseFile.js

@@ -286,6 +286,41 @@ class FranchiseFile extends EventEmitter {
       return null;
     }
   };
+
+  getReferencesToRecord(tableId, recordIndex) {
+    const referencedTable = this.getTableById(tableId);
+
+    if (referencedTable) {
+      const fullBinary = utilService.getBinaryReferenceData(tableId, recordIndex);
+      const hex = utilService.bin2hex(fullBinary).padStart(8, '0');
+  
+      return this.tables.filter((table) => {
+        if (table.schema) {
+          return table.schema && table.schema.attributes.find((attribute) => {
+            return attribute.type === referencedTable.name;
+          });
+        }
+        else if (table.isArray && referencedTable.schema) {
+          // If the referenced table has a schema, we can check its base name.
+          // Some array table names are by the base name like EnumTable[] can contain AwardTypeEnumTableEntry
+
+          return table.name.slice(0, table.name.length - 2) === referencedTable.name
+            || table.name.slice(0, table.name.length - 2) === referencedTable.schema.base;
+        }
+        else if (table.isArray) {
+          return table.name.slice(0, table.name.length - 2) === referencedTable.name;
+        }
+      }).filter((table) => {
+        return table.data.indexOf(hex, 0, 'hex') !== -1;
+      }).map((table) => {
+        return {
+          tableId: table.header.tableId,
+          name: table.name,
+          table: table
+        }
+      });
+    }
+  };
 };
 
 module.exports = FranchiseFile;

package/FranchiseFileTable.js

@@ -44,6 +44,10 @@ class FranchiseFileTable extends EventEmitter {
   get schema () {
     return this._schema;
   };
+
+  getBinaryReferenceToRecord(index) {
+    return utilService.getBinaryReferenceData(this.header.tableId, index);
+  };
   
   updateBuffer() {
     // need to check table2 data first because it may change offsets of the legit records.
@@ -592,7 +596,7 @@ function readOffsetTable(data, schema, header) {
         'originalIndex': parseInt(attribute.index),
         'name': attribute.name,
         'type': (minValue < 0 || maxValue < 0) ? 's_' + attribute.type : attribute.type,
-        'isReference': !attribute.enum && (attribute.type[0] == attribute.type[0].toUpperCase() || attribute.type.includes('[]')) ? true : false,
+        'isReference': !attribute.enum && (attribute.type[0] == attribute.type[0].toUpperCase() || attribute.type.includes('[]') || attribute.type === 'record') ? true : false,
         'valueInSecondTable': header.hasSecondTable && attribute.type === 'string',
         'isSigned': minValue < 0 || maxValue < 0,
         'minValue': minValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "2.3.15",
+  "version": "2.5.0",
   "description": "Tools to read a madden franchise file and get data from it",
   "main": "FranchiseFile.js",
   "scripts": {
@@ -13,7 +13,7 @@
   "author": "matthewpanetta",
   "license": "MIT",
   "dependencies": {
-    "xml-stream": "^0.4.5"
+    "node-xml-stream-parser": "^1.0.12"
   },
   "repository": {
     "type": "git",
@@ -22,7 +22,7 @@
   "devDependencies": {
     "chai": "^4.2.0",
     "chai-eventemitter": "^1.1.1",
-    "mocha": "^6.2.2",
+    "mocha": "^9.1.4",
     "proxyquire": "^2.1.3",
     "sinon": "^7.5.0"
   }

package/services/schemaGenerator.js

@@ -1,14 +1,12 @@
-// USAGE:
-//  node schema-generator.js [input file path] [output file folder]
-
 const fs = require('fs');
 const path = require('path');
 const zlib = require('zlib');
-const XmlStream = require('xml-stream');
+const { pipeline } = require('stream');
 const utilService = require('./utilService');
 const FranchiseEnum = require('../FranchiseEnum');
+const XmlParser = require('node-xml-stream-parser');
 const EventEmitter = require('events').EventEmitter;
-const extraSchemas = require('../data/schemas/extra-schemas.json');
+const extraSchemas = JSON.parse(JSON.stringify(require(path.join(__dirname, '../data/schemas/extra-schemas.json'))));
 
 let schemaGenerator = {};
 schemaGenerator.eventEmitter = new EventEmitter();
@@ -22,101 +20,144 @@ schemaGenerator.generateFromStream = (stream, showOutput, outputFile) => {
   schemaGenerator.root = {}
   schemaGenerator.schemas = [];
   schemaGenerator.schemaMap = {};
+  schemaGenerator.schemaMeta = {};
   schemaGenerator.enums = [];
 
-  schemaGenerator.xml = new XmlStream(stream);
+  schemaGenerator.xml = new XmlParser();
 
-  schemaGenerator.xml.collect('attribute');
+  pipeline(
+    stream,
+    schemaGenerator.xml,
+    (err) => {
+      if (err) {
+        console.error(err);
+        throw err;
+      }
 
-  schemaGenerator.xml.on('endElement: FranTkData', function (data) {
-    const majorVersion = data.$.dataMajorVersion;
-    const minorVersion = data.$.dataMinorVersion;
-    const databaseName = data.$.databaseName;
-    const gameYear = /Madden(\d{2})/.exec(databaseName)[1];
+      schemaGenerator.enums.forEach((theEnum) => {
+        theEnum.setMemberLength();
+      });
 
-    addExtraSchemas();
-    calculateInheritedSchemas();
+      const majorVersion = schemaGenerator.schemaMeta.dataMajorVersion;
+      const minorVersion = schemaGenerator.schemaMeta.dataMinorVersion;
+      const databaseName = schemaGenerator.schemaMeta.databaseName;
 
-    schemaGenerator.root = {
-      'meta': {
-        'major': parseInt(majorVersion),
-        'minor': parseInt(minorVersion),
-        'gameYear': parseInt(gameYear)
-      },
-      'schemas': schemaGenerator.schemas,
-      'schemaMap': schemaGenerator.schemaMap
-    };
+      const gameYear = /Madden(\d{2})/.exec(databaseName)[1];
 
-    if (outputFile) {
-      zlib.gzip(JSON.stringify(schemaGenerator.root), function (_, data) {
-        fs.writeFileSync(`${outputFile}\\${majorVersion}_${minorVersion}.gz`, data);
-      });
+      addExtraSchemas();
+      calculateInheritedSchemas();
+
+      schemaGenerator.root = {
+        'meta': {
+          'major': parseInt(majorVersion),
+          'minor': parseInt(minorVersion),
+          'gameYear': parseInt(gameYear)
+        },
+        'schemas': schemaGenerator.schemas,
+        'schemaMap': schemaGenerator.schemaMap
+      };
+
+      if (outputFile) {
+        zlib.gzip(JSON.stringify(schemaGenerator.root), function (_, data) {
+          fs.writeFileSync(`${outputFile}\\${majorVersion}_${minorVersion}.gz`, data);
+        });
+      }
+
+      schemaGenerator.eventEmitter.emit('schemas:done', schemaGenerator.root);
     }
+  );
 
-    schemaGenerator.eventEmitter.emit('schemas:done', schemaGenerator.root);
-  });
+  let currentParent = {
+    type: '',
+    ref: null
+  };
 
-  schemaGenerator.xml.on('endElement: enum', function (theEnum) {
-    if (showOutput) console.log(`Adding enum ${theEnum.$.name}`);
+  schemaGenerator.xml.on('opentag', (name, attrs) => {
+    if (name === 'FranTkData') {
+      schemaGenerator.schemaMeta.databaseName = attrs.databaseName;
+      schemaGenerator.schemaMeta.dataMajorVersion = attrs.dataMajorVersion;
+      schemaGenerator.schemaMeta.dataMinorVersion = attrs.dataMinorVersion;
+    }
 
-    let newEnum = new FranchiseEnum(theEnum.$.name, theEnum.$.assetId, theEnum.$.isRecordPersistent);
+    else if (name === 'enum') {
+      let theEnum = parseEnum(attrs);
+      schemaGenerator.enums.push(theEnum);
 
-    if (theEnum.attribute) {
-      theEnum.attribute.forEach((attribute) => {
-        newEnum.addMember(attribute.$.name, attribute.$.idx, attribute.$.value);
-      });
+      currentParent = {
+        type: 'enum',
+        ref: theEnum
+      }
     }
 
-    newEnum.setMemberLength();
-    schemaGenerator.enums.push(newEnum);
-  });
+    else if (name === 'schema') {
+      let schema = parseSchema(attrs);
+      schema.attributes = [];
 
-  schemaGenerator.xml.on('endElement: schema', function (schema) {
-    if (showOutput) console.log(`Adding schema ${schema.$.name}`);
-    let attributes = [];
-    
-    if (schema.attribute) {
-      attributes = schema.attribute.map((attribute) => {
-        return {
-          'index': attribute.$.idx,
-          'name': attribute.$.name,
-          'type': attribute.$.type,
-          'minValue': attribute.$.minValue,
-          'maxValue': attribute.$.maxValue,
-          'maxLength': attribute.$.maxLen,
-          'default': attribute.$.default,
-          'final': attribute.$.final,
-          'enum': getEnum(attribute.$.type),
-          'const': attribute.$.const
-        }
-      });
+      schemaGenerator.schemas.push(schema);
+      schemaGenerator.schemaMap[schema.name] = schema;
+      
+      currentParent = {
+        type: 'schema',
+        ref: schema
+      }
+    }
+
+    else if (name === 'attribute') {
+      if (currentParent.type === 'enum') {
+        currentParent.ref.addMember(attrs.name, attrs.idx, attrs.value);
+      }
+      else {
+        const attribute = parseAttribute(attrs);
+        currentParent.ref.attributes.push(attribute);
+      }
     }
+  });
+
+  function parseEnum(enumAttributes) {
+    return new FranchiseEnum(enumAttributes.name, enumAttributes.assetId, enumAttributes.isRecordPersistent);
+  };
 
-    const element = {
-      'assetId': schema.$.assetId,
-      'ownerAssetId': schema.$.ownerAssetId,
-      'numMembers': schema.$.numMembers,
-      'name': schema.$.name,
-      'base': schema.$.base,
-      'attributes': attributes
+  function parseSchema(schemaAttributes) {
+    return {
+      'assetId': schemaAttributes.assetId,
+      'ownerAssetId': schemaAttributes.ownerAssetId,
+      'numMembers': schemaAttributes.numMembers,
+      'name': schemaAttributes.name,
+      'base': schemaAttributes.base
     };
+  };
+
+  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
+    }
 
-    schemaGenerator.schemas.push(element);
-    schemaGenerator.schemaMap[element.name] = element;
+    function getDefaultValue(defaultVal) {
+      if (!defaultVal) { return undefined; }
 
-    if (element.name === 'WinLossStreakPlayerGoal') {
-      // calculateInheritedSchemas();
-      // // fs.writeFileSync(outputFile, JSON.stringify(schemaGenerator.schemas));
-      // zlib.gzip(JSON.stringify(schemaGenerator.schemas), function (_, data) {
-      //   fs.writeFileSync(outputFile, data);
-      // });
-      // schemaGenerator.emit('schemas:done', schemaGenerator.schemas);
+      defaultVal = defaultVal
+        .replace(new RegExp('
', 'g'), '\r')
+        .replace(new RegExp('
', 'g'), '\n')
+        .replace(new RegExp('&', 'g'), '&')
+        .replace(new RegExp('>', 'g'), '>')
+        .replace(new RegExp('&lt;', 'g'), '<')
+        .replace(new RegExp('&quot;', 'g'), '\"')
+
+      return defaultVal;
     }
-  });
+  };
 
   function addExtraSchemas() {
     extraSchemas.forEach((schema) => {
-
       if (!schemaGenerator.schemaMap[schema.name]) {
         schema.attributes.filter((attrib) => { 
           return attrib.enum && !(attrib.enum instanceof FranchiseEnum);