Merge pull request #25 from primetime43/dev

Dev to main v2.1.0

Author: primetime43

.github/workflows/release.yml

@@ -0,0 +1,64 @@
+name: Build and Release
+
+on:
+  push:
+    tags:
+      - 'v*'  # Triggers on version tags like v1.0.0, v2.0.0, etc.
+  workflow_dispatch:  # Allows manual trigger from GitHub UI
+    inputs:
+      version:
+        description: 'Version tag (e.g., v2.1.0)'
+        required: true
+        type: string
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '8.0.x'
+
+    - name: Restore dependencies
+      run: dotnet restore "Call of Duty FastFile Editor.sln"
+
+    - name: Build and Publish
+      run: |
+        dotnet publish "Call of Duty FastFile Editor/Call of Duty FastFile Editor.csproj" `
+          -c Release `
+          -r win-x64 `
+          --self-contained false `
+          -p:PublishSingleFile=true `
+          -p:IncludeNativeLibrariesForSelfExtract=true `
+          -o ./publish
+
+    - name: List published files
+      run: Get-ChildItem -Path ./publish -Recurse
+
+    - name: Get version from tag
+      id: get_version
+      shell: bash
+      run: |
+        if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+          echo "VERSION=${{ github.event.inputs.version }}" >> $GITHUB_OUTPUT
+        else
+          echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Create Release
+      uses: softprops/action-gh-release@v1
+      with:
+        tag_name: ${{ steps.get_version.outputs.VERSION }}
+        name: Release ${{ steps.get_version.outputs.VERSION }}
+        draft: false
+        prerelease: false
+        generate_release_notes: true
+        files: |
+          ./publish/Call of Duty FastFile Editor.exe
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Call of Duty FastFile Editor/Constants/ApplicationConstants.cs

@@ -3,7 +3,7 @@
     public static class ApplicationConstants
     {
         public const string ProgramName = "Call of Duty Fast File Editor for PS3";
-        public const string ProgramVersion = "v2.0.0";
+        public const string ProgramVersion = "v2.1.0";
         public const string About = $"{ProgramName}\n" +
              "Version: " + ProgramVersion + "\n\n" +
              "Developed by primetime43\n\n" +

Call of Duty FastFile Editor/IO/FastFileHandlerBase.cs

@@ -116,7 +116,8 @@ public void Recompress(string ffFilePath, string zoneFilePath, FastFile openedFa
 
                     binaryWriter.Write(compressedChunk);
                 }
-                binaryWriter.Write(new byte[2] { 0, 1 });
+                // Note: No terminator is written. Original FastFiles end after the last
+                // compressed chunk. The game detects EOF by reading past end of file.
             }
         }
 

Call of Duty FastFile Editor/Models/RawFileNode.cs

@@ -60,8 +60,8 @@ public RawFileNode(string name, byte[] buffer)
         public int CodeStartPosition => StartOfFileHeader + 12 + (FileName?.Length ?? 0) + 1;
 
         /// <summary>
-        /// Gets the position where the code ends, calculated as CodeStartPosition + MaxSize - 1 to not include the null byte.
-        /// Doesn't includes null byte. This is the offset before the null terminator
+        /// Gets the position where the code ends, calculated as CodeStartPosition + MaxSize
+        /// Minus 1 because the last byte is a null terminator.
         /// </summary>
         public int CodeEndPosition => CodeStartPosition + MaxSize - 1;
 
@@ -77,10 +77,10 @@ public RawFileNode(string name, byte[] buffer)
         public string FileName { get; set; }
 
         /// <summary>
-        /// Gets the position where the code ends, calculated as CodeStartPosition + MaxSize + 1 for the null byte.
-        /// Includes null byte. This is the offset after the null terminator
+        /// Gets the position where the code ends, calculated as CodeStartPosition + MaxSize
+        /// This is where the null terminator is at the end of the asset
         /// </summary>
-        public int RawFileEndPosition => CodeStartPosition + MaxSize + 1;
+        public int RawFileEndPosition => CodeStartPosition + MaxSize;
 
         /// <summary>
         /// The content of the file as a string.

Call of Duty FastFile Editor/Services/IO/ZoneFileIO.cs

@@ -23,14 +23,43 @@ public static uint ReadZoneFileSize(string path)
 
         /// <summary>
         /// Writes the updated zone file size (big-endian) to the header at the defined offset.
