madden-franchise 2.3.3 → 2.3.7

package/FranchiseFileField.js

@@ -68,7 +68,7 @@ class FranchiseFileField extends EventEmitter {
     this.emit('change');
   };
 
-  setUnformattedValueWithoutChangeEvent(unformattedValue) {
+  setUnformattedValueWithoutChangeEvent(unformattedValue, suppressErrors) {
     if (!utilService.isString(unformattedValue)) { throw new Error(`Argument must be of type string. You passed in a ${typeof unformattedValue}.`); }
     else if (!utilService.stringOnlyContainsBinaryDigits(unformattedValue)) { throw new Error(`Argument must only contain binary digits 1 and 0. If you would like to set the value, please set the 'value' attribute instead.`)}
     else {
@@ -82,7 +82,7 @@ class FranchiseFileField extends EventEmitter {
       }
 
       // check for 'allowed' error - this will be true if the unformatted value is invalid.
-      if (this._offset.enum && value === unformattedValue.padStart(this._offset.length, '0')) {
+      if (this._offset.enum && value === unformattedValue.padStart(this._offset.length, '0') && !suppressErrors) {
         throw new Error(`Argument is not a valid unformatted value for this field. You passed in ${value}.`)
       }
 

package/FranchiseFileTable.js

@@ -25,6 +25,27 @@ class FranchiseFileTable extends EventEmitter {
   };
 
   get hexData () {
+    this.updateBuffer();
+    return this.data;
+  };
+
+  set schema (schema) {
+    // console.time('set schema');
+    this._schema = schema;
+    const modifiedHeaderAttributes = this.strategy.parseHeaderAttributesFromSchema(schema, this.data, this.header);
+
+    this.header.headerSize = modifiedHeaderAttributes.headerSize;
+    this.header.record1Size = modifiedHeaderAttributes.record1Size;
+    this.header.table1StartIndex = modifiedHeaderAttributes.table1StartIndex;
+    this.header.table2StartIndex = modifiedHeaderAttributes.table2StartIndex;
+    // console.timeEnd('set schema');
+  };
+
+  get schema () {
+    return this._schema;
+  };
+  
+  updateBuffer() {
     // need to check table2 data first because it may change offsets of the legit records.
     const table2Data = this.strategy.getTable2BinaryData(this.table2Records, this.data.slice(this.header.table2StartIndex));
 
@@ -62,23 +83,23 @@ class FranchiseFileTable extends EventEmitter {
     bufferArrays = bufferArrays.concat(table2Data);
 
     this.data = Buffer.concat(bufferArrays);
-    return this.data;
   };
 
-  set schema (schema) {
-    // console.time('set schema');
-    this._schema = schema;
-    const modifiedHeaderAttributes = this.strategy.parseHeaderAttributesFromSchema(schema, this.data, this.header);
+  setNextRecordToUse(index, resetEmptyRecordMap) {
+    // We need to update the table header to use this row next
+    this.header.nextRecordToUse = index;
 
-    this.header.headerSize = modifiedHeaderAttributes.headerSize;
-    this.header.record1Size = modifiedHeaderAttributes.record1Size;
-    this.header.table1StartIndex = modifiedHeaderAttributes.table1StartIndex;
-    this.header.table2StartIndex = modifiedHeaderAttributes.table2StartIndex;
-    // console.timeEnd('set schema');
-  };
+    // And finally update the buffer to reflect this change
+    this.data.writeUInt32BE(index, this.header.headerOffset - 4);
 
-  get schema () {
-    return this._schema;
+    // Recalculate the empty record map if the option is set and the
+    // records have already been read.
+    if (resetEmptyRecordMap && this.recordsRead) {
+      this.updateBuffer();
+      this.emptyRecords = this._parseEmptyRecords();
+    }
+
+    this.emit('change');
   };
 
   // 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.
@@ -154,6 +175,7 @@ class FranchiseFileTable extends EventEmitter {
           }
 
           const that = this;
+
           record.on('change', function (changedOffset) {
             this.isChanged = true;
 
@@ -215,7 +237,7 @@ class FranchiseFileTable extends EventEmitter {
                     if (!previousEmptyReference) {
                       // If no previous empty record exists and a next record exists, we need to update the header to
                       // point to this record as the next record to use.
-                      updateNextRecordToUseHeaderAndBuffer(emptyRecordReference.next);
+                      that.setNextRecordToUse(emptyRecordReference.next);
                     }
                   }
     
@@ -223,7 +245,28 @@ class FranchiseFileTable extends EventEmitter {
                   // Then there are no more empty references in the table
                   // Update the table header nextRecordToUse back to the table record capacity
                   if (!previousEmptyReference && !nextEmptyReference) {
-                    updateNextRecordToUseHeaderAndBuffer(that.header.recordCapacity);
+                    that.setNextRecordToUse(that.header.recordCapacity);
+                  }
+                }
+              }
+              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) {
+                  // The record has a reference to table id 0, now we need to see if its referencing the 0th record or not
+                  // We have to be careful not to mistake a null reference for an empty reference to record 0
+                  if (referenceData.rowNumber !== 0) {
+                    // If the value is referencing a row number greater than 0, we need to treat this record as an empty reference.
+                    // onRecordEmpty(record);
+                  }
+                  else {
+                    // The record was updated to either be a null reference or an empty record reference to row 0.
+                    // First let's make sure we aren't editing row 0...if we are, then the value is a null reference
+                    // because a record cannot point to itself.
+                    if (this.index > 0) {
+                      // Now that we know that the edit isn't coming from row 0, let's check if row 0 is an empty reference.
+                      // If it is NOT an empty reference, then the updated value is not an empty reference.
+                    }
                   }
                 }
               }
@@ -233,10 +276,14 @@ class FranchiseFileTable extends EventEmitter {
           });
 
           record.on('empty', function () {
+            onRecordEmpty(this);
+          });
+
+          function onRecordEmpty(record) {
             // First, check if the record is already empty. If so, don't do anything...
             // If not empty, then we need to empty it.
-            if (!this.isEmpty) {
-              this.isChanged = true;
+            if (!record.isEmpty) {
+              record.isChanged = true;
               const lastEmptyRecordMapEntry = Array.from(that.emptyRecords).pop();
   
               // When we empty a record, we need to check if another empty record exists in the table.
@@ -248,11 +295,11 @@ class FranchiseFileTable extends EventEmitter {
   
                 that.emptyRecords.set(lastEmptyRecordIndex, {
                   previous: lastEmptyRecordMapEntry[1].previous,
-                  next: this.index
+                  next: record.index
                 });
   
                 // Then we need to update the current record index to point to the record capacity.
-                that.emptyRecords.set(this.index, {
+                that.emptyRecords.set(record.index, {
                   previous: lastEmptyRecordIndex,
                   next: that.header.recordCapacity
                 });
@@ -263,32 +310,24 @@ class FranchiseFileTable extends EventEmitter {
   
                 // And update both record's data. This will set the unformatted and formatted values
                 // without emitting an event
-                changeRecordBuffers(lastEmptyRecordIndex, this.index);
-                changeRecordBuffers(this.index, that.header.recordCapacity);
+                changeRecordBuffers(lastEmptyRecordIndex, record.index);
+                changeRecordBuffers(record.index, that.header.recordCapacity);
               }
               else {
                 // In this case, the record that was emptied is the first empty record in the table
-                that.emptyRecords.set(this.index, {
+                that.emptyRecords.set(record.index, {
                   previous: null,
                   next: that.header.recordCapacity
                 });
   
                 // Finally update the table header and buffer so that the game uses this new empty
                 // record as the next record to use (or fill)
-                updateNextRecordToUseHeaderAndBuffer(this.index);
-                changeRecordBuffers(this.index, that.header.recordCapacity);
+                that.setNextRecordToUse(record.index);
+                changeRecordBuffers(record.index, that.header.recordCapacity);
               }
               
               that.emit('change');
             }
-          });
-
-          function updateNextRecordToUseHeaderAndBuffer(nextRecordToUse) {
-            // We need to update the table header to use this row next
-            that.header.nextRecordToUse = nextRecordToUse;
-
-            // And finally update the buffer to reflect this change
-            that.data.writeUInt32BE(nextRecordToUse, that.header.headerOffset - 4);
           };
 
           function changeRecordBuffers(index, emptyRecordReference) {
@@ -299,7 +338,7 @@ class FranchiseFileTable extends EventEmitter {
           function setBufferToEmptyRecordReference(index, emptyRecordReference) {
             const recordStartIndex = that.header.table1StartIndex + (index * that.header.record1Size)
             that.data.writeUInt32BE(emptyRecordReference, recordStartIndex);
-            that.data.fill(0, recordStartIndex + 4, recordStartIndex + that.header.record1Size);
+            // that.data.fill(0, recordStartIndex + 4, recordStartIndex + that.header.record1Size);
           };
 
           function setRecordInternalBuffer(index, emptyRecordReference) {
@@ -307,7 +346,7 @@ class FranchiseFileTable extends EventEmitter {
 
             const recordSizeInBits = that.header.record1Size * 8;
             if (recordSizeInBits > 32) {
-              newData += utilService.dec2bin(0, recordSizeInBits - 32);
+              newData += that.records[index]._data.slice(32);
             }
 
             that.records[index].data = newData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "2.3.3",
+  "version": "2.3.7",
   "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++) {