madden-franchise 3.0.6 → 3.2.0

package/FranchiseFile.js

@@ -117,7 +117,7 @@ class FranchiseFile extends EventEmitter {
 
         const tableData = this.unpackedFileContents.slice(currentTable, nextTable);
 
-        const newFranchiseTable = new FranchiseFileTable(tableData, currentTable, this._gameYear, this.strategy);
+        const newFranchiseTable = new FranchiseFileTable(tableData, currentTable, this._gameYear, this.strategy, this.settings);
         newFranchiseTable.index = i;
         this.tables.push(newFranchiseTable);
 

package/FranchiseFileField.js

@@ -2,6 +2,7 @@ const { BitView } = require('bit-buffer');
 
 const utilService = require('./services/utilService');
 const FranchiseFileTable2Field = require('./FranchiseFileTable2Field');
+const FranchiseFileTable3Field = require('./FranchiseFileTable3Field');
 
 class FranchiseFileField {
   constructor(key, value, offset, parent) {
@@ -16,6 +17,11 @@ 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 () {
@@ -64,7 +70,18 @@ class FranchiseFileField {
 
     if (this.offset.valueInSecondTable) {
       this.secondTableField.value = value.toString();
-    } else {
+    }
+    else if (this.offset.valueInThirdTable) {
+      if (typeof value === 'object') {
+        const newVal = JSON.stringify(value);
+        this._value = newVal;
+        this.thirdTableField.value = newVal;
+      }
+      else {
+        this.thirdTableField.value = value.toString();
+      }
+    }
+    else {
       let actualValue;
 
       if (this.offset.isReference) {
@@ -214,6 +231,9 @@ class FranchiseFileField {
     if (offset.valueInSecondTable) {
       return this.secondTableField.value;
     }
+    else if (offset.valueInThirdTable) {
+      return this.thirdTableField.value;
+    }
     else if (offset.enum) {
       const enumUnformattedValue = utilService.dec2bin(this.unformattedValue.getBits(this.offset.offset, this.offset.length), offset.enum._maxLength);
       

package/FranchiseFileSettings.js

@@ -3,7 +3,8 @@ class FranchiseFileSettings {
     this.saveOnChange = settings && settings.saveOnChange ? settings.saveOnChange : false;
     this.schemaOverride = settings && settings.schemaOverride ? settings.schemaOverride: false;
     this.schemaDirectory = settings && settings.schemaDirectory ? settings.schemaDirectory : false;
-    this.autoParse = settings && (settings.autoParse !== null && settings.autoParse !== undefined) ? settings.autoParse : true
+    this.autoParse = settings && (settings.autoParse !== null && settings.autoParse !== undefined) ? settings.autoParse : true;
+    this.autoUnempty = settings && (settings.autoUnempty !== null && settings.autoUnempty !== undefined) ? settings.autoUnempty : false;
   }
 };
 

package/FranchiseFileTable.js

@@ -2,9 +2,10 @@ const EventEmitter = require('events').EventEmitter;
 const utilService = require('./services/utilService');
 const FranchiseFileRecord = require('./FranchiseFileRecord');
 const FranchiseFileTable2Field = require('./FranchiseFileTable2Field');
+const FranchiseFileTable3Field = require('./FranchiseFileTable3Field');
 
 class FranchiseFileTable extends EventEmitter {
-  constructor(data, offset, gameYear, strategy) {
+  constructor(data, offset, gameYear, strategy, settings) {
     super();
     this.index = -1;
     this.data = data;
@@ -21,8 +22,10 @@ class FranchiseFileTable extends EventEmitter {
     this.isChanged = false;
     this.records = [];
     this.table2Records = [];
+    this.table3Records = [];
     this.arraySizes = [];
     this.emptyRecords = new Map();
+    this._settings = settings;
   };
 
   get hexData () {
@@ -51,22 +54,31 @@ class FranchiseFileTable extends EventEmitter {
   };
   
   updateBuffer() {
-    // need to check table2 data first because it may change offsets of the legit records.
-    const table2Data = this.strategy.getTable2BinaryData(this.table2Records, this.data.slice(this.header.table2StartIndex));
+    // 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 = 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;
+      let table3DataLength = 0;
 
       // Get length of all table2Data sub arrays
       table2Data.forEach((arr) => {
         table2DataLength += arr.length;
       });
 
+      table3Data.forEach((arr) => {
+        table3DataLength += arr.length;
+      });
+
       this.header.table2Length = table2DataLength;
       this.header.tableTotalLength = this.header.table1Length + this.header.table2Length;
 
+      this.header.table3Length = table3DataLength;
+
       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);
     }
 
@@ -102,8 +114,19 @@ class FranchiseFileTable extends EventEmitter {
     }
 
     bufferArrays.push(this.data.slice(currentOffset, this.header.table2StartIndex));
+
+    if (!this.recordsRead && this.header.hasSecondTable && table2Data.length === 0) {
+      table2Data = this.data.slice(this.header.table2StartIndex);
+    }
+
     bufferArrays = bufferArrays.concat(table2Data);
 
+    if (!this.recordsRead && this.header.hasThirdTable && table3Data.length === 0) {
+      table3Data = this.data.slice(this.header.table3StartIndex);
+    }
+
+    bufferArrays = bufferArrays.concat(table3Data);
+
     this.data = Buffer.concat(bufferArrays);
   };
 
@@ -195,6 +218,7 @@ class FranchiseFileTable extends EventEmitter {
     this.isChanged = false;
     this.records = [];
     this.table2Records = [];
+    this.table3Records = [];
     this.arraySizes = [];
     this.emptyRecords = new Map();
 
@@ -230,7 +254,8 @@ class FranchiseFileTable extends EventEmitter {
               'name': `${this.name.substring(0, this.name.length - 2)}${i}`,
               'offset': i * 32,
               'type': this.name.substring(0, this.name.length - 2),
-              'valueInSecondTable': false
+              'valueInSecondTable': false,
+              'valueInThirdTable': false,
             }
             
             offset.isReference = !offset.enum && (offset.type[0] == offset.type[0].toUpperCase() || offset.type.includes('[]')) ? true : false,
@@ -268,6 +293,10 @@ class FranchiseFileTable extends EventEmitter {
           this._parseTable2Values(this.data, this.header, this.records);
         }
 
+        if (this.header.hasThirdTable) {
+          this._parseTable3Values(this.data, this.header, this.records);
+        }
+
         this.emptyRecords = this._parseEmptyRecords();
 
         this.records.forEach((record, index) => {
@@ -379,6 +408,22 @@ 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; });
+  
+      fieldsReferencingThirdTable.forEach((field) => {
+        field.thirdTableField.unformattedValue = that.strategyBase.table3Field.getInitialUnformattedValue(field, thirdTableData);
+        field.thirdTableField.strategy = that.strategyBase.table3Field;
+        that.table3Records.push(field.thirdTableField);
+        field.thirdTableField.parent = that;
+      });
+    });
+  };
 
   _changeRecordBuffers(index, emptyRecordReference) {
     this._setBufferToEmptyRecordReference(index, emptyRecordReference);
@@ -426,10 +471,8 @@ class FranchiseFileTable extends EventEmitter {
           const emptyRecordReference = this.emptyRecords.get(object.index);
           const changedRecordWasEmpty = emptyRecordReference !== null && emptyRecordReference !== undefined;
 
+          // Automatically un-empty the row if the setting is enabled and the changed record was empty.
           if (changedRecordWasEmpty) {
-            // 1/5/23: Assume all changes to a field make the record not empty. Leaving comments
-            // below if this needs to be reverted in the future.
-            
 
               // 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.
@@ -442,7 +485,7 @@ class FranchiseFileTable extends EventEmitter {
               // 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) {
+              if (this._settings.autoUnempty && changedFieldsInFirst4Bytes.length === 0) {
                 // set first 4 bytes to 0
                 this._changeRecordBuffers(object.index, 0);
 
@@ -452,53 +495,57 @@ class FranchiseFileTable extends EventEmitter {
                   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);
+
+                // 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 the record contains any string values, point the string values to
-              // their correct offsets
-              this.strategy.recalculateStringOffsets(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 (!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);
+                // 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);
+                }
               }
             // }
           }
@@ -511,7 +558,7 @@ class FranchiseFileTable extends EventEmitter {
         this.emit('change');
       }
     }
-    else if (object instanceof FranchiseFileTable2Field) {
+    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. 
@@ -633,6 +680,7 @@ function readOffsetTable(data, schema, header) {
         'type': (minValue < 0 || maxValue < 0) ? 's_' + attribute.type : attribute.type,
         'isReference': !attribute.enum && (attribute.type[0] == attribute.type[0].toUpperCase() || attribute.type.includes('[]') || attribute.type === 'record') ? true : false,
         'valueInSecondTable': header.hasSecondTable && attribute.type === 'string',
+        'valueInThirdTable': header.hasThirdTable && attribute.type === 'binaryblob',
         'isSigned': minValue < 0 || maxValue < 0,
         'minValue': minValue,
         'maxValue': maxValue,

package/FranchiseFileTable3Field.js

@@ -0,0 +1,92 @@
+const EventEmitter = require('events').EventEmitter;
+const utilService = require('./services/utilService');
+
+class FranchiseFileTable3Field {
+  constructor (index, maxLength, parent) {
+    this._value = '';
+    this.rawIndex = index;
+    this.isChanged = false;
+    this.maxLength = maxLength;
+    this.fieldReference = null;
+    this.lengthAtLastSave = null;
+    this._unformattedValue = null;
+    this.index = index;
+    this._offset = this.index;
+    this._parent = parent;
+  };
+
+  get unformattedValue () {
+    return this._unformattedValue;
+  };
+
+  set unformattedValue (value) {
+    this._unformattedValue = value;
+
+    if (this.lengthAtLastSave === null) {
+      this.lengthAtLastSave = getLengthOfUnformattedValue(this._unformattedValue);
+    }
+
+    this._value = null;
+    if (this._parent) {
+      this._parent.onEvent('change', this);
+    }
+  };
+
+  get value () {
+    if (this._value === null) {
+      this._value = this._strategy.getFormattedValueFromUnformatted(this._unformattedValue);
+    }
+
+    return this._value;
+  };
+
+  set value (value) {
+    this._value = value;    
+    this._unformattedValue = this._strategy.setUnformattedValueFromFormatted(value, this.maxLength);
+
+    if (this.lengthAtLastSave === null) {
+      this.lengthAtLastSave = getLengthOfUnformattedValue(this._unformattedValue);
+    }
+    
+    this._parent.onEvent('change', this);
+  };
+
+  get hexData () {
+    return this._unformattedValue;
+  };
+
+  get strategy () {
+    return this._strategy;
+  };
+
+  set strategy (strategy) {
+    this._strategy = strategy;
+  };
+
+  get offset () {
+    return this._offset;
+  };
+
+  set offset (offset) {
+    this._offset = offset;
+    this.index = offset;
+
+    if (this.fieldReference) {
+      this.fieldReference.unformattedValue.setBits(this.fieldReference.offset.offset, offset, 32);
+    }
+  };
+
+  get parent() {
+    return this._parent;
+  };
+
+  set parent(parent) {
+    this._parent = parent;
+  };
+};
+
+module.exports = FranchiseFileTable3Field;
+
+function getLengthOfUnformattedValue(value) {
+    return value.length;
+};

package/README.md

@@ -49,6 +49,10 @@ Franchise file settings
 
       // AUTO PARSE - specify if you want the system to automatically parse all tables in the file, or if you want to explicity call file.parse()
       'autoParse': true/false [default: true]
+
+      // AUTO UNEMPTY - specify if you want the system to automatically determine if an empty field should become un-empty once you edit it.
+      // Warning: may have unintended side-effects if you batch import. Enable with caution.
+      'autoUnempty': true/false [default: false]
     }
 
 #### fields

package/package.json

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

package/scripts/scratchpad.js

@@ -1,7 +1,10 @@
+const fs = require('fs');
+const zlib = require('zlib');
+
 const FranchiseFile = require('../FranchiseFile');
 const utilService = require('../services/utilService');
 
-const franchisePath = 'C:\\Users\\Matt\\Downloads\\CAREER-COACHTEST';
+const franchisePath = 'C:\\Users\\Matt\\Documents\\Madden NFL 24\\saves\\CAREER-FANTASY';
 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';
 
@@ -15,24 +18,35 @@ const schemaPath = 'C:\\Users\\Matt\\AppData\\Roaming\\madden-franchise-editor\\
     };
 
     const file = new FranchiseFile(franchisePath, {
-        schemaOverride: {
-            path: schemaPath
-        }
+        // schemaOverride: {
+        //     path: schemaPath
+        // }
     });
 
-    const ftc = new FranchiseFile(ftcPath, {
-        schemaOverride: {
-            path: schemaPath
-        }
-    });
+    // const ftc = new FranchiseFile(ftcPath, {
+    //     schemaOverride: {
+    //         path: schemaPath
+    //     }
+    // });
 
-    await Promise.all([franchiseFileLoadPromise(file), franchiseFileLoadPromise(ftc)]);
+    // await Promise.all([franchiseFileLoadPromise(file), franchiseFileLoadPromise(ftc)]);
     
-    const tableToFind = file.getTableById(4227);
-    await tableToFind.readRecords();
+    // 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);
+
+    await franchiseFileLoadPromise(file);
+
+    const table3s = file.tables.filter((table) => { return table.header.data1Pad4 > 0; });
+    table3s.forEach((table) => { console.log(`${table.header.tableId} - ${table.name}`)});
 
-    const college = tableToFind.records[2].getFieldByKey('College');
-    const collegeVal = utilService.bin2dec(college.value);
-    const ref = ftc.getReferenceFromAssetId(collegeVal);
-    console.log(ref);
+    const buf = fs.readFileSync('D:\\Projects\\Madden 24\\franchise\\characterVisualIsolated.dat');
+    const test = zlib.gunzipSync(buf.subarray(2));
+    // fs.writeFileSync('D:\\Projects\\Madden 24\\franchise\\characterVisualUnzipped.dat', test);
+    const test2 = zlib.gzipSync(test);
+    console.log(test2);
 })();

package/strategies/StrategyPicker.js

@@ -1,6 +1,7 @@
 const Constants = require('../Constants');
 const M19Strategy = require('./franchise/m19/M19Strategy');
 const M20Strategy = require('./franchise/m20/M20Strategy');
+const M24Strategy = require('./franchise/m24/M24Strategy');
 const M19FTCStrategy = require('./franchise-common/m19/M19FTCStrategy');
 const M20FTCStrategy = require('./franchise-common/m20/M20FTCStrategy');
 
@@ -13,8 +14,12 @@ StrategyPicker.pick = (type) => {
                 return M19Strategy;
             case 20:
             case 21:
+            case 22:
+            case 23:
             default:
                 return M20Strategy;
+            case 24:
+                return M24Strategy;
         }
     }
     else {

package/strategies/common/header/m19/M19TableHeaderStrategy.js

@@ -99,7 +99,8 @@ M19TableHeaderStrategy.parseHeader = (data) => {
         'recordWords': data2RecordWords,
         'recordCapacity': data2RecordCapacity,
         'numMembers': data2IndexEntries,
-        'nextRecordToUse': nextRecordToUse
+        'nextRecordToUse': nextRecordToUse,
+        'hasThirdTable': false
     };
 };
 

package/strategies/common/header/m20/M20TableHeaderStrategy.js

@@ -108,7 +108,8 @@ M20TableHeaderStrategy.parseHeader = (data) => {
         'recordWords': data2RecordWords,
         'recordCapacity': data2RecordCapacity,
         'numMembers': data2IndexEntries,
-        'nextRecordToUse': nextRecordToUse
+        'nextRecordToUse': nextRecordToUse,
+        'hasThirdTable': false
     };
 };
 

package/strategies/common/header/m24/M24TableHeaderStrategy.js

@@ -0,0 +1,15 @@
+const M20TableHeaderStrategy = require("../m20/M20TableHeaderStrategy");
+
+let M24TableHeaderStrategy = {};
+
+M24TableHeaderStrategy.parseHeader = (data) => {
+    let header = M20TableHeaderStrategy.parseHeader(data);
+    
+    header.table3Length = header.data1Pad3;
+    header.hasThirdTable = header.table3Length > 0;
+    header.table3StartIndex = header.table2StartIndex + header.table2Length;
+
+    return header;
+};
+
+module.exports = M24TableHeaderStrategy;

package/strategies/common/table/FranchiseTableStrategy.js

@@ -24,7 +24,9 @@ FranchiseTableStrategy.getTable2BinaryData = (table2Records, fullTable2Buffer) =
         currentOffset = recordOffset + recordHexData.length;
     }
 
-    table2Data.push(fullTable2Buffer.slice(currentOffset));
+    if (table2Records.length > 0) {
+        table2Data.push(fullTable2Buffer.slice(currentOffset));
+    }
 
     return table2Data;
 };

package/strategies/common/table3Field/FranchiseTable3FieldStrategy.js

@@ -0,0 +1,24 @@
+const zlib = require('zlib');
+
+let FranchiseTable3FieldStrategy = {};
+
+FranchiseTable3FieldStrategy.getInitialUnformattedValue = (field, data) => {
+    return data.slice(field.thirdTableField.index, (field.thirdTableField.index + field.offset.maxLength + 2)); 
+    // extend maxLength + 2 because the first 2 bytes are the size of the zipped data
+};
+
+FranchiseTable3FieldStrategy.getFormattedValueFromUnformatted = (unformattedValue) => {
+    return zlib.gunzipSync(unformattedValue.subarray(2)).toString();    // first 2 bytes are the size of the zipped data, so skip those.
+};
+
+FranchiseTable3FieldStrategy.setUnformattedValueFromFormatted = (formattedValue, maxLength) => {
+    let zippedData = zlib.gzipSync(formattedValue);
+    let padding = Buffer.alloc(maxLength - zippedData.length);  // table3s all have the same length and are zero padded to the end.
+
+    let sizeBuf = Buffer.alloc(2);
+    sizeBuf.writeUInt16LE(zippedData.length);
+
+    return Buffer.concat([sizeBuf, zippedData, padding]);
+};
+
+module.exports = FranchiseTable3FieldStrategy;

package/strategies/franchise/m19/M19Strategy.js

@@ -1,10 +1,12 @@
 const M19FileStrategy = require('./M19FileStrategy');
 const M19TableStrategy = require('./M19TableStrategy');
 const M19Table2FieldStrategy = require('./M19Table2FieldStrategy');
+const M24Table3Strategy = require('../m24/M24Table3FieldStrategy');
 
 module.exports = {
     'name': 'M19Strategy',
     'file': M19FileStrategy,
     'table': M19TableStrategy,
-    'table2Field': M19Table2FieldStrategy
+    'table2Field': M19Table2FieldStrategy,
+    'table3Field': M24Table3Strategy
 };

package/strategies/franchise/m19/M19TableStrategy.js

@@ -7,6 +7,7 @@ M19TableStrategy.parseHeader = M19TableHeaderStrategy.parseHeader;
 M19TableStrategy.parseHeaderAttributesFromSchema = M19TableHeaderStrategy.parseHeaderAttributesFromSchema;
 
 M19TableStrategy.getTable2BinaryData = FranchiseTableStrategy.getTable2BinaryData;
+M19TableStrategy.getTable3BinaryData = FranchiseTableStrategy.getTable2BinaryData;
 M19TableStrategy.getMandatoryOffsets = FranchiseTableStrategy.getMandatoryOffsets;
 M19TableStrategy.recalculateStringOffsets = FranchiseTableStrategy.recalculateStringOffsets;
 

package/strategies/franchise/m20/M20Strategy.js

@@ -1,10 +1,12 @@
 const M20FileStrategy = require('./M20FileStrategy');
 const M20TableStrategy = require('./M20TableStrategy');
 const M20Table2FieldStrategy = require('./M20Table2FieldStrategy');
+const M24Table3FieldStrategy = require('../m24/M24Table3FieldStrategy');
 
 module.exports = {
     'name': 'M20Strategy',
     'file': M20FileStrategy,
     'table': M20TableStrategy,
-    'table2Field': M20Table2FieldStrategy
+    'table2Field': M20Table2FieldStrategy,
+    'table3Field': M24Table3FieldStrategy
 };

package/strategies/franchise/m20/M20TableStrategy.js

@@ -7,6 +7,7 @@ M20TableStrategy.parseHeader = M20TableHeaderStrategy.parseHeader;
 M20TableStrategy.parseHeaderAttributesFromSchema = M20TableHeaderStrategy.parseHeaderAttributesFromSchema;
 
 M20TableStrategy.getTable2BinaryData = FranchiseTableStrategy.getTable2BinaryData;
+M20TableStrategy.getTable3BinaryData = FranchiseTableStrategy.getTable2BinaryData;
 M20TableStrategy.getMandatoryOffsets = FranchiseTableStrategy.getMandatoryOffsets;
 M20TableStrategy.recalculateStringOffsets = FranchiseTableStrategy.recalculateStringOffsets;
 

package/strategies/franchise/m24/M24Strategy.js

@@ -0,0 +1,12 @@
+const M20FileStrategy = require('../m20/M20FileStrategy');
+const M24TableStrategy = require('./M24TableStrategy');
+const M20Table2FieldStrategy = require('../m20/M20Table2FieldStrategy');
+const M24Table3FieldStrategy = require('./M24Table3FieldStrategy');
+
+module.exports = {
+    'name': 'M24Strategy',
+    'file': M20FileStrategy,
+    'table': M24TableStrategy,
+    'table2Field': M20Table2FieldStrategy,
+    'table3Field': M24Table3FieldStrategy
+};

package/strategies/franchise/m24/M24Table3FieldStrategy.js

@@ -0,0 +1,9 @@
+const FranchiseTable3FieldStrategy = require('../../common/table3Field/FranchiseTable3FieldStrategy');
+
+let M24Table3Strategy = {};
+
+M24Table3Strategy.getInitialUnformattedValue = FranchiseTable3FieldStrategy.getInitialUnformattedValue;
+M24Table3Strategy.getFormattedValueFromUnformatted = FranchiseTable3FieldStrategy.getFormattedValueFromUnformatted;
+M24Table3Strategy.setUnformattedValueFromFormatted = FranchiseTable3FieldStrategy.setUnformattedValueFromFormatted;
+
+module.exports = M24Table3Strategy;

package/strategies/franchise/m24/M24TableStrategy.js

@@ -0,0 +1,15 @@
+const FranchiseTableStrategy = require('../../common/table/FranchiseTableStrategy');
+const M20TableHeaderStrategy = require('../../common/header/m20/M20TableHeaderStrategy');
+const M24TableHeaderStrategy = require('../../common/header/m24/M24TableHeaderStrategy');
+
+let M24TableStrategy = {};
+
+M24TableStrategy.parseHeader = M24TableHeaderStrategy.parseHeader;
+M24TableStrategy.parseHeaderAttributesFromSchema = M20TableHeaderStrategy.parseHeaderAttributesFromSchema;
+
+M24TableStrategy.getTable2BinaryData = FranchiseTableStrategy.getTable2BinaryData;
+M24TableStrategy.getTable3BinaryData = FranchiseTableStrategy.getTable2BinaryData;
+M24TableStrategy.getMandatoryOffsets = FranchiseTableStrategy.getMandatoryOffsets;
+M24TableStrategy.recalculateStringOffsets = FranchiseTableStrategy.recalculateStringOffsets;
+
+module.exports = M24TableStrategy;

package/strategies/franchise-common/m19/M19FTCStrategy.js

@@ -1,10 +1,12 @@
 const M19FTCFileStrategy = require('./M19FTCFileStrategy');
 const M19FTCTableStrategy = require('./M19FTCTableStrategy');
 const M19FTCTable2FieldStrategy = require('./M19FTCTable2FieldStrategy');
+const M24Table3Strategy = require('../../franchise/m24/M24Table3FieldStrategy');
 
 module.exports = {
     'name': 'M19FTCStrategy',
     'file': M19FTCFileStrategy,
     'table': M19FTCTableStrategy,
-    'table2Field': M19FTCTable2FieldStrategy
+    'table2Field': M19FTCTable2FieldStrategy,
+    'table3Field': M24Table3Strategy
 };

package/strategies/franchise-common/m19/M19FTCTableStrategy.js

@@ -7,6 +7,7 @@ M19FTCTableStrategy.parseHeader = M19TableHeaderStrategy.parseHeader;
 M19FTCTableStrategy.parseHeaderAttributesFromSchema = M19TableHeaderStrategy.parseHeaderAttributesFromSchema;
 
 M19FTCTableStrategy.getTable2BinaryData = FTCTableStrategy.getTable2BinaryData;
+M19FTCTableStrategy.getTable3BinaryData = FTCTableStrategy.getTable2BinaryData;
 M19FTCTableStrategy.getMandatoryOffsets = FTCTableStrategy.getMandatoryOffsets;
 M19FTCTableStrategy.recalculateStringOffsets = () => {};
 

package/strategies/franchise-common/m20/M20FTCStrategy.js

@@ -1,10 +1,12 @@
 const M20FTCFileStrategy = require('./M20FTCFileStrategy');
 const M20FTCTableStrategy = require('./M20FTCTableStrategy');
 const M20FTCTable2FieldStrategy = require('./M20FTCTable2FieldStrategy');
+const M24Table3Strategy = require('../../franchise/m24/M24Table3FieldStrategy');
 
 module.exports = {
     'name': 'M20FTCStrategy',
     'file': M20FTCFileStrategy,
     'table': M20FTCTableStrategy,
-    'table2Field': M20FTCTable2FieldStrategy
+    'table2Field': M20FTCTable2FieldStrategy,
+    'table3Field': M24Table3Strategy
 };

package/strategies/franchise-common/m20/M20FTCTableStrategy.js

@@ -7,6 +7,7 @@ M20FTCTableStrategy.parseHeader = M20TableHeaderStrategy.parseHeader;
 M20FTCTableStrategy.parseHeaderAttributesFromSchema = M20TableHeaderStrategy.parseHeaderAttributesFromSchema;
 
 M20FTCTableStrategy.getTable2BinaryData = FTCTableStrategy.getTable2BinaryData;
+M20FTCTableStrategy.getTable3BinaryData = FTCTableStrategy.getTable2BinaryData;
 M20FTCTableStrategy.getMandatoryOffsets = FTCTableStrategy.getMandatoryOffsets;
 M20FTCTableStrategy.recalculateStringOffsets = () => {};