madden-franchise 2.3.0 → 2.3.4

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/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) => {
@@ -87,6 +88,7 @@ class FranchiseFileRecord extends EventEmitter {
 
   empty() {
     this.emit('empty');
+    this.isEmpty = true;
   };
 };
 

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,21 @@ 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();
+    }
   };
 
   // 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.
@@ -149,7 +168,12 @@ 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;
 
@@ -161,52 +185,75 @@ class FranchiseFileTable extends EventEmitter {
             // If so, we need to consider the record as no longer empty
             // So we need to adjust the empty records
 
-            // 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) {
-
-              // Delete the empty record entry because it is no longer empty
-              that.emptyRecords.delete(this.index);
-
-              // 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);
+            // 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.
+                      that.setNextRecordToUse(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) {
+                    that.setNextRecordToUse(that.header.recordCapacity);
+                  }
                 }
               }
-
-              // 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);
+              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);
+                }
               }
             }
 
@@ -214,57 +261,58 @@ class FranchiseFileTable extends EventEmitter {
           });
 
           record.on('empty', function () {
-            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);
-            }
-            
-            that.emit('change');
+            onRecordEmpty(this);
           });
 
-          function updateNextRecordToUseHeaderAndBuffer(nextRecordToUse) {
-            // We need to update the table header to use this row next
-            table.header.nextRecordToUse = nextRecordToUse;
-
-            // And finally update the buffer to reflect this change
-            that.data.writeUInt32BE(nextRecordToUse, that.header.headerOffset - 4);
+          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 (!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.
+              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: record.index
+                });
+  
+                // Then we need to update the current record index to point to the record capacity.
+                that.emptyRecords.set(record.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, 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(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)
+                that.setNextRecordToUse(record.index);
+                changeRecordBuffers(record.index, that.header.recordCapacity);
+              }
+              
+              that.emit('change');
+            }
           };
 
           function changeRecordBuffers(index, emptyRecordReference) {
@@ -279,7 +327,14 @@ class FranchiseFileTable extends EventEmitter {
           };
 
           function setRecordInternalBuffer(index, emptyRecordReference) {
-            that.records[index].data = utilService.dec2bin(emptyRecordReference, that.header.record1Size * 8);
+            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;
           };
         });
 

package/package.json

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