+        /// Also updates the EndOfFileDataPointer to stay in sync.
         /// </summary>
         public static void WriteZoneFileSize(string path, uint newSize)
         {
+            // Read the current EndOfFileDataPointer to calculate the offset from FileSize
+            uint currentFileSize = ReadZoneFileSize(path);
+            uint currentEndPointer = ReadEndOfFileDataPointer(path);
+
+            // Calculate the difference between EndOfFileDataPointer and FileSize
+            // This offset should remain constant when we update the size
+            uint pointerOffset = currentEndPointer - currentFileSize;
+            uint newEndPointer = newSize + pointerOffset;
+
             Span<byte> b = stackalloc byte[4];
-            System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(b, newSize);
             using var fs = new FileStream(path, FileMode.Open, FileAccess.Write);
+
+            // Write the new FileSize
+            System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(b, newSize);
             fs.Seek(ZoneFileHeaderConstants.ZoneSizeOffset, SeekOrigin.Begin);
             fs.Write(b);
+
+            // Write the new EndOfFileDataPointer
+            System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(b, newEndPointer);
+            fs.Seek(ZoneFileHeaderConstants.EndOfFileDataPointer, SeekOrigin.Begin);
+            fs.Write(b);
+        }
+
+        /// <summary>
+        /// Reads the EndOfFileDataPointer from the zone header (big-endian).
+        /// </summary>
+        public static uint ReadEndOfFileDataPointer(string path)
+        {
+            var b = new byte[4];
+            using var fs = new FileStream(path, FileMode.Open, FileAccess.Read);
+            fs.Seek(ZoneFileHeaderConstants.EndOfFileDataPointer, SeekOrigin.Begin);
+            fs.Read(b, 0, 4);
+            return System.Buffers.Binary.BinaryPrimitives.ReadUInt32BigEndian(b);
         }
     }
 }

Call of Duty FastFile Editor/Services/IRawFileService.cs

