madden-franchise 3.0.4 → 3.0.6

package/FranchiseFile.js

@@ -276,7 +276,7 @@ class FranchiseFile extends EventEmitter {
 
   getReferencedRecord (referenceValue) {
     const reference = utilService.getReferenceData(referenceValue);
-    return this.getTableById(reference.tableId).records[reference.rowNumber];
+    return this.getTableById(reference.tableId)?.records[reference.rowNumber];
   };
 
   getReferenceFromAssetId (assetId) {
@@ -433,7 +433,7 @@ function getGameYear(data, isCompressed, format) {
       'max': 95
     },
     {
-      'year': 22,
+      'year': 24,
       'max': 999
     }
   ];
@@ -468,6 +468,9 @@ function getGameYear(data, isCompressed, format) {
     else if (yearIdentifier[2] === 0x33) {
       return 23;
     }
+    else if (yearIdentifier[2] === 0x34 || yearIdentifier[2] === 'd') {
+      return 24;
+    }
     else {
       const schemaMajor = getCompressedSchema(data).major;
       const year = schemaMax.find((schema) => { return schema.max >= schemaMajor; }).year;

package/FranchiseFileField.js

@@ -10,6 +10,7 @@ class FranchiseFileField {
     this._unformattedValue = null;
     this._offset = offset;
     this._parent = parent;
+    this._isChanged = false;
 
     if (offset.valueInSecondTable) {
       this.secondTableField = new FranchiseFileTable2Field(this._recordBuffer.readUInt32BE(offset.offset / 8), offset.maxLength);
@@ -53,12 +54,13 @@ class FranchiseFileField {
     return null;
   };
 
-  set value (value) {    
+  set value (value) {
     if (this._unformattedValue === null) {
       this._setUnformattedValueIfEmpty();
     }
 
     this._value = value;
+    this.isChanged = true;
 
     if (this.offset.valueInSecondTable) {
       this.secondTableField.value = value.toString();
@@ -83,8 +85,15 @@ class FranchiseFileField {
           this._value = theEnum.name;
         }
         catch (err) {
-          this._value = null;
-          throw 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 {
+            this._value = null;
+            throw err;
+          }
         }
       }
       else {
@@ -149,6 +158,19 @@ class FranchiseFileField {
     this._parent.onEvent('change', this);
   };
 
+  get isChanged() {
+    return this._isChanged;
+  };
+
+  set isChanged(changed) {
+    this._isChanged = changed;
+  };
+
+  clearCachedValues() {
+    this._value = null;
+    this._unformattedValue = null;
+  };
+
   _setUnformattedValueIfEmpty() {
     this._value = null;
     this._unformattedValue = new BitView(this._recordBuffer, this._recordBuffer.byteOffset);

package/FranchiseFileRecord.js

@@ -7,8 +7,8 @@ class FranchiseFileRecord {
     this._offsetTable = offsetTable;
     this.index = index;
     this._fieldsArray = [];
-    this._fields = this.parseRecordFields(data, offsetTable, this);
-    this.isChanged = false;
+    this._fields = this.parseRecordFields();
+    this._isChanged = false;
     this.arraySize = null;
     this.isEmpty = false;
     this._parent = parent;
@@ -55,6 +55,20 @@ class FranchiseFileRecord {
     });
   };
 
+  get isChanged() {
+    return this._isChanged;
+  };
+
+  set isChanged(changed) {
+    this._isChanged = changed;
+
+    if (changed === false) {
+      this.fieldsArray.forEach((field) => {
+        field.isChanged = false;
+      });
+    }
+  }
+
   getFieldByKey(key) {
     return this._fields[key];
   };
@@ -69,15 +83,16 @@ class FranchiseFileRecord {
     return field ? field.referenceData : null;
   };
 
-  parseRecordFields(data, offsetTable, record) {
+  parseRecordFields() {
     let fields = {};
+    this._fieldsArray = [];
   
-    for (let j = 0; j < offsetTable.length; j++) {
-      const offset = offsetTable[j];
+    for (let j = 0; j < this._offsetTable.length; j++) {
+      const offset = this._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);
+      fields[offset.name] = new FranchiseFileField(offset.name, this._data, offset, this);
 
       this._fieldsArray.push(fields[offset.name]);
     }

package/FranchiseFileTable.js

@@ -145,7 +145,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);
         }
@@ -154,7 +154,6 @@ class FranchiseFileTable extends EventEmitter {
       record.isEmpty = isEmptyReference;
     });
 
-
     // 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) => {
@@ -439,6 +438,21 @@ class FranchiseFileTable extends EventEmitter {
               // 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 (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 the record contains any string values, point the string values to
               // their correct offsets
               this.strategy.recalculateStringOffsets(this, object);

package/package.json

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

package/scripts/scratchpad.js

@@ -0,0 +1,38 @@
+const FranchiseFile = require('../FranchiseFile');
+const utilService = require('../services/utilService');
+
+const franchisePath = 'C:\\Users\\Matt\\Downloads\\CAREER-COACHTEST';
+const ftcPath = 'D:\\Projects\\Madden 24\\FTCs\\franchise-league-binary.FTC';
+const schemaPath = 'C:\\Users\\Matt\\AppData\\Roaming\\madden-franchise-editor\\schemas\\M24_144_6.gz';
+
+(async () => {
+    function franchiseFileLoadPromise(file) {
+        return new Promise((resolve, reject) => {
+            file.on('ready', () => {
+                resolve();
+            });
+        });
+    };
+
+    const file = new FranchiseFile(franchisePath, {
+        schemaOverride: {
+            path: schemaPath
+        }
+    });
+
+    const ftc = new FranchiseFile(ftcPath, {
+        schemaOverride: {
+            path: schemaPath
+        }
+    });
+
+    await Promise.all([franchiseFileLoadPromise(file), franchiseFileLoadPromise(ftc)]);
+    
+    const tableToFind = file.getTableById(4227);
+    await tableToFind.readRecords();
+
+    const college = tableToFind.records[2].getFieldByKey('College');
+    const collegeVal = utilService.bin2dec(college.value);
+    const ref = ftc.getReferenceFromAssetId(collegeVal);
+    console.log(ref);
+})();