madden-franchise 3.2.5 → 3.2.6

package/FranchiseFileField.js

@@ -1,4 +1,6 @@
-const { BitView } = require('bit-buffer');
+const {
+  BitView
+} = require('bit-buffer');
 
 const utilService = require('./services/utilService');
 const FranchiseFileTable2Field = require('./FranchiseFileTable2Field');
@@ -17,26 +19,26 @@ class FranchiseFileField {
       this.secondTableField = new FranchiseFileTable2Field(this._recordBuffer.readUInt32BE(offset.offset / 8), offset.maxLength);
       this.secondTableField.fieldReference = this;
     }
-    
+
     if (offset.valueInThirdTable) {
       this.thirdTableField = new FranchiseFileTable3Field(this._recordBuffer.readUInt32BE(offset.offset / 8), offset.maxLength);
       this.thirdTableField.fieldReference = this;
     }
   };
 
-  get key () {
+  get key() {
     return this._key;
   };
 
-  get offset () {
+  get offset() {
     return this._offset;
   };
 
-  get value () {
+  get value() {
     if (this._unformattedValue === null) {
       this._setUnformattedValueIfEmpty();
     }
-    
+
     if (this._value === null) {
       this._value = this._parseFieldValue(this._unformattedValue, this._offset);
     }
@@ -44,11 +46,11 @@ class FranchiseFileField {
     return this._value;
   };
 
-  get isReference () {
+  get isReference() {
     return this._offset.isReference;
   };
 
-  get referenceData () {
+  get referenceData() {
     if (this._unformattedValue === null) {
       this._setUnformattedValueIfEmpty();
     }
@@ -56,11 +58,11 @@ class FranchiseFileField {
     if (this.isReference) {
       return utilService.getReferenceDataFromBitview(this._unformattedValue, this.offset.offset);
     }
-    
+
     return null;
   };
 
-  set value (value) {
+  set value(value) {
     if (this._unformattedValue === null) {
       this._setUnformattedValueIfEmpty();
     }
@@ -70,50 +72,46 @@ class FranchiseFileField {
 
     if (this.offset.valueInSecondTable) {
       this.secondTableField.value = value.toString();
-    }
-    else if (this.offset.valueInThirdTable) {
+    } else if (this.offset.valueInThirdTable) {
       if (typeof value === 'object') {
         const newVal = JSON.stringify(value);
         this._value = newVal;
         this.thirdTableField.value = newVal;
-      }
-      else {
+      } else {
         this.thirdTableField.value = value.toString();
       }
-    }
-    else {
+    } else {
       let actualValue;
 
       if (this.offset.isReference) {
-        if (!utilService.isString(value)) { throw new Error(`Argument must be of type string. You passed in a ${typeof unformattedValue}.`); }
-        else if (!utilService.stringOnlyContainsBinaryDigits(value)) { 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.`)}
+        if (!utilService.isString(value)) {
+          throw new Error(`Argument must be of type string. You passed in a ${typeof unformattedValue}.`);
+        } else if (!utilService.stringOnlyContainsBinaryDigits(value)) {
+          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.`)
+        }
         const referenceData = utilService.getReferenceData(value);
         this._unformattedValue.setBits(this.offset.offset, referenceData.tableId, 15);
         this._unformattedValue.setBits((this.offset.offset + 15), referenceData.rowNumber, 17);
-      }
-      else if (this.offset.enum) {
+      } else if (this.offset.enum) {
         try {
           let theEnum = this._getEnumFromValue(value);
-          
+
           // Enums can have negative values and Madden negative numbers are not standard. We need to convert it here.
           // Ex: In Madden, binary "1000" = -1 for an enum with a max length of 4. But for everything else, "1000" = 8, so we need to get the "real" value here.
           const decimalEquivalent = utilService.bin2dec(theEnum.unformattedValue);
           this._unformattedValue.setBits(this.offset.offset, decimalEquivalent, this.offset.length);
           this._value = theEnum.name;
-        }
-        catch (err) {
+        } catch (err) {
           // if user tries entering an invalid enum value, check if it's an empty record reference (will be binary)
           if (utilService.stringOnlyContainsBinaryDigits(value)) {
             this._value = value;
             this._unformattedValue.setBits(this.offset.offset, value, this.offset.length);
-          }
-          else {
+          } else {
             this._value = null;
             throw err;
           }
         }
-      }
-      else {
+      } else {
         switch (this.offset.type) {
           case 's_int':
             actualValue = parseInt(value);
@@ -128,8 +126,7 @@ class FranchiseFileField {
             if (this.offset.minValue || this.offset.maxValue) {
               // return utilService.dec2bin(formatted, offset.length);
               this._unformattedValue.setBits(this.offset.offset, actualValue, this.offset.length);
-            }
-            else {
+            } else {
               const maxValueBinary = getMaxValueBinary(this.offset);
               const maxValue = utilService.bin2dec(maxValueBinary);
               // return utilService.dec2bin(formatted + maxValue, offset.length);
@@ -161,7 +158,7 @@ class FranchiseFileField {
     }
   };
 
-  get unformattedValue () {
+  get unformattedValue() {
     if (this._unformattedValue === null) {
       this._setUnformattedValueIfEmpty();
     }
@@ -169,7 +166,7 @@ class FranchiseFileField {
     return this._unformattedValue;
   };
 
-  set unformattedValue (unformattedValue) {
+  set unformattedValue(unformattedValue) {
     this.setUnformattedValueWithoutChangeEvent(unformattedValue);
     this._value = null;
     this._parent.onEvent('change', this);
@@ -183,6 +180,10 @@ class FranchiseFileField {
     this._isChanged = changed;
   };
 
+  _bubbleChangeToParent() {
+    this._parent.onEvent('change', this);
+  };
+
   clearCachedValues() {
     this._value = null;
     this._unformattedValue = null;
@@ -195,8 +196,9 @@ class FranchiseFileField {
   };
 
   setUnformattedValueWithoutChangeEvent(unformattedValue, suppressErrors) {
-    if (!(unformattedValue instanceof BitView)) { throw new Error(`Argument must be of type BitView. You passed in a(n) ${typeof unformattedValue}.`); }
-    else {
+    if (!(unformattedValue instanceof BitView)) {
+      throw new Error(`Argument must be of type BitView. You passed in a(n) ${typeof unformattedValue}.`);
+    } else {
       this._unformattedValue = unformattedValue;
       this._value = null;
     }
@@ -204,23 +206,20 @@ class FranchiseFileField {
 
   _getEnumFromValue(value) {
     const enumName = this.offset.enum.getMemberByName(value);
-    
+
     if (enumName) {
       return enumName;
-    } 
-    else {
+    } else {
       const formattedEnum = this.offset.enum.getMemberByValue(value)
 
       if (formattedEnum) {
         return formattedEnum;
-      } 
-      else {
+      } else {
         const unformattedEnum = this.offset.enum.getMemberByUnformattedValue(value);
 
         if (unformattedEnum) {
           return unformattedEnum;
-        } 
-        else {
+        } else {
           return this.offset.enum.members[0];
         }
       }
@@ -230,31 +229,26 @@ class FranchiseFileField {
   _parseFieldValue(unformatted, offset) {
     if (offset.valueInSecondTable) {
       return this.secondTableField.value;
-    }
-    else if (offset.valueInThirdTable) {
+    } else if (offset.valueInThirdTable) {
       return this.thirdTableField.value;
-    }
-    else if (offset.enum) {
+    } else if (offset.enum) {
       const enumUnformattedValue = utilService.dec2bin(this.unformattedValue.getBits(this.offset.offset, this.offset.length), offset.enum._maxLength);
-      
+
       try {
         const theEnum = offset.enum.getMemberByUnformattedValue(enumUnformattedValue);
-  
+
         if (theEnum) {
           return theEnum.name;
         }
-      }
-      catch (err) {
+      } catch (err) {
         // console.log(err);
       }
-      
+
       return enumUnformattedValue;
-    }
-    else if (offset.isReference) {
+    } else if (offset.isReference) {
       const referenceData = utilService.getReferenceDataFromBitview(this._unformattedValue, this.offset.offset);
       return utilService.getBinaryReferenceData(referenceData.tableId, referenceData.rowNumber);
-    }
-    else {
+    } else {
       switch (offset.type) {
         case 's_int':
           // return utilService.bin2dec(unformatted) + offset.minValue;
@@ -262,28 +256,26 @@ class FranchiseFileField {
         case 'int':
           if (offset.minValue || offset.maxValue) {
             return unformatted.getBits(offset.offset, offset.length);
-          }
-          else {
+          } else {
             // This is for int[] tables.
-            
+
             const maxValueBinary = getMaxValueBinary(offset);
             const maxValue = utilService.bin2dec(maxValueBinary);
             const newValue = unformatted.getBits(offset.offset, offset.length);
-            
+
             if (newValue === 0) {
               return 0;
-            }
-            else {
+            } else {
               return newValue - maxValue;
             }
           }
-        case 'bool':
-          return unformatted.getBits(offset.offset, 1) ? true : false;
-        case 'float':
-          // return utilService.bin2Float(unformatted);
-          return unformatted.getFloat32(offset.offset, offset.length);
-        default:
-          return unformatted;
+          case 'bool':
+            return unformatted.getBits(offset.offset, 1) ? true : false;
+          case 'float':
+            // return utilService.bin2Float(unformatted);
+            return unformatted.getFloat32(offset.offset, offset.length);
+          default:
+            return unformatted;
       }
     }
   };

package/FranchiseFileTable.js

@@ -14,7 +14,7 @@ class FranchiseFileTable extends EventEmitter {
     this.strategyBase = strategy;
     this.strategy = this.strategyBase.table;
     this.recordsRead = false;
-    this._gameYear = gameYear; 
+    this._gameYear = gameYear;
     this.header = this.strategy.parseHeader(this.data);
     this.name = this.header.name;
     this.isArray = this.header.isArray;
@@ -28,12 +28,12 @@ class FranchiseFileTable extends EventEmitter {
     this._settings = settings;
   };
 
-  get hexData () {
+  get hexData() {
     this.updateBuffer();
     return this.data;
   };
 
-  set schema (schema) {
+  set schema(schema) {
     // console.time('set schema');
     this._schema = schema;
     const modifiedHeaderAttributes = this.strategy.parseHeaderAttributesFromSchema(schema, this.data, this.header);
@@ -45,23 +45,23 @@ class FranchiseFileTable extends EventEmitter {
     // console.timeEnd('set schema');
   };
 
-  get schema () {
+  get schema() {
     return this._schema;
   };
 
   getBinaryReferenceToRecord(index) {
     return utilService.getBinaryReferenceData(this.header.tableId, index);
   };
-  
+
   updateBuffer() {
     // need to check table2 & table3 data first because it may change offsets of the legit records.
     let table2Data = this.strategy.getTable2BinaryData(this.table2Records, this.data.slice(this.header.table2StartIndex));
     let table3Data = [];
-    
+
     if (this.header.table3StartIndex) {
       table3Data = this.strategy.getTable3BinaryData(this.table3Records, this.data.slice(this.header.table3StartIndex));
     }
-    
+
     // update table2 length and table total length in table header (only if records have been read)
     if (this.recordsRead) {
       let table2DataLength = 0;
@@ -81,12 +81,15 @@ class FranchiseFileTable extends EventEmitter {
 
       this.header.table3Length = table3DataLength;
 
-      this.data.writeUInt32BE(this.header.table2Length , this.header.offsetStart - 44);
+      this.data.writeUInt32BE(this.header.table2Length, this.header.offsetStart - 44);
       this.data.writeUInt32BE(this.header.table3Length, this.header.offsetStart - 40);
       this.data.writeUInt32BE(this.header.tableTotalLength, this.header.offsetStart - 24);
     }
 
-    const changedRecords = this.records.filter((record) => { return record.isChanged; });
+    const changedRecords = this.records.filter((record) => {
+      return record.isChanged;
+    });
+
     let currentOffset = 0;
     let bufferArrays = [];
 
@@ -109,10 +112,10 @@ class FranchiseFileTable extends EventEmitter {
       let record = changedRecords[i];
       record.isChanged = false;
       const recordOffset = this.header.table1StartIndex + (record.index * this.header.record1Size);
-      
+
       bufferArrays.push(this.data.slice(currentOffset, recordOffset));
       const recordHexData = record.hexData;
-      
+
       bufferArrays.push(recordHexData);
       currentOffset = recordOffset + recordHexData.length;
     }
@@ -172,7 +175,7 @@ class FranchiseFileTable extends EventEmitter {
         const firstOffset = this.offsetTable[0];
         if (firstOffset.type !== 'string') {
           isEmptyReference = true;
-          
+
           // Save the row number that this record points to.
           emptyRecordReferenceIndicies.push(firstFourBytesReference.rowNumber);
         }
@@ -183,7 +186,9 @@ class FranchiseFileTable extends EventEmitter {
 
     // 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) => {
+    const unreachableRecords = this.records.filter((record) => {
+      return record.isEmpty;
+    }).filter((record) => {
       return emptyRecordReferenceIndicies.indexOf(record.index) === -1;
     });
 
@@ -193,11 +198,10 @@ class FranchiseFileTable extends EventEmitter {
         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 {
+      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) {
@@ -235,7 +239,7 @@ class FranchiseFileTable extends EventEmitter {
   };
 
   // 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.
-  readRecords (attribsToLoad) {
+  readRecords(attribsToLoad) {
     return new Promise((resolve, reject) => {
       if (!this.recordsRead || isLoadingNewOffsets(this.loadedOffsets, attribsToLoad, this.offsetTable)) {
         if (this.schema) {
@@ -261,10 +265,10 @@ class FranchiseFileTable extends EventEmitter {
               'valueInSecondTable': false,
               'valueInThirdTable': false,
             }
-            
+
             offset.isReference = !offset.enum && (offset.type[0] == offset.type[0].toUpperCase() || offset.type.includes('[]')) ? true : false,
 
-            offsetTable.push(offset);
+              offsetTable.push(offset);
           }
 
           for (let i = 0; i < this.header.data1RecordCount; i++) {
@@ -276,23 +280,25 @@ class FranchiseFileTable extends EventEmitter {
         } else {
           reject('Cannot read records: Schema is not defined.');
         }
-        
+
         let offsetTableToUse = this.offsetTable;
         const mandatoryOffsetsToLoad = this.strategy.getMandatoryOffsets(this.offsetTable);
-        
+
         if (attribsToLoad) {
           // 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; }); 
+          offsetTableToUse = offsetTableToUse.filter((attrib) => {
+            return mandatoryOffsetsToLoad.includes(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, this);
-        
+
         if (this.header.hasSecondTable) {
           this._parseTable2Values(this.data, this.header, this.records);
         }
@@ -379,8 +385,7 @@ class FranchiseFileTable extends EventEmitter {
         // without emitting an event
         this._changeRecordBuffers(lastEmptyRecordIndex, record.index);
         this._changeRecordBuffers(record.index, this.header.recordCapacity);
-      }
-      else {
+      } else {
         // In this case, the record that was emptied is the first empty record in the table
         this.emptyRecords.set(record.index, {
           previous: null,
@@ -392,7 +397,7 @@ class FranchiseFileTable extends EventEmitter {
         this.setNextRecordToUse(record.index);
         this._changeRecordBuffers(record.index, this.header.recordCapacity);
       }
-      
+
       this.emit('change');
     }
   };
@@ -400,10 +405,12 @@ class FranchiseFileTable extends EventEmitter {
   _parseTable2Values(data, header, records) {
     const that = this;
     const secondTableData = data.slice(header.table2StartIndex);
-  
+
     records.forEach((record) => {
-      const fieldsReferencingSecondTable = record.fieldsArray.filter((field) => { return field.secondTableField; });
-  
+      const fieldsReferencingSecondTable = record.fieldsArray.filter((field) => {
+        return field.secondTableField;
+      });
+
       fieldsReferencingSecondTable.forEach((field) => {
         field.secondTableField.unformattedValue = that.strategyBase.table2Field.getInitialUnformattedValue(field, secondTableData);
         field.secondTableField.strategy = that.strategyBase.table2Field;
@@ -412,14 +419,16 @@ class FranchiseFileTable extends EventEmitter {
       });
     });
   };
-  
+
   _parseTable3Values(data, header, records) {
     const that = this;
     const thirdTableData = data.slice(header.table3StartIndex);
 
     records.forEach((record) => {
-      const fieldsReferencingThirdTable = record.fieldsArray.filter((field) => { return field.thirdTableField; });
-  
+      const fieldsReferencingThirdTable = record.fieldsArray.filter((field) => {
+        return field.thirdTableField;
+      });
+
       fieldsReferencingThirdTable.forEach((field) => {
         field.thirdTableField.unformattedValue = that.strategyBase.table3Field.getInitialUnformattedValue(field, thirdTableData);
         field.thirdTableField.strategy = that.strategyBase.table3Field;
@@ -469,7 +478,7 @@ class FranchiseFileTable extends EventEmitter {
         // 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 (this.header.record1Size >= 4) {
-          
+
           // Ex: Empty record list looks like object: A -> B -> C
           // When B's value is changed, the records need updated to: A -> C
           const emptyRecordReference = this.emptyRecords.get(object.index);
@@ -478,99 +487,100 @@ class FranchiseFileTable extends EventEmitter {
           // Automatically un-empty the row if the setting is enabled and the changed record was empty.
           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.getReferenceDataFromBuffer(object.data.slice(0, 4));
-              // if (referenceData.tableId !== 0 || referenceData.rowNumber > this.header.recordCapacity) {
-
-
-              // if the changed field isn't included in the first 32 bits, zero out the first 32 bits. 
-              // Otherwise, it's not necessary to zero out.
-              const changedFieldsInFirst4Bytes = object.fieldsArray.filter((field) => { return field.isChanged && field.offset.indexOffset < 32; });
-              if (this._settings.autoUnempty && changedFieldsInFirst4Bytes.length === 0) {
-                // set first 4 bytes to 0
-                this._changeRecordBuffers(object.index, 0);
-
-                // invalidate the cached values since we set the buffer directly
-                const fieldsInFirst4Bytes = object.fieldsArray.filter((field) => { return field.offset.indexOffset < 32; });
-                fieldsInFirst4Bytes.forEach((field) => { 
-                  field.clearCachedValues();
+            // 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.getReferenceDataFromBuffer(object.data.slice(0, 4));
+            // if (referenceData.tableId !== 0 || referenceData.rowNumber > this.header.recordCapacity) {
+
+
+            // if the changed field isn't included in the first 32 bits, zero out the first 32 bits. 
+            // Otherwise, it's not necessary to zero out.
+            const changedFieldsInFirst4Bytes = object.fieldsArray.filter((field) => {
+              return field.isChanged && field.offset.indexOffset < 32;
+            });
+            if (this._settings.autoUnempty && changedFieldsInFirst4Bytes.length === 0) {
+              // set first 4 bytes to 0
+              this._changeRecordBuffers(object.index, 0);
+
+              // invalidate the cached values since we set the buffer directly
+              const fieldsInFirst4Bytes = object.fieldsArray.filter((field) => {
+                return field.offset.indexOffset < 32;
+              });
+              fieldsInFirst4Bytes.forEach((field) => {
+                field.clearCachedValues();
+              });
+            }
+
+            // If autoUnempty is disabled, only un-empty the row if a field in the first 4 bytes changed.
+            // If autoUnempty is enabled, un-empty the row if ANY field changed.
+            if (this._settings.autoUnempty || changedFieldsInFirst4Bytes.length > 0) {
+              // if the record contains any string values, point the string values to
+              // their correct offsets
+              this.strategy.recalculateStringOffsets(this, object);
+              this.strategy.recalculateBlobOffsets(this, object);
+
+              // Delete the empty record entry because it is no longer empty
+              this.emptyRecords.delete(object.index);
+
+              // Set the isEmpty back to false because it's no longer empty
+              object.isEmpty = false;
+
+              // Check if there is a previous empty record
+              const previousEmptyReference = this.emptyRecords.get(emptyRecordReference.previous);
+
+              if (previousEmptyReference) {
+                // Set the previous empty record to point to the old reference's next node
+                this.emptyRecords.set(emptyRecordReference.previous, {
+                  previous: this.emptyRecords.get(emptyRecordReference.previous).previous,
+                  next: emptyRecordReference.next
                 });
+
+                // change the table buffer and record buffer to reflect object change
+                this._changeRecordBuffers(emptyRecordReference.previous, emptyRecordReference.next);
               }
-              
-              // If autoUnempty is disabled, only un-empty the row if a field in the first 4 bytes changed.
-              // If autoUnempty is enabled, un-empty the row if ANY field changed.
-              if (this._settings.autoUnempty || changedFieldsInFirst4Bytes.length > 0) {
-                // if the record contains any string values, point the string values to
-                // their correct offsets
-                this.strategy.recalculateStringOffsets(this, object);
-                this.strategy.recalculateBlobOffsets(this, object);
-
-                // Delete the empty record entry because it is no longer empty
-                this.emptyRecords.delete(object.index);
-
-                // Set the isEmpty back to false because it's no longer empty
-                object.isEmpty = false;
-
-                // Check if there is a previous empty record
-                const previousEmptyReference = this.emptyRecords.get(emptyRecordReference.previous);
-
-                if (previousEmptyReference) {
-                  // Set the previous empty record to point to the old reference's next node
-                  this.emptyRecords.set(emptyRecordReference.previous, {
-                    previous: this.emptyRecords.get(emptyRecordReference.previous).previous,
-                    next: emptyRecordReference.next
-                  });
-
-                  // change the table buffer and record buffer to reflect object change
-                  this._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 = this.emptyRecords.get(emptyRecordReference.next);
-
-                if (nextEmptyReference) {
-                  this.emptyRecords.set(emptyRecordReference.next, {
-                    previous: emptyRecordReference.previous,
-                    next: this.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 object record as the next record to use.
-                    this.setNextRecordToUse(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 = this.emptyRecords.get(emptyRecordReference.next);
+
+              if (nextEmptyReference) {
+                this.emptyRecords.set(emptyRecordReference.next, {
+                  previous: emptyRecordReference.previous,
+                  next: this.emptyRecords.get(emptyRecordReference.next).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) {
-                  this.setNextRecordToUse(this.header.recordCapacity);
+                if (!previousEmptyReference) {
+                  // If no previous empty record exists and a next record exists, we need to update the header to
+                  // point to object record as the next record to use.
+                  this.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) {
+                this.setNextRecordToUse(this.header.recordCapacity);
+              }
+            }
             // }
           }
         }
 
         this.emit('change');
-      }
-      else if (name === 'empty') {
+      } else if (name === 'empty') {
         this._onRecordEmpty(object);
         this.emit('change');
       }
-    }
-    else if (object instanceof FranchiseFileTable2Field || object instanceof FranchiseFileTable3Field) {
+    } else if (object instanceof FranchiseFileTable2Field || object instanceof FranchiseFileTable3Field) {
       object.isChanged = true;
-      
+
       // When a table2 field changes, we need to check if the record is empty. If so, we need to mark it as not empty. 
       if (object.fieldReference) {
         this.onEvent('change', object.fieldReference._parent);
-      }
-      else {
+      } else {
         // Only emit change here if the field reference is empty.
         // the onEvent call will emit a change in the above condition.
         this.emit('change');
@@ -591,24 +601,23 @@ function readOffsetTable(data, schema, header) {
     return offset.final || offset.const || offset.type.indexOf('()') >= 0 || offset.type === 'ITransaction_Sleep';
   };
 
-  for(let i = 0; i < offsetTable.length; i++) {
+  for (let i = 0; i < offsetTable.length; i++) {
     let curOffset = offsetTable[i];
-    let nextOffset = offsetTable.length > i + 1 ? offsetTable[i+1] : null;
+    let nextOffset = offsetTable.length > i + 1 ? offsetTable[i + 1] : null;
 
     if (nextOffset) {
-      let curIndex = i+2;
-      while(nextOffset && isSkippedOffset(nextOffset)) {
+      let curIndex = i + 2;
+      while (nextOffset && isSkippedOffset(nextOffset)) {
         nextOffset = offsetTable[curIndex];
         curIndex += 1;
       }
 
       if (nextOffset) {
-        curOffset.length = nextOffset.indexOffset - curOffset.indexOffset;  
+        curOffset.length = nextOffset.indexOffset - curOffset.indexOffset;
       } else {
         curOffset.length = (header.record1Size * 8) - curOffset.indexOffset;
-      }      
-    }
-    else {
+      }
+    } else {
       curOffset.length = (header.record1Size * 8) - curOffset.indexOffset;
     }
 
@@ -619,7 +628,7 @@ function readOffsetTable(data, schema, header) {
 
   let currentOffsetIndex = 0;
   let chunked32bit = [];
- 
+
   for (let i = 0; i < header.record1Size * 8; i += 32) {
     let chunkedOffsets = [];
     let offsetLength = i % 32;
@@ -632,15 +641,15 @@ function readOffsetTable(data, schema, header) {
           currentOffsetIndex += 1;
           continue;
         }
-        
+
         offsetLength += currentOffset.length;
         chunkedOffsets.push(currentOffset);
-  
+
         currentOffsetIndex += 1;
       } else {
         break;
       }
-    } while((currentOffsetIndex < offsetTable.length) && offsetLength < 32);
+    } while ((currentOffsetIndex < offsetTable.length) && offsetLength < 32);
 
     chunked32bit.push(chunkedOffsets);
   }
@@ -651,16 +660,20 @@ function readOffsetTable(data, schema, header) {
       offsetArray[offsetArray.length - 1].offset = currentOffset;
 
       for (let i = offsetArray.length - 2; i >= 0; i--) {
-        let previousOffset = offsetArray[i+1];
+        let previousOffset = offsetArray[i + 1];
         let offset = offsetArray[i];
         offset.offset = previousOffset.offset + previousOffset.length;
       }
     }
   });
 
-  offsetTable = offsetTable.filter((offset) => { return !(isSkippedOffset(offset)) });
-  offsetTable.sort((a,b) => { return a.offset - b.offset; });
-  
+  offsetTable = offsetTable.filter((offset) => {
+    return !(isSkippedOffset(offset))
+  });
+  offsetTable.sort((a, b) => {
+    return a.offset - b.offset;
+  });
+
   for (let i = 0; i < offsetTable.length; i++) {
     schema.attributes[offsetTable[i].index].offsetIndex = i;
   }
@@ -668,7 +681,9 @@ function readOffsetTable(data, schema, header) {
   return offsetTable;
 
   function sortOffsetTableByIndexOffset() {
-    offsetTable.sort((a, b) => { return a.indexOffset - b.indexOffset; });
+    offsetTable.sort((a, b) => {
+      return a.indexOffset - b.indexOffset;
+    });
   };
 
   function parseOffsetTableFromData() {
@@ -722,16 +737,17 @@ function readRecords(data, header, offsetTable, table) {
 };
 
 function isLoadingNewOffsets(currentlyLoaded, attribsToLoad, offsetTable) {
-  const names = currentlyLoaded.map((currentlyLoadedOffset) => { return currentlyLoadedOffset.name; });
+  const names = currentlyLoaded.map((currentlyLoadedOffset) => {
+    return currentlyLoadedOffset.name;
+  });
 
   if (attribsToLoad) {
     let newAttribs = attribsToLoad.filter((attrib) => {
       return !names.includes(attrib);
     });
-  
+
     return newAttribs.length > 0;
-  }
-  else {
+  } else {
     return currentlyLoaded.length !== offsetTable.length;
   }
 };

package/FranchiseFileTable2Field.js

@@ -2,7 +2,7 @@ const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 
 class FranchiseFileTable2Field {
-  constructor (index, maxLength, parent) {
+  constructor(index, maxLength, parent) {
     this._value = '';
     this.rawIndex = index;
     this.isChanged = false;
@@ -15,11 +15,11 @@ class FranchiseFileTable2Field {
     this._parent = parent;
   };
 
-  get unformattedValue () {
+  get unformattedValue() {
     return this._unformattedValue;
   };
 
-  set unformattedValue (value) {
+  set unformattedValue(value) {
     this._unformattedValue = value;
 
     if (this.lengthAtLastSave === null) {
@@ -32,52 +32,55 @@ class FranchiseFileTable2Field {
     }
   };
 
-  get value () {
+  get value() {
     if (this._value === null) {
-      this._value = this._unformattedValue.toString().replace(/\0.*$/g,'');
+      this._value = this._unformattedValue.toString().replace(/\0.*$/g, '');
     }
 
     return this._value;
   };
 
-  set value (value) {
+  set value(value) {
     this._value = value;
 
     if (value.length > this.maxLength) {
       value = value.substring(0, this.maxLength);
     }
-    
+
     this._unformattedValue = this._strategy.setUnformattedValueFromFormatted(value, this.maxLength);
 
     if (this.lengthAtLastSave === null) {
       this.lengthAtLastSave = getLengthOfUnformattedValue(this._unformattedValue);
     }
-    
+
     this._parent.onEvent('change', this);
   };
 
-  get hexData () {
+  get hexData() {
     return this._unformattedValue;
   };
 
-  get strategy () {
+  get strategy() {
     return this._strategy;
   };
 
-  set strategy (strategy) {
+  set strategy(strategy) {
     this._strategy = strategy;
   };
 
-  get offset () {
+  get offset() {
     return this._offset;
   };
 
-  set offset (offset) {
+  set offset(offset) {
+    const offsetChanged = this._offset !== offset;
     this._offset = offset;
     this.index = offset;
 
-    if (this.fieldReference) {
+    if (offsetChanged && this.fieldReference) {
       this.fieldReference.unformattedValue.setBits(this.fieldReference.offset.offset, offset, 32);
+      this.fieldReference.isChanged = true;
+      this.fieldReference._bubbleChangeToParent();
     }
   };
 
@@ -93,5 +96,5 @@ class FranchiseFileTable2Field {
 module.exports = FranchiseFileTable2Field;
 
 function getLengthOfUnformattedValue(value) {
-    return value.length;
+  return value.length;
 };

package/package.json

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

package/strategies/common/CommonAlgorithms.js

@@ -2,7 +2,9 @@ let CommonAlgorithms = {};
 
 CommonAlgorithms.save = (units, oldData) => {
     // first check if any records changed. If not, we can return immediately because nothing changed.
-    const changedUnits = units.find((unit) => { return unit.isChanged; });
+    const changedUnits = units.find((unit) => {
+        return unit.isChanged;
+    });
 
     if (!changedUnits) {
         return oldData;
@@ -14,7 +16,9 @@ CommonAlgorithms.save = (units, oldData) => {
     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.sort((a, b) => {
+        return a.index - b.index;
+    });
 
     units.forEach((unit, index) => {
         if (unit.offset === 0 && index > 0) {
@@ -50,7 +54,7 @@ CommonAlgorithms.save = (units, oldData) => {
             unit.isChanged = false;
         }
     });
-    
+
     // Next, we need to push the remainder of data onto the array.
 
     // For example, think if a user changed the 3rd record out of 100.