madden-franchise 2.3.6 → 2.3.10

package/FranchiseFileTable.js

@@ -86,11 +86,7 @@ class FranchiseFileTable extends EventEmitter {
   };
 
   setNextRecordToUse(index, resetEmptyRecordMap) {
-    // We need to update the table header to use this row next
-    this.header.nextRecordToUse = index;
-
-    // And finally update the buffer to reflect this change
-    this.data.writeUInt32BE(index, this.header.headerOffset - 4);
+    this._setNextRecordToUseBuffer(index);
 
     // Recalculate the empty record map if the option is set and the
     // records have already been read.
@@ -98,6 +94,70 @@ class FranchiseFileTable extends EventEmitter {
       this.updateBuffer();
       this.emptyRecords = this._parseEmptyRecords();
     }
+
+    this.emit('change');
+  };
+
+  _setNextRecordToUseBuffer(index) {
+    // We need to update the table header to use this row next
+    this.header.nextRecordToUse = index;
+
+    // And finally update the buffer to reflect this change
+    this.data.writeUInt32BE(index, this.header.offsetStart - 4);
+  };
+
+  recalculateEmptyRecordReferences() {
+    // For this method, we are not going to assume any existing empty records.
+    // We're going through each record and checking if it is an empty reference.
+    // If so, we'll add it to the list. At the end we will check if there are any unreachable empty references
+    // and update those accordingly.
+    let emptyRecordReferenceIndicies = [];
+
+    this.records.forEach((record) => {
+      let isEmptyReference = false;
+      const firstFourBytesReference = utilService.getReferenceData(record._data.slice(0, 32));
+
+      if (firstFourBytesReference.tableId === 0 && firstFourBytesReference.rowNumber !== 0) {
+        // Could be a an empty record reference or a table2 field.
+        // Check for a table2 field reference.
+        const firstOffset = this.offsetTable[0];
+        if (firstOffset.type !== 'string') {
+          isEmptyReference = true;
+
+          // Save the row number that this record points to.
+          emptyRecordReferenceIndicies.push(firstFourBytesReference.rowNumber);
+        }
+      }
+
+      record.isEmpty = isEmptyReference;
+    });
+
+    // We need to determine the starting node.
+    // To do that, we need to find the empty record which no other empty record points to.
+    const unreachableRecords = this.records.filter((record) => { return record.isEmpty; }).filter((record) => {
+      return emptyRecordReferenceIndicies.indexOf(record.index) === -1;
+    });
+
+    // If there are more than 1 nodes which are not referenced, there is an issue
+    if (unreachableRecords.length > 1) {
+      const unreachableIndicies = unreachableRecords.map((record) => {
+        return record.index;
+      });
+
+      console.warn(`(${this.header.tableId}) ${this.name} - More than one unreachable records found: `
+      + `(${unreachableIndicies.join(', ')}). The game will most likely crash if you do not fix this problem. `
+      + `The nextRecordToUse has NOT been updated.`);
+    }
+    else {
+      let nextRecordToUse = this.header.recordCapacity;
+
+      if (unreachableRecords.length === 1) {
+        nextRecordToUse = unreachableRecords[0].index;
+      }
+
+      this._setNextRecordToUseBuffer(nextRecordToUse);
+      this.emptyRecords = this._parseEmptyRecords();
+    }
   };
 
   // attribsToLoad is an array of attribute names (strings) to load. It is optional - if nothing is provided to the function it will load all attributes.
@@ -142,8 +202,7 @@ class FranchiseFileTable extends EventEmitter {
           reject('Cannot read records: Schema is not defined.');
         }
         
-        this.emptyRecords = this._parseEmptyRecords();
-
+        
         let offsetTableToUse = this.offsetTable;
         const mandatoryOffsetsToLoad = this.strategy.getMandatoryOffsets(this.offsetTable);
         
