madden-franchise 2.5.4 → 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/FranchiseFile.js

@@ -113,7 +113,7 @@ class FranchiseFile extends EventEmitter {
 
       for (let i = 0; i < tableIndicies.length; i++) {
         const currentTable = tableIndicies[i];
-        const nextTable = tableIndicies.length >= i+1 ? tableIndicies[i+1] : null;
+        const nextTable = tableIndicies.length > i+1 ? tableIndicies[i+1] : this.unpackedFileContents.length - 8;  // Ignore trailing 8 bytes on last table
 
         const tableData = this.unpackedFileContents.slice(currentTable, nextTable);
 

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;