madden-franchise 2.2.7 → 2.3.3

package/FranchiseFileField.js

@@ -64,6 +64,11 @@ class FranchiseFileField extends EventEmitter {
   };
 
   set unformattedValue (unformattedValue) {
+    this.setUnformattedValueWithoutChangeEvent(unformattedValue);
+    this.emit('change');
+  };
+
+  setUnformattedValueWithoutChangeEvent(unformattedValue) {
     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 {
@@ -89,10 +94,8 @@ class FranchiseFileField extends EventEmitter {
       else {
         this._unformattedValue = unformattedValue;
       }
-
-      this.emit('change');
     }
-  };
+  }
 };
 
 module.exports = FranchiseFileField;

package/FranchiseFileRecord.js

@@ -11,6 +11,7 @@ class FranchiseFileRecord extends EventEmitter {
     this._fields = parseRecordFields(data, offsetTable);
     this.isChanged = false;
     this.arraySize = null;
+    this.isEmpty = false;
 
     const that = this;
     this._fields.forEach((field) => {
@@ -58,6 +59,19 @@ class FranchiseFileRecord extends EventEmitter {
     return Buffer.from(utilService.binaryBlockToDecimalBlock(this._data));
   };
 
+  get fields () {
+    return this._fields;
+  };
+
+  set data (data) {
+    this._data = data;
+
+    this._fields.forEach((field) => {
+      const unformattedValue = data.slice(field.offset.offset, field.offset.offset + field.offset.length);
+      field.setUnformattedValueWithoutChangeEvent(unformattedValue);
+    });
+  };
+
   getFieldByKey(key) {
     return this._fields.find((field) => { return field.key === key; });
   };
@@ -72,8 +86,9 @@ class FranchiseFileRecord extends EventEmitter {
     return field ? field.referenceData : null;
   };
 
-  get fields () {
-    return this._fields;
+  empty() {
+    this.emit('empty');
+    this.isEmpty = true;
   };
 };
 

package/FranchiseFileTable.js

@@ -1,4 +1,3 @@
-const assert = require('assert');
 const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 const FranchiseFileRecord = require('./FranchiseFileRecord');
@@ -22,6 +21,7 @@ class FranchiseFileTable extends EventEmitter {
     this.records = [];
     this.table2Records = [];
     this.arraySizes = [];
+    this.emptyRecords = new Map();
   };
 
   get hexData () {
@@ -122,9 +122,10 @@ class FranchiseFileTable extends EventEmitter {
         } else {
           reject('Cannot read records: Schema is not defined.');
         }
+        
+        this.emptyRecords = this._parseEmptyRecords();
 
         let offsetTableToUse = this.offsetTable;
-
         const mandatoryOffsetsToLoad = this.strategy.getMandatoryOffsets(this.offsetTable);
         
         if (attribsToLoad) {
@@ -148,12 +149,169 @@ class FranchiseFileTable extends EventEmitter {
             record.arraySize = this.arraySizes[index];
           }
 
+          if (this.emptyRecords.get(index)) {
+            record.isEmpty = true;
+          }
+
           const that = this;
           record.on('change', function (changedOffset) {
             this.isChanged = true;
-            that.arraySizes[index] = this.arraySize;
+
+            if (that.isArray) {
+              that.arraySizes[index] = this.arraySize;
+            }
+
+            // When a record changes, we need to check if it was previously empty
+            // If so, we need to consider the record as no longer empty
+            // So we need to adjust the empty records
+
+            // First, check if the record's length is greater than 4 bytes (32 bits)
+            // If less than 4 bytes, it can never become empty...probably. :)
+            if (that.header.record1Size >= 4) {
+              
+              // Ex: Empty record list looks like this: A -> B -> C
+              // When B's value is changed, the records need updated to: A -> C
+              const emptyRecordReference = that.emptyRecords.get(this.index);
+              const changedRecordWasEmpty = emptyRecordReference !== null && emptyRecordReference !== undefined;
+  
+              if (changedRecordWasEmpty) {
+                // Check if the record's first four bytes still have a reference to the 0th table.
+                // If so, then the record is still considered empty.
+                
+                // We need to check the buffer because the first field is not always a reference.
+                const referenceData = utilService.getReferenceData(this._data.slice(0, 32));
+                if (referenceData.tableId !== 0) {
+
+                  // Delete the empty record entry because it is no longer empty
+                  that.emptyRecords.delete(this.index);
+    
+                  // Set the isEmpty back to false because it's no longer empty
+                  this.isEmpty = false;
+    
+                  // Check if there is a previous empty record
+                  const previousEmptyReference = that.emptyRecords.get(emptyRecordReference.previous);
+    
+                  if (previousEmptyReference) {
+                    // Set the previous empty record to point to the old reference's next node
+                    that.emptyRecords.set(emptyRecordReference.previous, {
+                      previous: that.emptyRecords.get(emptyRecordReference.previous).previous,
+                      next: emptyRecordReference.next
+                    });
+    
+                    // change the table buffer and record buffer to reflect this change
+                    changeRecordBuffers(emptyRecordReference.previous, emptyRecordReference.next);
+                  }
+    
+                  // If there is a next empty reference, update the previous value accordingly to now point
+                  // to the current record's previous index.
+                  const nextEmptyReference = that.emptyRecords.get(emptyRecordReference.next);
+    
+                  if (nextEmptyReference) {
+                    that.emptyRecords.set(emptyRecordReference.next, {
+                      previous: emptyRecordReference.previous,
+                      next: that.emptyRecords.get(emptyRecordReference.next).next
+                    });
+    
+                    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);
+                    }
+                  }
+    
+                  // If there are no previous or next empty references
+                  // 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.emit('change');
           });
+
+          record.on('empty', function () {
+            // 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;
+              const lastEmptyRecordMapEntry = Array.from(that.emptyRecords).pop();
+  
+              // When we empty a record, we need to check if another empty record exists in the table.
+              if (lastEmptyRecordMapEntry !== null && lastEmptyRecordMapEntry !== undefined) {
+  
+                // If an empty record already exists, we just need to get the last empty record
+                // and update its index to point to the current record that we want to empty.
+                const lastEmptyRecordIndex = lastEmptyRecordMapEntry[0];
+  
+                that.emptyRecords.set(lastEmptyRecordIndex, {
+                  previous: lastEmptyRecordMapEntry[1].previous,
+                  next: this.index
+                });
+  
+                // Then we need to update the current record index to point to the record capacity.
+                that.emptyRecords.set(this.index, {
+                  previous: lastEmptyRecordIndex,
+                  next: that.header.recordCapacity
+                });
+  
+                // Finally, we need to update the buffers to reflect this data.
+                // First, place the new referenced index (will be the first 4 bytes)
+                // Next, fill the rest of the record with 0s (the last bytes of the record)
+  
+                // 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);
+              }
+              else {
+                // In this case, the record that was emptied is the first empty record in the table
+                that.emptyRecords.set(this.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.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) {
+            setBufferToEmptyRecordReference(index, emptyRecordReference);
+            setRecordInternalBuffer(index, emptyRecordReference);
+          };
+
+          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);
+          };
+
+          function setRecordInternalBuffer(index, emptyRecordReference) {
+            let newData = utilService.dec2bin(emptyRecordReference, 32);
+
+            const recordSizeInBits = that.header.record1Size * 8;
+            if (recordSizeInBits > 32) {
+              newData += utilService.dec2bin(0, recordSizeInBits - 32);
+            }
+
+            that.records[index].data = newData;
+          };
         });
 
         this.table2Records.forEach((record, index) => {
@@ -173,6 +331,33 @@ class FranchiseFileTable extends EventEmitter {
     });
   };
 
+  _parseEmptyRecords() {
+    const firstEmptyRecord = this.header.nextRecordToUse;
+    const sizeOfEachRecord = this.header.record1Size;
+    
+    let emptyRecords = new Map();
+
+    let previousEmptyRecordIndex = null;
+    let currentEmptyRecordIndex = firstEmptyRecord;
+
+    if (this.header.nextRecordToUse !== this.header.recordCapacity) {
+      while (currentEmptyRecordIndex !== this.header.recordCapacity) {
+        let nextEmptyRecordIndex = this.data.readUInt32BE(this.header.table1StartIndex + (currentEmptyRecordIndex * sizeOfEachRecord));
+
+        emptyRecords.set(currentEmptyRecordIndex, {
+          previous: previousEmptyRecordIndex,
+          next: nextEmptyRecordIndex
+        });
+
+        previousEmptyRecordIndex = currentEmptyRecordIndex;
+        currentEmptyRecordIndex = nextEmptyRecordIndex;
+      }
+    }
+
+    return emptyRecords;
+  };
+
+
   _parseTable2Values(data, header, records) {
     const that = this;
     const secondTableData = data.slice(header.table2StartIndex);

package/package.json

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

package/strategies/common/header/m19/M19TableHeaderStrategy.js

@@ -45,7 +45,7 @@ M19TableHeaderStrategy.parseHeader = (data) => {
     const data2RecordCapacity = data.readUInt32BE(headerOffset+48);
     const data2IndexEntries = data.readUInt32BE(headerOffset+52);
     const unknown4 = data.readUInt32BE(headerOffset+56);
-    const data2RecordCount = data.readUInt32BE(headerOffset+60);
+    const nextRecordToUse = data.readUInt32BE(headerOffset+60);
 
     let offsetStart = 0xE4 + tableStoreLength;
     const hasSecondTable = tableTotalLength > table1Length;
@@ -95,10 +95,10 @@ M19TableHeaderStrategy.parseHeader = (data) => {
         'hasSecondTable': hasSecondTable,
         'table1StartIndex': tableStoreLength === 0 && !isArray ? headerSize : headerSize + (data1RecordCount * 4),
         'table2StartIndex': tableStoreLength === 0 && !isArray ? headerSize + (data1RecordCount * records1Size) : headerSize + (data1RecordCount * 4) + (data1RecordCount * records1Size),
-        'data2recordWords': data2RecordWords,
-        'data2RecordCapacity': data2RecordCapacity,
-        'data2IndexEntries': data2IndexEntries,
-        'data2RecordCount': data2RecordCount
+        'recordWords': data2RecordWords,
+        'recordCapacity': data2RecordCapacity,
+        'numMembers': data2IndexEntries,
+        'nextRecordToUse': nextRecordToUse
     };
 };
 

package/strategies/common/header/m20/M20TableHeaderStrategy.js

@@ -46,7 +46,7 @@ M20TableHeaderStrategy.parseHeader = (data) => {
     const data2RecordCapacity = data.readUInt32BE(headerOffset+48);
     const data2IndexEntries = data.readUInt32BE(headerOffset+52);
     const unknown4 = data.readUInt32BE(headerOffset+56);
-    const data2RecordCount = data.readUInt32BE(headerOffset+60);
+    const nextRecordToUse = data.readUInt32BE(headerOffset+60);
 
     let offsetStart = 0xE8 + tableStoreLength;
     const hasSecondTable = tableTotalLength > table1Length;
@@ -104,10 +104,10 @@ M20TableHeaderStrategy.parseHeader = (data) => {
         'hasSecondTable': hasSecondTable,
         'table1StartIndex': table1StartIndex,
         'table2StartIndex': table2StartIndex,
-        'data2recordWords': data2RecordWords,
-        'data2RecordCapacity': data2RecordCapacity,
-        'data2IndexEntries': data2IndexEntries,
-        'data2RecordCount': data2RecordCount
+        'recordWords': data2RecordWords,
+        'recordCapacity': data2RecordCapacity,
+        'numMembers': data2IndexEntries,
+        'nextRecordToUse': nextRecordToUse
     };
 };