madden-franchise 2.5.6 → 3.0.0

package/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "pwa-node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${file}"
+        }
+    ]
+}

package/FranchiseEnum.js

@@ -45,7 +45,11 @@ class FranchiseEnum {
   };
 
   getMemberByValue(value) {
-    return this._members.find((member) => { return member.name !== 'First_' && member.name !== 'Last_' && member.value === value; });
+    const matches = this._members.filter((member) => { return member.name !== 'First_' && member.name !== 'Last_' && member.value === value; });
+    if (matches.length === 0) { throw new Error(`Argument is not a valid enum value for this field. You passed in ${value}. Field name: ${this.name}`); }
+
+    const matchesNoUnderscore = matches.find((member) => { return member.name[member.name.length - 1] !== '_'});    
+    return matchesNoUnderscore ? matchesNoUnderscore : matches[0];
   };
 
   getMemberByUnformattedValue(value) {

package/FranchiseFileField.js

@@ -1,22 +1,19 @@
-const EventEmitter = require('events').EventEmitter;
+const { BitView } = require('bit-buffer');
+
 const utilService = require('./services/utilService');
 const FranchiseFileTable2Field = require('./FranchiseFileTable2Field');
 
-class FranchiseFileField extends EventEmitter {
-  constructor(key, value, offset) {
-    super();
+class FranchiseFileField {
+  constructor(key, value, offset, parent) {
     this._key = key;
-    this._unformattedValue = value;
-    this._value = parseFieldValue(value, offset);
+    this._recordBuffer = value;
+    this._unformattedValue = null;
     this._offset = offset;
+    this._parent = parent;
 
     if (offset.valueInSecondTable) {
-      this.secondTableField = new FranchiseFileTable2Field(value, offset.maxLength);
+      this.secondTableField = new FranchiseFileTable2Field(this._recordBuffer.readUInt32BE(offset.offset / 8), offset.maxLength);
       this.secondTableField.fieldReference = this;
-
-      this.secondTableField.on('change', function () {
-        this._value = this.secondTableField.value;
-      }.bind(this));
     }
   };
 
@@ -29,6 +26,14 @@ class FranchiseFileField extends EventEmitter {
   };
 
   get value () {
+    if (this._unformattedValue === null) {
+      this._setUnformattedValueIfEmpty();
+    }
+    
+    if (this._value === null) {
+      this._value = this._parseFieldValue(this._unformattedValue, this._offset);
+    }
+
     return this._value;
   };
 
@@ -37,193 +42,213 @@ class FranchiseFileField extends EventEmitter {
   };
 
   get referenceData () {
+    if (this._unformattedValue === null) {
+      this._setUnformattedValueIfEmpty();
+    }
+
     if (this.isReference) {
-      return utilService.getReferenceData(this.value);
+      return utilService.getReferenceDataFromBitview(this._unformattedValue, this.offset.offset);
     }
     
     return null;
   };
 
-  set value (value) {
+  set value (value) {    
+    if (this._unformattedValue === null) {
+      this._setUnformattedValueIfEmpty();
+    }
+
+    this._value = value;
+
     if (this.offset.valueInSecondTable) {
       this.secondTableField.value = value.toString();
     } 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.`)}
+        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) {
+        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) {
+          this._value = null;
+          throw err;
+        }
       }
+      else {
+        switch (this.offset.type) {
+          case 's_int':
+            actualValue = parseInt(value);
+            this._value = actualValue;
+            this._unformattedValue.setBits(this.offset.offset, actualValue - this.offset.minValue, this.offset.length);
+            break;
+          default:
+          case 'int':
+            actualValue = parseInt(value);
+            this._value = actualValue;
+
+            if (this.offset.minValue || this.offset.maxValue) {
+              // return utilService.dec2bin(formatted, offset.length);
+              this._unformattedValue.setBits(this.offset.offset, actualValue, this.offset.length);
+            }
+            else {
+              const maxValueBinary = getMaxValueBinary(this.offset);
+              const maxValue = utilService.bin2dec(maxValueBinary);
+              // return utilService.dec2bin(formatted + maxValue, offset.length);
+              this._unformattedValue.setBits(this.offset.offset, actualValue + maxValue, this.offset.length);
+            }
+            break;
+          case 'bool':
+            // return (formatted == 1 || (formatted.toString().toLowerCase() == 'true')) ? '1' : '0';
+            actualValue = (value == 1 || (value.toString().toLowerCase() == 'true'));
+            this._value = actualValue;
+            this._unformattedValue.setBits(this.offset.offset, actualValue, 1);
+            break;
+          case 'float':
+            actualValue = parseFloat(value);
+            this._value = actualValue;
+            // return utilService.float2Bin(formatted);
+            // this._unformattedValue.setBits(this.offset.offset, value, this.offset.length);
+            this._unformattedValue.setFloat32(this.offset.offset, actualValue);
+            break;
+        }
+      }
+
+      // this._value = setFormattedValue(value, this._offset);
+      // this._unformattedValue = parseFormattedValue(value, this._offset);
+
 
-      this._value = setFormattedValue(value, this._offset);
-      this._unformattedValue = parseFormattedValue(value, this._offset);
-      this.emit('change');
+      // this.emit('change');
+      this._parent.onEvent('change', this);
     }
   };
 
   get unformattedValue () {
+    if (this._unformattedValue === null) {
+      this._setUnformattedValueIfEmpty();
+    }
+
     return this._unformattedValue;
   };
 
   set unformattedValue (unformattedValue) {
     this.setUnformattedValueWithoutChangeEvent(unformattedValue);
-    this.emit('change');
+    this._value = null;
+    this._parent.onEvent('change', this);
+  };
+
+  _setUnformattedValueIfEmpty() {
+    this._value = null;
+    this._unformattedValue = new BitView(this._recordBuffer, this._recordBuffer.byteOffset);
+    this._unformattedValue.bigEndian = true;
   };
 
   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.`)}
+    if (!(unformattedValue instanceof BitView)) { throw new Error(`Argument must be of type BitView. You passed in a(n) ${typeof unformattedValue}.`); }
     else {
-      let value;
-
-      if (this.offset.valueInSecondTable) {
-        value = this.secondTableField.value;
-      }
-      else {
-        value = parseFieldValue(unformattedValue.padStart(this._offset.length, '0'), this._offset);
-      }
-
-      // 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') && !suppressErrors) {
-        throw new Error(`Argument is not a valid unformatted value for this field. You passed in ${value}.`)
-      }
-
-      this._value = value;
-
-      if (this._offset.enum) {
-        this._unformattedValue = this._offset.enum.getMemberByName(this._value).unformattedValue.padStart(this._offset.length, '0');
-      } 
-      else {
-        this._unformattedValue = unformattedValue;
-      }
-    }
-  }
-};
-
-module.exports = FranchiseFileField;
-
-function setFormattedValue(value, offset) {
-  if (offset.enum) {
-    const theEnum = offset.enum.getMemberByName(value);
-    if (!theEnum) {
-      const theEnumByValue = offset.enum.getMemberByValue(value);
-
-      if (!theEnumByValue) {
-        throw new Error(`Argument is not a valid enum value for this field. You passed in ${value}.`);
-      }
-      else {
-        return theEnumByValue.name;
-      }
-    } else {
-      return theEnum.name;
+      this._unformattedValue = unformattedValue;
+      this._value = null;
     }
   }
 
-  switch (offset.type) {
-    case 's_int':
-    case 'int':
-      return parseInt(value);
-    case 'bool':
-      return value == 1 || (value.toString().toLowerCase() == 'true');
-    case 'float':
-      return parseFloat(value);
-    default:
-      return value.toString();
-  }
-};
-
-function parseFieldValue(unformatted, offset) {
-  if (offset.enum) {
-    try {
-      const theEnum = offset.enum.getMemberByUnformattedValue(unformatted);
-
-      if (theEnum) {
-        return theEnum.name;
-      }
-    }
-    catch (err) {
-      // console.log(err);
-    }
+  _getEnumFromValue(value) {
+    const enumName = this.offset.enum.getMemberByName(value);
     
-    return unformatted;
-  }
-  else {
-    switch (offset.type) {
-      case 's_int':
-        return utilService.bin2dec(unformatted) + offset.minValue;
-      case 'int':
-        if (offset.minValue || offset.maxValue) {
-          return utilService.bin2dec(unformatted);
-        }
-        else {
-          const maxValueBinary = getMaxValueBinary(offset);
-          const maxValue = utilService.bin2dec(maxValueBinary);
-          const newValue = utilService.bin2dec(unformatted);
-          
-          if (newValue === 0) {
-            return 0;
-          }
-          else {
-            return newValue - maxValue;
-          }
-        }
-      case 'bool':
-        return unformatted[0] === '1' ? true : false;
-      case 'float':
-        return utilService.bin2Float(unformatted);
-      default:
-        return unformatted;
-    }
-  }
-};
-
-function parseFormattedValue(formatted, offset) {
-  if (offset.enum) {
-    const enumName = offset.enum.getMemberByName(formatted);
-
     if (enumName) {
-      return enumName.unformattedValue.padStart(offset.length, '0');
+      return enumName;
     } 
     else {
-      const formattedEnum = offset.enum.getMemberByValue(formatted)
+      const formattedEnum = this.offset.enum.getMemberByValue(value)
 
       if (formattedEnum) {
-        return formattedEnum.unformattedValue.padStart(offset.length, '0');
+        return formattedEnum;
       } 
       else {
-        const unformattedEnum = offset.enum.getMemberByUnformattedValue(formatted);
+        const unformattedEnum = this.offset.enum.getMemberByUnformattedValue(value);
 
         if (unformattedEnum) {
-          return unformattedEnum.unformattedValue.padStart(offset.length, '0');
+          return unformattedEnum;
         } 
         else {
-          return offset.enum.members[0].unformattedValue.padStart(offset.length, '0');
+          return this.offset.enum.members[0];
         }
       }
     }
-  }
-  else {
-    switch (offset.type) {
-      case 's_int':
-        const actualValue = parseInt(formatted);
-        return utilService.dec2bin(actualValue - offset.minValue, offset.length);
-      case 'int':
-        if (offset.minValue || offset.maxValue) {
-          return utilService.dec2bin(formatted, offset.length);
-        }
-        else {
-          const maxValueBinary = getMaxValueBinary(offset);
-          const maxValue = utilService.bin2dec(maxValueBinary);
-          return utilService.dec2bin(formatted + maxValue, offset.length);
+  };
+
+  _parseFieldValue(unformatted, offset) {
+    if (offset.valueInSecondTable) {
+      return this.secondTableField.value;
+    }
+    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;
         }
-      case 'bool':
-        return (formatted == 1 || (formatted.toString().toLowerCase() == 'true')) ? '1' : '0';
-      case 'float':
-        return utilService.float2Bin(formatted);
-      default:
-        return formatted;
+      }
+      catch (err) {
+        // console.log(err);
+      }
+      
+      return enumUnformattedValue;
     }
-  }
+    else if (offset.isReference) {
+      const referenceData = utilService.getReferenceDataFromBitview(this._unformattedValue, this.offset.offset);
+      return utilService.getBinaryReferenceData(referenceData.tableId, referenceData.rowNumber);
+    }
+    else {
+      switch (offset.type) {
+        case 's_int':
+          // return utilService.bin2dec(unformatted) + offset.minValue;
+          return unformatted.getBits(offset.offset, offset.length) + offset.minValue;
+        case 'int':
+          if (offset.minValue || offset.maxValue) {
+            return unformatted.getBits(offset.offset, offset.length);
+          }
+          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 {
+              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;
+      }
+    }
+  };
 };
 
+module.exports = FranchiseFileField;
+
 function getMaxValueBinary(offset) {
   let maxValue = '1';
   for (let j = 0; j < (offset.length - 1); j++) {

package/FranchiseFileRecord.js

@@ -1,79 +1,62 @@
-const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 const FranchiseFileField = require('./FranchiseFileField');
 
-class FranchiseFileRecord extends EventEmitter {
-  constructor(data, index, offsetTable) {
-    super();
+class FranchiseFileRecord {
+  constructor(data, index, offsetTable, parent) {
     this._data = data;
     this._offsetTable = offsetTable;
     this.index = index;
-    this._fields = parseRecordFields(data, offsetTable);
+    this._fieldsArray = [];
+    this._fields = this.parseRecordFields(data, offsetTable, this);
     this.isChanged = false;
     this.arraySize = null;
     this.isEmpty = false;
-
-    const that = this;
-    this._fields.forEach((field) => {
-      Object.defineProperty(this, field.key, {
-        set: function (value) {
-          field.value = value;
-        },
-        get: function () {
-          return field.value;
+    this._parent = parent;
+
+    return new Proxy(this, {
+      get: function (target, prop, receiver) {
+        return target.fields[prop] !== undefined ? target.fields[prop].value : target[prop] !== undefined ? target[prop] : null;
+      },
+      set: function (target, prop, receiver) {
+        if (target.fields[prop] !== undefined) {
+          target.fields[prop].value = receiver;
         }
-      });
-
-      field.on('change', function () {
-        that._data = utilService.replaceAt(that._data, this.offset.offset, this.unformattedValue);
-
-        // NOTE: At this time, we can only change the size of arrays of references.
-        // I'm not sure how to change the size of non-reference arrays, or if it's even possible.
-        if (that.arraySize !== null && that.arraySize !== undefined) {
-          const referenceData = this.referenceData;
-
-          // If the field is outside of the previous array size and was edited to a valid reference,
-          // then reset the array size
-          if (this.offset.index >= that.arraySize) {
-            if (this.isReference) {
-              if (referenceData.tableId !== 0 || referenceData.rowNumber !== 0) {
-                that.arraySize = this.offset.index + 1;
-              }
-            }
-          }
-          
-          // If the value was changed to 0s, then shrink the array size to this index.
-          else if (this.isReference) {
-            if (referenceData.tableId === 0 && referenceData.rowNumber === 0) {
-              that.arraySize = this.offset.index;
-            }
-          }
+        else {
+          target[prop] = receiver;
         }
 
-        that.emit('change', this.offset);
-      });
-    });
+        return true;
+      }
+    })
   };
 
   get hexData () {
-    return Buffer.from(utilService.binaryBlockToDecimalBlock(this._data));
+    return this._data;
   };
 
   get fields () {
     return this._fields;
   };
 
+  get fieldsArray () {
+    return this._fieldsArray;
+  };
+
+  get data() {
+    return this._data;
+  };
+
   set data (data) {
     this._data = data;
 
-    this._fields.forEach((field) => {
+    this._fieldsArray.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; });
+    return this._fields[key];
   };
 
   getValueByKey(key) {
@@ -86,22 +69,57 @@ class FranchiseFileRecord extends EventEmitter {
     return field ? field.referenceData : null;
   };
 
+  parseRecordFields(data, offsetTable, record) {
+    let fields = {};
+  
+    for (let j = 0; j < offsetTable.length; j++) {
+      const offset = offsetTable[j];
+
+      // Push the entire record buffer to the field. No need to perform a calculation
+      // to subarray the buffer, BitView will take care of it in the Field.
+      fields[offset.name] = new FranchiseFileField(offset.name, data, offset, record);
+
+      this._fieldsArray.push(fields[offset.name]);
+    }
+  
+    return fields;
+  };
+
   empty() {
-    this.emit('empty');
+    this._parent.onEvent('empty', this);
     this.isEmpty = true;
   };
-};
 
-module.exports = FranchiseFileRecord;
-
-function parseRecordFields (data, offsetTable) {
-  let fields = [];
+  onEvent(name, field) {
+    if (name === 'change') {
+      // this._data = utilService.replaceAt(this._data, field.offset.offset, field.unformattedValue);
+
+      // NOTE: At field time, we can only change the size of arrays of references.
+      // I'm not sure how to change the size of non-reference arrays, or if it's even possible.
+      if (this.arraySize !== null && this.arraySize !== undefined) {
+        const referenceData = field.referenceData;
+
+        // If the field is outside of the previous array size and was edited to a valid reference,
+        // then reset the array size
+        if (field.offset.index >= this.arraySize) {
+          if (field.isReference) {
+            if (referenceData.tableId !== 0 || referenceData.rowNumber !== 0) {
+              this.arraySize = field.offset.index + 1;
+            }
+          }
+        }
+        
+        // If the value was changed to 0s, then shrink the array size to field index.
+        else if (field.isReference) {
+          if (referenceData.tableId === 0 && referenceData.rowNumber === 0) {
+            this.arraySize = field.offset.index;
+          }
+        }
+      }
 
-  for (let j = 0; j < offsetTable.length; j++) {
-    const offset = offsetTable[j];
-    const unformattedValue = data.slice(offset.offset, offset.offset + offset.length);
-    fields.push(new FranchiseFileField(offset.name, unformattedValue, offset));
-  }
+      this._parent.onEvent('change', this);
+    }
+  };
+};
 
-  return fields;
-};
+module.exports = FranchiseFileRecord;

package/FranchiseFileTable.js

@@ -1,6 +1,7 @@
 const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 const FranchiseFileRecord = require('./FranchiseFileRecord');
+const FranchiseFileTable2Field = require('./FranchiseFileTable2Field');
 
 class FranchiseFileTable extends EventEmitter {
   constructor(data, offset, gameYear, strategy) {
@@ -135,7 +136,7 @@ class FranchiseFileTable extends EventEmitter {
 
     this.records.forEach((record) => {
       let isEmptyReference = false;
-      const firstFourBytesReference = utilService.getReferenceData(record._data.slice(0, 32));
+      const firstFourBytesReference = utilService.getReferenceDataFromBuffer(record.data.slice(0, 4));
 
       if (firstFourBytesReference.tableId === 0 && firstFourBytesReference.rowNumber !== 0) {
         // Could be a an empty record reference or a table2 field.
@@ -246,7 +247,6 @@ class FranchiseFileTable extends EventEmitter {
           reject('Cannot read records: Schema is not defined.');
         }
         
-        
         let offsetTableToUse = this.offsetTable;
         const mandatoryOffsetsToLoad = this.strategy.getMandatoryOffsets(this.offsetTable);
         
@@ -260,7 +260,8 @@ class FranchiseFileTable extends EventEmitter {
         }
         
         this.loadedOffsets = offsetTableToUse;
-        this.records = readRecords(this.data, this.header, offsetTableToUse);
+
+        this.records = readRecords(this.data, this.header, offsetTableToUse, this);
         
         if (this.header.hasSecondTable) {
           this._parseTable2Values(this.data, this.header, this.records);
@@ -276,172 +277,6 @@ class FranchiseFileTable extends EventEmitter {
           if (this.emptyRecords.get(index)) {
             record.isEmpty = true;
           }
-
-          const that = this;
-
-          record.on('change', function (changedOffset) {
-            this.isChanged = true;
-
-            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.
-                      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);
-                  }
-                }
-              }
-            }
-
-            that.emit('change');
-          });
-
-          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 (!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) {
-            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 += that.records[index]._data.slice(32);
-            }
-
-            that.records[index].data = newData;
-          };
-        });
-
-        this.table2Records.forEach((record, index) => {
-          const that = this;
-
-          record.on('change', function (secondTableField) {
-            this.isChanged = true;
-            that.emit('change');
-          });
         });
 
         this.recordsRead = true;
@@ -453,10 +288,8 @@ class FranchiseFileTable extends EventEmitter {
   };
 
   _parseEmptyRecords() {
-    const firstEmptyRecord = this.header.nextRecordToUse;
-    const sizeOfEachRecord = this.header.record1Size;
-    
     let emptyRecords = new Map();
+    const firstEmptyRecord = this.header.nextRecordToUse;
 
     let previousEmptyRecordIndex = null;
     let currentEmptyRecordIndex = firstEmptyRecord;
@@ -464,7 +297,7 @@ class FranchiseFileTable extends EventEmitter {
     if (firstEmptyRecord !== this.header.recordCapacity) {
       while (currentEmptyRecordIndex !== this.header.recordCapacity) {
         // let nextEmptyRecordIndex = this.data.readUInt32BE(this.header.table1StartIndex + (currentEmptyRecordIndex * sizeOfEachRecord));
-        let nextEmptyRecordIndex = utilService.getReferenceData(this.records[currentEmptyRecordIndex]._data.slice(0, 32)).rowNumber;
+        let nextEmptyRecordIndex = this.records[currentEmptyRecordIndex].data.readUInt32BE(0);
 
         emptyRecords.set(currentEmptyRecordIndex, {
           previous: previousEmptyRecordIndex,
@@ -479,21 +312,186 @@ class FranchiseFileTable extends EventEmitter {
     return emptyRecords;
   };
 
+  _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(this.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];
+
+        this.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.
+        this.emptyRecords.set(record.index, {
+          previous: lastEmptyRecordIndex,
+          next: this.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
+        this._changeRecordBuffers(lastEmptyRecordIndex, record.index);
+        this._changeRecordBuffers(record.index, this.header.recordCapacity);
+      }
+      else {
+        // In this case, the record that was emptied is the first empty record in the table
+        this.emptyRecords.set(record.index, {
+          previous: null,
+          next: this.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)
+        this.setNextRecordToUse(record.index);
+        this._changeRecordBuffers(record.index, this.header.recordCapacity);
+      }
+      
+      this.emit('change');
+    }
+  };
 
   _parseTable2Values(data, header, records) {
     const that = this;
     const secondTableData = data.slice(header.table2StartIndex);
   
     records.forEach((record) => {
-      const fieldsReferencingSecondTable = record._fields.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;
         that.table2Records.push(field.secondTableField);
+        field.secondTableField.parent = that;
       });
     });
   };
+
+  _changeRecordBuffers(index, emptyRecordReference) {
+    this._setBufferToEmptyRecordReference(index, emptyRecordReference);
+    this._setRecordInternalBuffer(index, emptyRecordReference);
+  };
+
+  _setBufferToEmptyRecordReference(index, emptyRecordReference) {
+    const recordStartIndex = this.header.table1StartIndex + (index * this.header.record1Size)
+    this.data.writeUInt32BE(emptyRecordReference, recordStartIndex);
+    // that.data.fill(0, recordStartIndex + 4, recordStartIndex + that.header.record1Size);
+  };
+
+  _setRecordInternalBuffer(index, emptyRecordReference) {
+    // let newData = utilService.dec2bin(emptyRecordReference, 32);
+
+    // const recordSizeInBits = this.header.record1Size * 8;
+    // if (recordSizeInBits > 32) {
+    //   newData += this.records[index]._data.slice(32);
+    // }
+
+    // console.log(newData);
+
+    this.records[index]._data.writeUInt32BE(emptyRecordReference, 0);
+  };
+
+  onEvent(name, object) {
+    if (object instanceof FranchiseFileRecord) {
+      if (name === 'change') {
+        object.isChanged = true;
+
+        if (this.isArray) {
+          this.arraySizes[object.index] = object.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 (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);
+          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.getReferenceDataFromBuffer(object.data.slice(0, 4));
+            if (referenceData.tableId !== 0) {
+
+              // 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 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') {
+        this._onRecordEmpty(object);
+        this.emit('change');
+      }
+    }
+    else if (object instanceof FranchiseFileTable2Field) {
+      object.isChanged = true;
+      this.emit('change');
+    }
+  };
 };
 
 module.exports = FranchiseFileTable;
@@ -504,13 +502,17 @@ function readOffsetTable(data, schema, header) {
   // console.log(offsetTable.sort((a,b) => { return a.indexOffset - b.indexOffset}))
   sortOffsetTableByIndexOffset();
 
+  function isSkippedOffset(offset) {
+    return offset.final || offset.const || offset.type.indexOf('()') >= 0 || offset.type === 'ITransaction_Sleep';
+  };
+
   for(let i = 0; i < offsetTable.length; i++) {
     let curOffset = offsetTable[i];
     let nextOffset = offsetTable.length > i + 1 ? offsetTable[i+1] : null;
 
     if (nextOffset) {
       let curIndex = i+2;
-      while(nextOffset && (nextOffset.final || nextOffset.const || nextOffset.type.indexOf('()') >= 0)) {
+      while(nextOffset && isSkippedOffset(nextOffset)) {
         nextOffset = offsetTable[curIndex];
         curIndex += 1;
       }
@@ -541,7 +543,7 @@ function readOffsetTable(data, schema, header) {
       const currentOffset = offsetTable[currentOffsetIndex];
 
       if (currentOffset) {
-        if (currentOffset.final || currentOffset.const || currentOffset.type.indexOf('()') >= 0) {
+        if (isSkippedOffset(currentOffset)) {
           currentOffsetIndex += 1;
           continue;
         }
@@ -571,7 +573,7 @@ function readOffsetTable(data, schema, header) {
     }
   });
 
-  offsetTable = offsetTable.filter((offset) => { return !offset.final && !offset.const && offset.type.indexOf('()') === -1; });
+  offsetTable = offsetTable.filter((offset) => { return !(isSkippedOffset(offset)) });
   offsetTable.sort((a,b) => { return a.offset - b.offset; });
   
   for (let i = 0; i < offsetTable.length; i++) {
@@ -614,15 +616,19 @@ function readOffsetTable(data, schema, header) {
   };
 };
 
-function readRecords(data, header, offsetTable) {
-  const binaryData = utilService.getBitArray(data.slice(header.table1StartIndex, header.table2StartIndex));
-
+function readRecords(data, header, offsetTable, table) {
+  // const binaryData = utilService.getBitArray(data.slice(header.table1StartIndex, header.table2StartIndex));
   let records = [];
 
-  if (binaryData) {
-    for (let i = 0; i < binaryData.length; i += (header.record1Size * 8)) {
-      const recordBinary = binaryData.slice(i, i + (header.record1Size * 8));
-      records.push(new FranchiseFileRecord(recordBinary, (i / (header.record1Size * 8)), offsetTable));
+  if (data) {
+    let index = 0;
+
+    for (let i = header.table1StartIndex; i < header.table2StartIndex; i += header.record1Size) {
+      // const recordBinary = binaryData.slice(i, i + (header.record1Size * 8));
+      let record = new FranchiseFileRecord(data.slice(i, i + header.record1Size), index, offsetTable, table);
+      records.push(record);
+
+      index += 1;
     }
   }
 

package/FranchiseFileTable2Field.js

@@ -1,9 +1,8 @@
 const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 
-class FranchiseFileTable2Field extends EventEmitter {
-  constructor (index, maxLength) {
-    super();
+class FranchiseFileTable2Field {
+  constructor (index, maxLength, parent) {
     this._value = '';
     this.rawIndex = index;
     this.isChanged = false;
@@ -11,8 +10,9 @@ class FranchiseFileTable2Field extends EventEmitter {
     this.fieldReference = null;
     this.lengthAtLastSave = null;
     this._unformattedValue = null;
-    this.index = utilService.bin2dec(index);
+    this.index = index;
     this._offset = this.index;
+    this._parent = parent;
   };
 
   get unformattedValue () {
@@ -25,38 +25,39 @@ class FranchiseFileTable2Field extends EventEmitter {
     if (this.lengthAtLastSave === null) {
       this.lengthAtLastSave = getLengthOfUnformattedValue(this._unformattedValue);
     }
-    
-    let formattedValue = '';
-    const chunked = utilService.chunk(this._unformattedValue, 8);
-    chunked.forEach((chunk) => {
-      formattedValue += String.fromCharCode(parseInt(chunk,2));
-    });
-
-    this._value = formattedValue.replace(/\0.*$/g,'');
-    this.emit('change');
+
+    this._value = null;
+    if (this._parent) {
+      this._parent.onEvent('change', this);
+    }
   };
 
   get value () {
+    if (this._value === null) {
+      this._value = this._unformattedValue.toString().replace(/\0.*$/g,'');
+    }
+
     return this._value;
   };
 
   set value (value) {
+    this._value = value;
+
     if (value.length > this.maxLength) {
       value = value.substring(0, this.maxLength);
     }
     
-    this._value = value;
     this._unformattedValue = this._strategy.setUnformattedValueFromFormatted(value, this.maxLength);
 
     if (this.lengthAtLastSave === null) {
       this.lengthAtLastSave = getLengthOfUnformattedValue(this._unformattedValue);
     }
     
-    this.emit('change');
+    this._parent.onEvent('change', this);
   };
 
   get hexData () {
-    return Buffer.from(utilService.binaryBlockToDecimalBlock(this.unformattedValue));
+    return this._unformattedValue;
   };
 
   get strategy () {
@@ -76,13 +77,21 @@ class FranchiseFileTable2Field extends EventEmitter {
     this.index = offset;
 
     if (this.fieldReference) {
-      this.fieldReference.unformattedValue = utilService.dec2bin(offset, 32);
+      this.fieldReference.unformattedValue.setBits(this.fieldReference.offset.offset, offset, 32);
     }
   };
+
+  get parent() {
+    return this._parent;
+  };
+
+  set parent(parent) {
+    this._parent = parent;
+  };
 };
 
 module.exports = FranchiseFileTable2Field;
 
 function getLengthOfUnformattedValue(value) {
-    return value.length / 8;
+    return value.length;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "2.5.6",
+  "version": "3.0.0",
   "description": "Tools to read a madden franchise file and get data from it",
   "main": "FranchiseFile.js",
   "scripts": {
@@ -13,6 +13,7 @@
   "author": "matthewpanetta",
   "license": "MIT",
   "dependencies": {
+    "bit-buffer": "^0.2.5",
     "node-xml-stream-parser": "^1.0.12"
   },
   "repository": {

package/scripts/getTableId.js

@@ -2,8 +2,17 @@ const FranchiseFile = require('../FranchiseFile');
 
 const franchisePath = 'C:\\Users\\Matt\\Documents\\Madden NFL 20\\settings\\CAREER-M03TEST_MOD';
 
-const file = new FranchiseFile(franchisePath);
-file.on('ready', () => {
-    const tableToFind = file.getTableById(7391);
-    console.log(tableToFind);
-});
+(async () => {
+    const file = new FranchiseFile(franchisePath);
+    file.on('ready', async () => {
+        const tableToFind = file.getTableById(7391);
+        console.log(tableToFind);
+
+        const user = file.getTableByName('FranchiseUser');
+        await user.readRecords();
+        const row = user.records.filter(record => !record.isEmpty).length;
+        console.log(row);
+        const teamSetting = user.records[row].getFieldByKey('TeamSetting');
+        console.log(teamSetting);
+    });
+})();

package/services/utilService.js

@@ -1,3 +1,5 @@
+const { BitView } = require("bit-buffer");
+
 let utilService = {};
 
 utilService.intersection = function (arrayOfArrays) {
@@ -223,6 +225,19 @@ utilService.getReferenceData = function (value) {
   }
 };
 
+utilService.getReferenceDataFromBuffer = (buf) => {
+  let bv = new BitView(buf, buf.byteOffset);
+  bv.bigEndian = true;
+  return utilService.getReferenceDataFromBitview(bv);
+};
+
+utilService.getReferenceDataFromBitview = (bv, start = 0) => {
+  return {
+    tableId: bv.getBits(start, 15),
+    rowNumber: bv.getBits(start+15, 17)
+  };
+};
+
 utilService.getBinaryReferenceData = function (tableId, rowNumber) {
   const referenceBinary = utilService.dec2bin(tableId, 15);
   const recordIndexBinary = utilService.dec2bin(rowNumber, 17);

package/strategies/common/table2Field/FTCTable2FieldStrategy.js

@@ -12,7 +12,7 @@ FTCTable2FieldStrategy.getInitialUnformattedValue = (field, data) => {
         fieldData = fieldData.slice(0, endOfFieldIndex + 1);
     }
 
-    return utilService.getBitArray(fieldData);
+    return fieldData;
 };
 
 FTCTable2FieldStrategy.setUnformattedValueFromFormatted = (formattedValue, maxLength) => {
@@ -20,10 +20,8 @@ FTCTable2FieldStrategy.setUnformattedValueFromFormatted = (formattedValue, maxLe
         // FTC strings cannot equal max length because the last character must be the null character.
         formattedValue = formattedValue.substring(0, maxLength - 1);
     }
-    
-    return formattedValue.split('').map((char) => {
-        return char.charCodeAt(0).toString(2).padStart(8, '0');
-    }).join('') + '00000000';
+
+    return Buffer.from(formattedValue + '\u0000');
 };
 
 module.exports = FTCTable2FieldStrategy;

package/strategies/common/table2Field/FranchiseTable2FieldStrategy.js

@@ -3,7 +3,7 @@ const utilService = require('../../../services/utilService');
 let FranchiseTable2FieldStrategy = {};
 
 FranchiseTable2FieldStrategy.getInitialUnformattedValue = (field, data) => {
-    return utilService.getBitArray(data.slice(field.secondTableField.index, (field.secondTableField.index + field.offset.maxLength)));
+    return data.slice(field.secondTableField.index, (field.secondTableField.index + field.offset.maxLength));
 };
 
 FranchiseTable2FieldStrategy.setUnformattedValueFromFormatted = (formattedValue, maxLength) => {
@@ -18,10 +18,8 @@ FranchiseTable2FieldStrategy.setUnformattedValueFromFormatted = (formattedValue,
     for (let i = 0; i < numberOfNullCharactersToAdd; i++) {
         valuePadded += String.fromCharCode(0);
     }
-    
-    return valuePadded.split('').map((char) => {
-        return char.charCodeAt(0).toString(2).padStart(8, '0');
-    }).join('');
+
+    return Buffer.from(valuePadded);
 };
 
 module.exports = FranchiseTable2FieldStrategy;