@@ -9,11 +9,19 @@ public interface IRawFileService
     {
         /// <summary>
         /// Exports the given raw file node to an external file with the specified extension.
+        /// Includes the zone header for re-injection compatibility.
         /// </summary>
         /// <param name="node">The raw file node to export.</param>
         /// <param name="extension">The file extension to use for the exported file (including the leading dot).</param>
         void ExportRawFile(RawFileNode node, string extension);
 
+        /// <summary>
+        /// Exports only the content of the raw file (without zone header) for external editing.
+        /// </summary>
+        /// <param name="node">The raw file node to export.</param>
+        /// <param name="extension">The file extension to use for the exported file.</param>
+        void ExportRawFileContentOnly(RawFileNode node, string extension);
+
         /// <summary>
         /// Overwrites the content of a raw file inside the zone file, padding or trimming as needed.
         /// </summary>
@@ -64,12 +72,21 @@ void RenameRawFile(
 
         /// <summary>
         /// Appends a brand‑new raw file entry to the end of the asset pool in the zone file.
+        /// The file must include the zone header (FF FF FF FF markers).
         /// </summary>
         /// <param name="zoneFilePath">Path to the decompressed Zone File (.zone).</param>
         /// <param name="filePath">Path to the external file to inject (must include its own header).</param>
         /// <param name="expectedSize">The expected data size for this entry.</param>
         void AppendNewRawFile(string zoneFilePath, string filePath, int expectedSize);
 
+        /// <summary>
+        /// Injects a plain file (without zone header) by creating the header structure.
+        /// </summary>
+        /// <param name="zoneFilePath">Path to the decompressed Zone File (.zone).</param>
+        /// <param name="filePath">Path to the plain file to inject.</param>
+        /// <param name="gamePath">The game path for this file (e.g., "maps/mp/gametypes/dm.gsc").</param>
+        void InjectPlainFile(string zoneFilePath, string filePath, string gamePath);
+
         /// <summary>
         /// Adjusts the maximum size of a raw file node by padding with zeros or shifting data.
         /// </summary>

Call of Duty FastFile Editor/Services/RawFileService.cs

@@ -44,6 +44,81 @@ public void AppendNewRawFile(string zoneFilePath, string filePath, int expectedS
             currentZone.ReadHeaderFields();
         }
 
+        /// <inheritdoc/>
+        public void InjectPlainFile(string zoneFilePath, string filePath, string gamePath)
+        {
+            // Read the plain file content
+            byte[] fileContent = File.ReadAllBytes(filePath);
+            int contentSize = fileContent.Length;
+
+            // Build the raw file entry with header:
+            // - 4 bytes: first marker (0xFFFFFFFF)
+            // - 4 bytes: data size (big-endian)
+            // - 4 bytes: second marker (0xFFFFFFFF)
+            // - N bytes: filename + null terminator
+            // - M bytes: file content
+            byte[] fileNameBytes = Encoding.ASCII.GetBytes(gamePath);
+            int headerSize = 12 + fileNameBytes.Length + 1; // 12 bytes markers/size + filename + null
+            int totalSize = headerSize + contentSize;
+
+            byte[] newEntry = new byte[totalSize];
+
+            // Write first marker (0xFFFFFFFF)
+            newEntry[0] = 0xFF;
+            newEntry[1] = 0xFF;
+            newEntry[2] = 0xFF;
+            newEntry[3] = 0xFF;
+
+            // Write data size (big-endian)
+            System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(
+                newEntry.AsSpan(4, 4),
+                (uint)contentSize
+            );
+
+            // Write second marker (0xFFFFFFFF)
+            newEntry[8] = 0xFF;
+            newEntry[9] = 0xFF;
+            newEntry[10] = 0xFF;
+            newEntry[11] = 0xFF;
+
+            // Write filename
+            Array.Copy(fileNameBytes, 0, newEntry, 12, fileNameBytes.Length);
+            // Null terminator is already 0x00 from array initialization
+
+            // Write content
+            Array.Copy(fileContent, 0, newEntry, headerSize, contentSize);
+
+            // Now inject the entry into the zone file
+            ZoneFile currentZone = RawFileNode.CurrentZone;
+            int insertPosition = currentZone.AssetPoolEndOffset;
+
+            currentZone.ModifyZoneFile(fs =>
+            {
+                long originalLength = fs.Length;
+                // Read tail data from the insertion point.
+                fs.Seek(insertPosition, SeekOrigin.Begin);
+                byte[] tailBuffer = new byte[originalLength - insertPosition];
+                fs.Read(tailBuffer, 0, tailBuffer.Length);
+                // Extend the file length.
+                fs.SetLength(originalLength + newEntry.Length);
+                // Shift tail data forward.
+                fs.Seek(insertPosition + newEntry.Length, SeekOrigin.Begin);
+                fs.Write(tailBuffer, 0, tailBuffer.Length);
+                // Write the new entry.
+                fs.Seek(insertPosition, SeekOrigin.Begin);
+                fs.Write(newEntry, 0, newEntry.Length);
+            });
+
+            // Update the zone file size header.
+            uint currentZoneSize = ZoneFileIO.ReadZoneFileSize(zoneFilePath);
+            uint newZoneSize = currentZoneSize + (uint)newEntry.Length;
+            ZoneFileIO.WriteZoneFileSize(zoneFilePath, newZoneSize);
+
+            // Refresh zone data and header.
+            currentZone.LoadData();
+            currentZone.ReadHeaderFields();
+        }
+
         /// <inheritdoc/>
         public void AdjustRawFileNodeSize(string zoneFilePath, RawFileNode rawFileNode, int newSize)
         {
@@ -105,10 +180,14 @@ public void AdjustRawFileNodeSize(string zoneFilePath, RawFileNode rawFileNode,
             uint currentZoneSize = ZoneFileIO.ReadZoneFileSize(zoneFilePath);
             uint updatedZoneSize = currentZoneSize + (uint)sizeIncrease;
             ZoneFileIO.WriteZoneFileSize(zoneFilePath, updatedZoneSize);
+
+            // Refresh zone header fields after modification.
+            currentZone.LoadData();
+            currentZone.ReadHeaderFields();
         }
 
         /// <summary>
-        /// Adjusts a raw file entry read from disk so that its header’s size field (at offset 4)
+        /// Adjusts a raw file entry read from disk so that its header's size field (at offset 4)
         /// matches the expected data size. It uses the known header structure:
         ///   Bytes 0-3: first marker (0xFFFFFFFF)
         ///   Bytes 4-7: data size (to be updated)
@@ -179,7 +258,7 @@ public void ExportRawFile(RawFileNode exportedRawFile, string fileExtension)
         {
             using var save = new SaveFileDialog
             {
-                Title = "Export File",
+                Title = "Export File (With Header for Re-injection)",
                 FileName = SanitizeFileName(exportedRawFile.FileName),
                 Filter = $"{fileExtension.TrimStart('.').ToUpper()} Files (*{fileExtension})|*{fileExtension}|All Files (*.*)|*.*"
             };
@@ -197,7 +276,47 @@ public void ExportRawFile(RawFileNode exportedRawFile, string fileExtension)
                 File.WriteAllBytes(save.FileName, slice);
 
                 MessageBox.Show(
-                    $"File successfully exported to:\n\n{save.FileName}",
+                    $"File successfully exported to:\n\n{save.FileName}\n\n" +
+                    "Note: This file includes the zone header and can be re-injected.",
+                    "Export Complete",
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Information
+                );
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(
+                    $"Failed to export file: {ex.Message}",
+                    "Export Error",
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Error
+                );
+            }
+        }
+
+        /// <inheritdoc/>
+        public void ExportRawFileContentOnly(RawFileNode exportedRawFile, string fileExtension)
+        {
+            using var save = new SaveFileDialog
+            {
+                Title = "Export Content Only",
+                FileName = SanitizeFileName(exportedRawFile.FileName),
+                Filter = $"{fileExtension.TrimStart('.').ToUpper()} Files (*{fileExtension})|*{fileExtension}|All Files (*.*)|*.*"
+            };
+
+            if (save.ShowDialog() != DialogResult.OK)
+                return;
+
+            try
+            {
+                // Export only the actual content (RawFileBytes), not the header
+                byte[] contentOnly = exportedRawFile.RawFileBytes;
+
+                File.WriteAllBytes(save.FileName, contentOnly);
+
+                MessageBox.Show(
+                    $"File content successfully exported to:\n\n{save.FileName}\n\n" +
+                    "Note: This file contains only the script content without zone header.",
                     "Export Complete",
                     MessageBoxButtons.OK,
                     MessageBoxIcon.Information
@@ -242,6 +361,12 @@ public void IncreaseSize(string zoneFilePath, RawFileNode rawFileNode, byte[] ne
                 }
                 fs.Seek(rawFileNode.CodeStartPosition, SeekOrigin.Begin);
                 fs.Write(newContent, 0, newSize);
+
+                // Update the size field in the raw file header (4 bytes at StartOfFileHeader + 4)
+                Span<byte> sizeBuf = stackalloc byte[4];
+                System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(sizeBuf, (uint)newSize);
+                fs.Seek(rawFileNode.StartOfFileHeader + 4, SeekOrigin.Begin);
+                fs.Write(sizeBuf);
             });
 
             rawFileNode.MaxSize = newSize;
@@ -251,6 +376,10 @@ public void IncreaseSize(string zoneFilePath, RawFileNode rawFileNode, byte[] ne
             uint currentZoneSize = ZoneFileIO.ReadZoneFileSize(zoneFilePath);
             uint newZoneSize = currentZoneSize + (uint)sizeIncrease;
             ZoneFileIO.WriteZoneFileSize(zoneFilePath, newZoneSize);
+
+            // Refresh zone header fields after modification
+            currentZone.LoadData();
+            currentZone.ReadHeaderFields();
         }
 
         /// <inheritdoc/>
@@ -331,6 +460,18 @@ public void RenameRawFile(TreeView filesTreeView, string ffFilePath, string zone
                         // Write the modified zone file back to disk.
                         File.WriteAllBytes(zoneFilePath, zoneFileData);
 
+                        // Update the zone file size header if the filename length changed.
+                        if (byteDifference != 0)
+                        {
+                            uint currentZoneSize = ZoneFileIO.ReadZoneFileSize(zoneFilePath);
+                            uint newZoneSize = (uint)((int)currentZoneSize + byteDifference);
+                            ZoneFileIO.WriteZoneFileSize(zoneFilePath, newZoneSize);
+
+                            // Refresh zone data and header fields.
+                            RawFileNode.CurrentZone.LoadData();
+                            RawFileNode.CurrentZone.ReadHeaderFields();
+                        }
+
                         // Save the old file name for notification.
                         string oldFileName = rawFileNode.FileName;
                         // Update the renamed file's FileName property.