@@ -151,18 +210,20 @@ class FranchiseFileTable extends EventEmitter {
           // get any new attributes to load plus the existing loaded offsets
           offsetTableToUse = offsetTableToUse.filter((attrib) => { 
             return mandatoryOffsetsToLoad.includes(attrib.name)
-              || attribsToLoad.includes(attrib.name) 
-              || this.loadedOffsets.find((offset) => { return offset.name === attrib.name; }); 
+            || attribsToLoad.includes(attrib.name) 
+            || this.loadedOffsets.find((offset) => { return offset.name === attrib.name; }); 
           });
         }
-
+        
         this.loadedOffsets = offsetTableToUse;
         this.records = readRecords(this.data, this.header, offsetTableToUse);
-
+        
         if (this.header.hasSecondTable) {
           this._parseTable2Values(this.data, this.header, this.records);
         }
 
+        this.emptyRecords = this._parseEmptyRecords();
+
         this.records.forEach((record, index) => {
           if (this.isArray) {
             record.arraySize = this.arraySizes[index];
@@ -247,14 +308,6 @@ class FranchiseFileTable extends EventEmitter {
                   }
                 }
               }
-              else {
-                // The field was not empty, let's check if it is now
-                const referenceData = utilService.getReferenceData(this._data.slice(0, 32));
-                if (referenceData.tableId === 0) {
-                  // In this case, the record is now empty. Add an entry to the empty record map
-                  // onRecordEmpty(this);
-                }
-              }
             }
 
             that.emit('change');
@@ -364,9 +417,10 @@ class FranchiseFileTable extends EventEmitter {
     let previousEmptyRecordIndex = null;
     let currentEmptyRecordIndex = firstEmptyRecord;
 
-    if (this.header.nextRecordToUse !== this.header.recordCapacity) {
+    if (firstEmptyRecord !== this.header.recordCapacity) {
       while (currentEmptyRecordIndex !== this.header.recordCapacity) {
-        let nextEmptyRecordIndex = this.data.readUInt32BE(this.header.table1StartIndex + (currentEmptyRecordIndex * sizeOfEachRecord));
+        // let nextEmptyRecordIndex = this.data.readUInt32BE(this.header.table1StartIndex + (currentEmptyRecordIndex * sizeOfEachRecord));
+        let nextEmptyRecordIndex = utilService.getReferenceData(this.records[currentEmptyRecordIndex]._data.slice(0, 32)).rowNumber;
 
         emptyRecords.set(currentEmptyRecordIndex, {
           previous: previousEmptyRecordIndex,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "2.3.6",
+  "version": "2.3.10",
   "description": "Tools to read a madden franchise file and get data from it",
   "main": "FranchiseFile.js",
   "scripts": {

package/scripts/deflate.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const zlib = require('zlib');
 
-const filePath = 'D:\\Projects\\Madden 22\\Expressions\\franchise-expressions-binary.frt';
+const filePath = 'D:\\Projects\\Madden 22\\Expressions\\sabo-expression-binary.frt';
 const outputPath = 'D:\\Projects\\Madden 22\\Expressions\\modified-Franchise-Expression-binary.FTC'
 
 const stream = fs.createReadStream(filePath)

package/strategies/common/CommonAlgorithms.js

@@ -13,6 +13,9 @@ CommonAlgorithms.save = (units, oldData) => {
     let oldOffsetCounter = 0;
     let bufferArrays = [];
 
+    // Ensure the units are sorted by index in the actual file. Otherwise, we may overwrite data
+    units.sort((a, b) => { return a.index - b.index; });
+
     units.forEach((unit, index) => {
         if (unit.offset === 0 && index > 0) {
             // there are usually trailing records at the end of the table that reference

package/strategies/common/table/FranchiseTableStrategy.js

@@ -3,7 +3,8 @@ let FranchiseTableStrategy = {};
 FranchiseTableStrategy.getTable2BinaryData = (table2Records, fullTable2Buffer) => {
     let table2Data = [];
 
-    const changedTable2Records = table2Records.filter((record) => { return record.isChanged; });
+    // Make sure to sort the table2 records by index
+    const changedTable2Records = table2Records.filter((record) => { return record.isChanged; }).sort((a, b) => { return a.index - b.index; });
     let currentOffset = 0;
 
     for (let i = 0; i < changedTable2Records.length; i++) {